MouseTrackingView-2.c

/*
    File:	MouseTrackingView-2.c
    
    Version:	1.0

    Disclaimer:	IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc.
		("Apple") in consideration of your agreement to the following terms, and your
		use, installation, modification or redistribution of this Apple software
		constitutes acceptance of these terms.  If you do not agree with these terms,
		please do not use, install, modify or redistribute this Apple software.

		In consideration of your agreement to abide by the following terms, and subject
		to these terms, Apple grants you a personal, non-exclusive license, under Apple’s
		copyrights in this original Apple software (the "Apple Software"), to use,
		reproduce, modify and redistribute the Apple Software, with or without
		modifications, in source and/or binary forms; provided that if you redistribute
		the Apple Software in its entirety and without modifications, you must retain
		this notice and the following text and disclaimers in all such redistributions of
		the Apple Software.  Neither the name, trademarks, service marks or logos of
		Apple Computer, Inc. may be used to endorse or promote products derived from the
		Apple Software without specific prior written permission from Apple.  Except as
		expressly stated in this notice, no other rights or licenses, express or implied,
		are granted by Apple herein, including but not limited to any patent rights that
		may be infringed by your derivative works or by other works in which the Apple
		Software may be incorporated.

		The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO
		WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
		WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
		COMBINATION WITH YOUR PRODUCTS.

		IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
		CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
		GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
		ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION
		OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT
		(INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN
		ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	Copyright © 2005 Apple Computer, Inc., All Rights Reserved
*/

/****************************************************************************************************
 * And this is the version with the "bells and whistles", to illustrate the following points:
 * - Use the sketched path as clip path (vs. the QD clipRgn)
 * - Use a 1x1 bitmap context for hit testing on the clipped portion (vs. PtInRgn)
 * - Drag the clipped image portion around, with transparency (vs. GWorlds, CopyBits, CopyDeepMask etc.)
 * - Use a maskedImage to remove the white background (vs. CopyBits, SearchProcs, BitmapToRegion etc.)
 ****************************************************************************************************/

#include "MouseTrackingView.h"

extern CGImageRef LoadImageFromMainBundle(CFStringRef imageName);


// A pointer to this per-view storage gets passed to the EventHandler as "userData".
struct MTViewData {
    HIViewRef		theView;
    CGImageRef		theImage;
    CGImageRef		maskedImage;
    CGMutablePathRef    thePath;
    HIPoint		selectionOffset;
    Boolean		pathBuildingDone;
    Boolean		hitSelection;
    Boolean		selectionMoveDone;
};
typedef struct MTViewData   MTViewData;

//-----------------------------------------------------------------------------------
// Two alternatives for "CreateMaskedImage", both available in 10.4 and later only:
// a) Use CGImageCreateWithMaskingColors
// b) Draw image into grayLevel bitmap context to be used as imageMask
//    and use CGImageCreateWithMask.
// Prior to 10.4, the mask would have to be worked into the alpha channel of the image.
 
#if 0
static CGImageRef CreateMaskedImage(CGImageRef image)
{
    const float maskingMinMax[] = { 220, 255, 220, 255, 220, 255 };
    CGImageRef maskedImage = CGImageCreateWithMaskingColors(image, maskingMinMax);
    return maskedImage;
}

#else

static void FreePixelData(void *info, const void *data, size_t size)
{
    free((void*)data);
}

static void FixOpaqueness(uint8_t* p, size_t n)
{
    const uint8_t kCutOff = 220;
    while (n-- > 0)
    {
	uint8_t v = *p;
	if (v < kCutOff)
	    v = 0;
	*p++ = v;
    }
}

static CGImageRef CreateMaskedImage(CGImageRef image)
{
    // Draw the image into a grayLevel bitmap context to produce a mask
    size_t width = CGImageGetWidth(image);
    size_t height = CGImageGetHeight(image);
    size_t dataSize = width * height;	    // 1 byte per pixel
    void* data = malloc(dataSize);
    CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceGray();
    // Ironically, due to a bug in CGImageCreateWithMask, you cannot use 
    // CGColorSpaceCreateWithName(kCGColorSpaceGenericGray) at this point!
    
    CGContextRef ctx = CGBitmapContextCreate(data, width, height, 8, width, colorspace, kCGImageAlphaNone);
    CGContextDrawImage(ctx, CGRectMake(0, 0, width, height), image);
    CGContextRelease(ctx);
    FixOpaqueness(data, dataSize);
    CGDataProviderRef provider = CGDataProviderCreateWithData(NULL, data, dataSize, FreePixelData);
    const float decode[] = { 1.0, 0.0 };    // need to inverse gray levels
    CGImageRef imageMask = CGImageCreate(width, height, 8, 8, width, colorspace, kCGImageAlphaNone, provider, decode, false, kCGRenderingIntentDefault);
    CGColorSpaceRelease(colorspace);
    CGDataProviderRelease(provider);

    CGImageRef maskedImage = CGImageCreateWithMask(image, imageMask);
    CGImageRelease(imageMask);
    
    return maskedImage;
}
#endif

//-----------------------------------------------------------------------------------
// Called for each CGPathElement when scanning the CGPath in CGPathApply()
static void MyCGPathApplier(void* info, const CGPathElement* element)
{
    CGContextRef ctx = (CGContextRef)info;
    switch (element->type)
    {
	case kCGPathElementMoveToPoint:
	    CGContextMoveToPoint(ctx, element->points[0].x, element->points[0].y);
	    break;
		
	case kCGPathElementAddLineToPoint:
	    CGContextAddLineToPoint(ctx, element->points[0].x, element->points[0].y);
	    break;
	
	default:	// we know our path only contains line segments
	    break;
    }
}

//-----------------------------------------------------------------------------------
static void DrawTheMTView(CGContextRef ctx, MTViewData* data)
{
    CGRect dstRect;

    if ((data->theImage == NULL) || (data->maskedImage == NULL))
	return;
	
    // Fill background
#if 1
    HIViewGetBounds(data->theView, &dstRect);
    CGContextSetRGBFillColor(ctx, 0.5, 1, 0.5, 1);
    CGContextFillRect(ctx, dstRect);
#endif

    // Draw the image first, before stroking the path; otherwise the path gets overwritten

    dstRect = CGRectMake(0, 0, CGImageGetWidth(data->theImage), CGImageGetHeight(data->theImage));
    HIViewDrawCGImage(ctx, &dstRect, data->maskedImage);
    
    // If we already hit the selection, remove the selection from the original image.
    // Because we apply a clip, save and restore the GState.
    CGContextSaveGState(ctx);
    if (data->hitSelection)
    {
	CGPathApply(data->thePath, ctx, MyCGPathApplier);
	CGContextClip(ctx);
	CGContextSetRGBFillColor(ctx, 1, 1, 1, 1);
	CGContextFillRect(ctx, dstRect);
    }
    CGContextRestoreGState(ctx);
    
    // Draw our selection path only as long as we have not hit the selection
    if (!data->hitSelection && (data->thePath != NULL))
    {
	CGPathApply(data->thePath, ctx, MyCGPathApplier);
	CGContextStrokePath(ctx);
    }
   
    if (data->pathBuildingDone)
    {
//	CGContextSaveGState(ctx); -- not necessary here: the HIView system saves and restores the GState from the outside
	CGContextTranslateCTM(ctx, data->selectionOffset.x, data->selectionOffset.y);
	CGPathApply(data->thePath, ctx, MyCGPathApplier);
	CGContextClip(ctx);
	if (!data->selectionMoveDone)	// while we are dragging, use some transparency for the image drawing
	    CGContextSetAlpha(ctx, 0.5);
	HIViewDrawCGImage(ctx, &dstRect, data->maskedImage);
//	CGContextRestoreGState(ctx);
    }
}   // DrawTheMTView


// -----------------------------------------------------------------------------
static HIPoint QDGlobalToHIViewLocal( const Point inGlobalPoint, const HIViewRef inTheView)
{                               
    HIPoint viewPoint = CGPointMake(inGlobalPoint.h, inGlobalPoint.v);

    HIPointConvert(&viewPoint, kHICoordSpace72DPIGlobal, NULL, kHICoordSpaceView, inTheView);
    return viewPoint;
}

// -----------------------------------------------------------------------------
static OSStatus	DoTheHitTest(EventRef inEvent, MTViewData* data)
{
    HIPoint where;
    ControlPartCode part = kControlContentMetaPart;
    
    GetEventParameter(inEvent, kEventParamMouseLocation, typeHIPoint, NULL, sizeof(HIPoint), NULL, &where);
    SetEventParameter(inEvent, kEventParamControlPart, typeControlPartCode, sizeof(ControlPartCode), &part);
    
    // If we hit a previously clipped image portion described by data->thePath, indicate it so we can start 
    // dragging it around inside "DoTheTracking"
    
    if (data->pathBuildingDone)	// i.e. we have finished data->thePath to use it as grab selection
    {
	// Create 1x1 BitmapContext
	CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
	CGBitmapInfo bitmapInfo = kCGImageAlphaNoneSkipFirst;
	UInt32	thePixel = 0;
	CGContextRef bmpCtx = CGBitmapContextCreate(&thePixel, 1, 1, 8, 4, colorspace, bitmapInfo);

	// Move it to "where"
	CGContextTranslateCTM(bmpCtx, -where.x, -where.y);

	// Fill the path and ...
	CGPathApply(data->thePath, bmpCtx, MyCGPathApplier);
	CGContextFillPath(bmpCtx);
	
	// ... check whether we have touched thePixel
	data->hitSelection = (thePixel != 0);
	
	CGColorSpaceRelease(colorspace);
	CGContextRelease(bmpCtx);
    }
    
    return noErr;
}   // DoTheHitTest

// -----------------------------------------------------------------------------
static void DragImageSelectionAround(EventRef inEvent, MTViewData* data)
{
    HIPoint startPt;
    
    // Extract the mouse location (local coordinates!)
    GetEventParameter(inEvent, kEventParamMouseLocation, typeHIPoint, NULL, sizeof(HIPoint), NULL, &startPt);
    
    data->selectionMoveDone = false;

    while (true)
    {
	MouseTrackingResult mouseResult;
	Point		    qdPt;
	
	// Watch the mouse for change: qdPt comes back in global coordinates!
	TrackMouseLocation((GrafPtr)(-1), &qdPt, &mouseResult);

	// Bail out when the mouse is released
	if ( mouseResult == kMouseTrackingMouseReleased )
	{
	    data->selectionMoveDone = true;
	    break;
	}
	
	// Need to convert from global
	HIPoint where = QDGlobalToHIViewLocal(qdPt, data->theView);
	data->selectionOffset.x = where.x - startPt.x;
	data->selectionOffset.y = where.y - startPt.y;

	ControlPartCode part = 0;
	SetEventParameter(inEvent, kEventParamControlPart, typeControlPartCode, sizeof(ControlPartCode), &part); 

	HIViewSetNeedsDisplay(data->theView, true);
    }
}   // DragImageSelectionAround

// -----------------------------------------------------------------------------
static void BuildPolygonPath(EventRef inEvent, MTViewData* data)
{
    MouseTrackingResult	mouseResult;
    Point		qdPt;
    HIPoint		where;
    CGAffineTransform m = CGAffineTransformIdentity;
    // Reset the path
    if (data->thePath != NULL)
	CGPathRelease(data->thePath);
    
    data->thePath = CGPathCreateMutable();
    data->pathBuildingDone = false;
    data->hitSelection = false;
    data->selectionOffset.x = data->selectionOffset.y = 0;
    
    // Extract the mouse location (local coordinates!)
    GetEventParameter(inEvent, kEventParamMouseLocation, typeHIPoint, NULL, sizeof(HIPoint), NULL, &where);
    CGPathMoveToPoint(data->thePath, &m, where.x, where.y);
    
    while (true)
    {
	// Watch the mouse for change: qdPt comes back in global coordinates!
	TrackMouseLocation((GrafPtr)(-1), &qdPt, &mouseResult);

	// Bail out when the mouse is released
	if ( mouseResult == kMouseTrackingMouseReleased )
	{
	    data->pathBuildingDone = true;
	    break;
	}
	
	// Need to convert from global
	where = QDGlobalToHIViewLocal(qdPt, data->theView);
	CGPathAddLineToPoint(data->thePath, &m, where.x, where.y);

	ControlPartCode part = 0;
	SetEventParameter(inEvent, kEventParamControlPart, typeControlPartCode, sizeof(ControlPartCode), &part); 

	HIViewSetNeedsDisplay(data->theView, true);
    }
}   // BuildPolygonPath

//-----------------------------------------------------------------------------------
static OSStatus DoTheTracking(EventRef inEvent, MTViewData* data)
{
    // If we hit an image selection, drag it around, else build a path
    if (data->hitSelection)
	DragImageSelectionAround(inEvent, data);
    else
	BuildPolygonPath(inEvent, data);

    // One final redisplay
    HIViewSetNeedsDisplay(data->theView, true);
    
    // Send back the part upon which the mouse was released
    ControlPartCode part = kControlEntireControl;
    SetEventParameter(inEvent, kEventParamControlPart, typeControlPartCode, sizeof(ControlPartCode), &part);
    return noErr; 
}

//-----------------------------------------------------------------------------------
static OSStatus DoHIObjectBusiness(EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData)
{
    MTViewData* data;
    OSStatus	err = eventNotHandledErr;
    switch ( GetEventKind(inEvent) )
    {
	case kEventHIObjectConstruct:
	{
	    data = (MTViewData*)malloc(sizeof(MTViewData));
	    // Follow the usual mechanism of setting our data as EventParameter, after recovering data->theView.
	    err = GetEventParameter( inEvent, kEventParamHIObjectInstance, typeHIObjectRef, NULL, sizeof(HIObjectRef*), NULL, &data->theView );
	    require_noerr( err, ParameterMissing );

	    SetEventParameter( inEvent, kEventParamHIObjectInstance, typeVoidPtr, sizeof(MTViewData), &data ); 
	}
	break;
	
	case kEventHIObjectInitialize:
	err = CallNextEventHandler( inCallRef, inEvent );
	if ( err == noErr )
	{
	    data = (MTViewData*)inUserData;
	    Rect bounds;
	    // Extract the bounds from the initialization event that we set up in CreateMouseTrackingView
	    err = GetEventParameter(inEvent, kCanvasBoundsParam, typeQDRectangle, NULL, sizeof(Rect), NULL, &bounds);
	    require_noerr(err, ParameterMissing);
	    SetControlBounds(data->theView, &bounds);
	    
	    // Also initialize our MTViewData
	    data->theImage = LoadImageFromMainBundle(CFSTR("Peter.png"));
	    data->maskedImage = CreateMaskedImage(data->theImage);
	    data->thePath = NULL;
	    data->selectionOffset.x = data->selectionOffset.y = 0;
	    data->pathBuildingDone = false;
	    data->hitSelection = false;
	    data->selectionMoveDone = false;
	}
	break;
	
	case kEventHIObjectDestruct:
	{
	    CGImageRelease(data->theImage);
	    CGImageRelease(data->maskedImage);
	    CGPathRelease(data->thePath);
	    free(inUserData);
	}
	break;
    }
    
ParameterMissing:
    return err;
}   // DoHIObjectBusiness

//-----------------------------------------------------------------------------------
static OSStatus
MTViewHandler( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData )
{
    OSStatus	    err = eventNotHandledErr;
	    
    switch ( GetEventClass(inEvent) )
    {
	case kEventClassHIObject:
	    err = DoHIObjectBusiness(inCallRef, inEvent, inUserData);
	    break;

	case kEventClassControl:
	{
	    MTViewData* data = (MTViewData*)inUserData;
	    switch ( GetEventKind(inEvent) )
	    {
		case kEventControlDraw:
		{
		    CGContextRef ctx;
		    GetEventParameter( inEvent, kEventParamCGContextRef, typeCGContextRef, NULL, sizeof(CGContextRef), NULL, &ctx );

		    CallNextEventHandler(inCallRef, inEvent);	// not really needed, here
		    DrawTheMTView(ctx, data);
		    err = noErr;
		}
		break;
		
		case kEventControlHitTest:
		    err = DoTheHitTest(inEvent, data);
		    break;

		case kEventControlTrack:
		    err = DoTheTracking(inEvent, data);
		    break;
	    }	// switch
	}
	break;	// kEventClassControl
    }	// switch
    return err;
}   // MTViewHandler


//----------------------------------------------------------------------------------- the usual boilerplate stuff
static OSStatus MyMTViewRegister(CFStringRef myClassID)
{
    OSStatus                err = noErr;
    static HIObjectClassRef sMyViewClassRef = NULL;
	
    if ( sMyViewClassRef == NULL )
    {
        EventTypeSpec eventList[] = {
            { kEventClassHIObject, kEventHIObjectConstruct },
            { kEventClassHIObject, kEventHIObjectInitialize },
            { kEventClassHIObject, kEventHIObjectDestruct },

            { kEventClassControl, kEventControlDraw },
            { kEventClassControl, kEventControlHitTest },
	    { kEventClassControl, kEventControlTrack },
	};
		
        err = HIObjectRegisterSubclass( myClassID,
					kHIViewClassID,					// base class ID
					0,						// option bits
					MTViewHandler,					// construct proc
					GetEventTypeCount( eventList ),
					eventList,
					NULL,						// construct data
					&sMyViewClassRef );
    }
    return err;
}

//-----------------------------------------------------------------------------------
OSStatus 
CreateMouseTrackingView(HIViewRef parentView, const Rect* inBounds, HIViewID* inViewID)
{
    #define kCanvasClassID	CFSTR( "com.apple.sample.canvasview" )

    OSStatus	err;
    EventRef	event;
    HIViewRef	theView;
	
    // Register this class
    err = MyMTViewRegister(kCanvasClassID); 
    require_noerr( err, CantRegister );
	
    // Make an initialization event
    err = CreateEvent( NULL, kEventClassHIObject, kEventHIObjectInitialize, GetCurrentEventTime(), 0, &event ); 
    require_noerr( err, CantCreateEvent );
        
    // If bounds were specified, push them into the initialization event
    // so that they can be used in the initialization handler.
    if ( inBounds != NULL )
    {
        err = SetEventParameter(event, kCanvasBoundsParam, typeQDRectangle, sizeof(Rect), inBounds);
        require_noerr( err, CantSetParameter );
    }
    err = HIObjectCreate(kCanvasClassID, event, (HIObjectRef*)&theView);
    require_noerr(err, CantCreate);
	
    if (parentView != NULL) 
    {
        err = HIViewAddSubview(parentView, theView);
    }

    SetControlID(theView, inViewID);	// useful if a handler needs to call GetControlByID()
    HIViewSetVisible(theView, true);
	
CantCreate:
CantSetParameter:
CantCreateEvent:
    ReleaseEvent( event );
	
CantRegister:
    return err;
}   // CreateMouseTrackingView