VuoGraphicsView.m

Go to the documentation of this file.

 
#import "VuoGraphicsView.h"
#import "VuoGraphicsLayer.h"
 
#ifdef VUO_COMPILER
VuoModuleMetadata({
    "title" : "VuoGraphicsView",
    "dependencies" : [
        "VuoGraphicsLayer",
    ]
});
#endif
 
@interface VuoGraphicsView ()
@property(retain) NSImage *circleImage; 
@property NSRect circleRect;            
 
@property NSMutableSet *touchTriggers;  
@property NSMutableSet *zoomedTriggers;  
@property NSMutableSet *swipedLeftTriggers;  
@property NSMutableSet *swipedRightTriggers;  
@end
 
@implementation VuoGraphicsView
 
- (instancetype)init
{
    if (self = [super init])
    {
        self.wantsLayer = true;
 
        self.allowedTouchTypes = NSTouchTypeMaskIndirect;
        self.wantsRestingTouches = YES;
        _touchTriggers = [NSMutableSet new];
        _zoomedTriggers = [NSMutableSet new];
        _swipedLeftTriggers = [NSMutableSet new];
        _swipedRightTriggers = [NSMutableSet new];
 
        // Prepare the circle mouse cursor.
        {
            _circleRect = NSMakeRect(0,0,48,48);
            _circleImage = [[NSImage alloc] initWithSize:_circleRect.size];
            [_circleImage lockFocus];
            {
                [[NSColor colorWithDeviceWhite:1 alpha:0.75] setFill];
                [[NSColor colorWithDeviceWhite:0 alpha:0.15] setStroke];
                NSBezierPath *circlePath = [NSBezierPath bezierPathWithOvalInRect:NSInsetRect(_circleRect, 1, 1)];
                [circlePath fill];
                [circlePath stroke];
            }
            [_circleImage unlockFocus];
        }
    }
    return self;
}
 
- (void)viewDidMoveToWindow
{
    if (!self.window)
        return;
 
    _viewport = self.frame;
}
 
- (void)viewDidChangeBackingProperties
{
    VuoGraphicsLayer *l = (VuoGraphicsLayer *)self.layer;
    [l viewDidChangeBackingProperties];
    [l setNeedsDisplay];
}
 
- (void)resetCursorRects
{
    VuoGraphicsWindow *gw = (VuoGraphicsWindow *)self.window;
    VuoCursor cursor = gw.cursor;
    NSCursor *nsCursor = nil;
 
    if (cursor == VuoCursor_None)
    {
        NSImage *im = [[NSImage alloc] initWithSize:NSMakeSize(1,1)];
        nsCursor = [[[NSCursor alloc] initWithImage:im hotSpot:NSMakePoint(0,0)] autorelease];
        [im release];
    }
    else if (cursor == VuoCursor_Pointer)
        nsCursor = [NSCursor arrowCursor];
    else if (cursor == VuoCursor_Crosshair)
        nsCursor = [NSCursor crosshairCursor];
    else if (cursor == VuoCursor_HandOpen)
        nsCursor = [NSCursor openHandCursor];
    else if (cursor == VuoCursor_HandClosed)
        nsCursor = [NSCursor closedHandCursor];
    else if (cursor == VuoCursor_IBeam)
        nsCursor = [NSCursor IBeamCursor];
    else if (cursor == VuoCursor_Circle)
        nsCursor = [[[NSCursor alloc] initWithImage:_circleImage hotSpot:NSMakePoint(NSMidX(_circleRect),NSMidY(_circleRect))] autorelease];
 
    if (nsCursor)
        [self addCursorRect:[self visibleRect] cursor:nsCursor];
}
 
- (BOOL)acceptsFirstResponder
{
    return YES;
}
 
- (BOOL)mouseDownCanMoveWindow
{
    return NO;
}
 
- (void)dealloc
{
    [_circleImage release];
    [super dealloc];
}
 
static NSInteger VuoGraphicsView_touchComparator(NSTouch *a, NSTouch *b, void *p)
{
    float ax = a.normalizedPosition.x;
    float bx = b.normalizedPosition.x;
    if (ax < bx)
        return -1;
    else if (ax > bx)
        return 1;
    else
        return 0;
}
 
- (void)fireTouches:(NSEvent *)e
{
    NSSet *touchesSet = [e touchesMatchingPhase:NSTouchPhaseAny inView:nil];
    NSArray *orderedTouches = [touchesSet.allObjects sortedArrayUsingFunction:VuoGraphicsView_touchComparator context:nil];
 
    VuoList_VuoPoint2d touches = VuoListCreateWithCount_VuoPoint2d(orderedTouches.count, (VuoPoint2d){0,0});
    VuoPoint2d *touchPoints = VuoListGetData_VuoPoint2d(touches);
    int i = 0;
    for (NSTouch *t in orderedTouches)
        touchPoints[i++] = (VuoPoint2d){
            t.normalizedPosition.x * 2 - 1,
            (t.normalizedPosition.y * 2 - 1) * (t.deviceSize.height / t.deviceSize.width)
        };
 
    dispatch_async(dispatch_get_main_queue(), ^{
        for (NSValue *v in self.touchTriggers)
        {
            void (*touchesMoved)(VuoList_VuoPoint2d) = v.pointerValue;
            if (touchesMoved)
                touchesMoved(touches);
        }
    });
}
- (void)touchesBeganWithEvent:(NSEvent *)event
{
    [self fireTouches:event];
}
- (void)touchesMovedWithEvent:(NSEvent *)event
{
    [self fireTouches:event];
}
- (void)touchesEndedWithEvent:(NSEvent *)event
{
    [self fireTouches:event];
}
- (void)touchesCancelledWithEvent:(NSEvent *)event
{
    [self fireTouches:event];
}
 
- (void)magnifyWithEvent:(NSEvent *)event
{
    if (event.magnification != 0)
        dispatch_async(dispatch_get_main_queue(), ^{
            for (NSValue *v in self.zoomedTriggers)
            {
                void (*zoomed)(VuoReal) = v.pointerValue;
                if (zoomed)
                    zoomed(event.magnification);
            }
        });
}
 
- (void)swipeWithEvent:(NSEvent *)event
{
    if (event.deltaX > 0)
        dispatch_async(dispatch_get_main_queue(), ^{
            for (NSValue *v in self.swipedLeftTriggers)
            {
                void (*swipedLeft)(void) = v.pointerValue;
                if (swipedLeft)
                    swipedLeft();
            }
        });
    else if (event.deltaX < 0)
        dispatch_async(dispatch_get_main_queue(), ^{
            for (NSValue *v in self.swipedRightTriggers)
            {
                void (*swipedRight)(void) = v.pointerValue;
                if (swipedRight)
                    swipedRight();
            }
        });
}
 
- (void)addTouchesMovedTrigger:(void (*)(VuoList_VuoPoint2d))touchesMoved
    zoomed:(void (*)(VuoReal))zoomed
    swipedLeft:(void (*)(void))swipedLeft
    swipedRight:(void (*)(void))swipedRight
{
    dispatch_async(dispatch_get_main_queue(), ^{
        [self.touchTriggers addObject:[NSValue valueWithPointer:touchesMoved]];
        [self.zoomedTriggers addObject:[NSValue valueWithPointer:zoomed]];
        [self.swipedLeftTriggers addObject:[NSValue valueWithPointer:swipedLeft]];
        [self.swipedRightTriggers addObject:[NSValue valueWithPointer:swipedRight]];
    });
}
 
- (void)removeTouchesMovedTrigger:(void (*)(VuoList_VuoPoint2d))touchesMoved
    zoomed:(void (*)(VuoReal))zoomed
    swipedLeft:(void (*)(void))swipedLeft
    swipedRight:(void (*)(void))swipedRight
{
    dispatch_async(dispatch_get_main_queue(), ^{
        for (NSValue *v in self.touchTriggers)
            if (v.pointerValue == touchesMoved)
                [self.touchTriggers removeObject:v];
        for (NSValue *v in self.zoomedTriggers)
            if (v.pointerValue == zoomed)
                [self.zoomedTriggers removeObject:v];
        for (NSValue *v in self.swipedLeftTriggers)
            if (v.pointerValue == swipedLeft)
                [self.swipedLeftTriggers removeObject:v];
        for (NSValue *v in self.swipedRightTriggers)
            if (v.pointerValue == swipedRight)
                [self.swipedRightTriggers removeObject:v];
    });
}
@end