@amazon-devices/react-native-gesture-handler 2.0.9000000000 → 4.0.0-rn-83

package/apple/Handlers/RNPinchHandler.m

@@ -0,0 +1,186 @@
+
+
+//
+//  RNPinchHandler.m
+//  RNGestureHandler
+//
+//  Created by Krzysztof Magiera on 12/10/2017.
+//  Copyright © 2017 Software Mansion. All rights reserved.
+//
+
+#import "RNPinchHandler.h"
+
+#if !TARGET_OS_TV
+
+#if TARGET_OS_OSX
+@interface RNBetterPinchRecognizer : NSMagnificationGestureRecognizer {
+  CGFloat prevMagnification;
+  NSTimeInterval prevTime;
+}
+
+@property (nonatomic, readonly) CGFloat velocity;
+#else
+@interface RNBetterPinchRecognizer : UIPinchGestureRecognizer
+#endif
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
+
+@end
+
+@implementation RNBetterPinchRecognizer {
+  __weak RNGestureHandler *_gestureHandler;
+}
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler
+{
+  if ((self = [super initWithTarget:self action:@selector(handleGesture:)])) {
+    _gestureHandler = gestureHandler;
+  }
+#if TARGET_OS_OSX
+  prevMagnification = 0;
+  prevTime = 0;
+#endif
+  return self;
+}
+
+- (void)handleGesture:(UIGestureRecognizer *)recognizer
+{
+  if (self.state == UIGestureRecognizerStateBegan) {
+#if TARGET_OS_OSX
+    self.magnification = 1;
+#else
+    self.scale = 1;
+#endif
+  }
+  [_gestureHandler handleGesture:recognizer];
+}
+
+- (void)interactionsBegan:(NSSet *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesBegan:touches withEvent:event];
+}
+
+- (void)interactionsMoved:(NSSet *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesMoved:touches withEvent:event];
+}
+
+- (void)interactionsEnded:(NSSet *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
+}
+
+- (void)interactionsCancelled:(NSSet *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
+}
+
+#if TARGET_OS_OSX
+- (void)magnifyWithEvent:(NSEvent *)event
+{
+  [super magnifyWithEvent:event];
+
+  switch (self.state) {
+    case NSGestureRecognizerStateBegan:
+      [_gestureHandler setCurrentPointerTypeToMouse];
+      [self interactionsBegan:[NSSet setWithObject:event] withEvent:event];
+      break;
+    case NSGestureRecognizerStateChanged:
+      [self interactionsMoved:[NSSet setWithObject:event] withEvent:event];
+      break;
+    case NSGestureRecognizerStateEnded:
+      [self interactionsEnded:[NSSet setWithObject:event] withEvent:event];
+      break;
+    case NSGestureRecognizerStateCancelled:
+      [self interactionsCancelled:[NSSet setWithObject:event] withEvent:event];
+      break;
+  }
+
+  _velocity = (self.magnification - prevMagnification) / ((event.timestamp - prevTime) * 1000);
+  prevMagnification = self.magnification;
+  prevTime = event.timestamp;
+}
+#else
+- (void)touchesBegan:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler setCurrentPointerType:event];
+  [super touchesBegan:touches withEvent:event];
+  [self interactionsBegan:touches withEvent:event];
+}
+
+- (void)touchesMoved:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesMoved:touches withEvent:event];
+  [self interactionsMoved:touches withEvent:event];
+}
+
+- (void)touchesEnded:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesEnded:touches withEvent:event];
+  [self interactionsEnded:touches withEvent:event];
+}
+
+- (void)touchesCancelled:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesCancelled:touches withEvent:event];
+  [self interactionsCancelled:touches withEvent:event];
+}
+#endif
+
+- (void)reset
+{
+  [_gestureHandler.pointerTracker reset];
+  [super reset];
+  [_gestureHandler reset];
+}
+
+@end
+#endif
+
+@implementation RNPinchGestureHandler
+
+- (instancetype)initWithTag:(NSNumber *)tag
+{
+  if ((self = [super initWithTag:tag])) {
+#if !TARGET_OS_TV
+    _recognizer = [[RNBetterPinchRecognizer alloc] initWithGestureHandler:self];
+#endif
+  }
+  return self;
+}
+
+#if !TARGET_OS_TV
+
+#if TARGET_OS_OSX
+- (RNGestureHandlerEventExtraData *)eventExtraData:(NSMagnificationGestureRecognizer *)recognizer
+{
+  return [RNGestureHandlerEventExtraData forPinch:recognizer.magnification
+                                   withFocalPoint:[recognizer locationInView:recognizer.view]
+                                     withVelocity:((RNBetterPinchRecognizer *)recognizer).velocity
+                              withNumberOfTouches:2
+                                  withPointerType:RNGestureHandlerMouse];
+}
+#else
+- (RNGestureHandlerEventExtraData *)eventExtraData:(UIPinchGestureRecognizer *)recognizer
+{
+  CGPoint accumulatedPoint = CGPointZero;
+
+  for (int i = 0; i < recognizer.numberOfTouches; i++) {
+    CGPoint location = [recognizer locationOfTouch:i inView:recognizer.view];
+    accumulatedPoint.x += location.x;
+    accumulatedPoint.y += location.y;
+  }
+
+  CGPoint focalPoint =
+      CGPointMake(accumulatedPoint.x / recognizer.numberOfTouches, accumulatedPoint.y / recognizer.numberOfTouches);
+
+  return [RNGestureHandlerEventExtraData forPinch:recognizer.scale
+                                   withFocalPoint:focalPoint
+                                     withVelocity:recognizer.velocity
+                              withNumberOfTouches:recognizer.numberOfTouches
+                                  withPointerType:_pointerType];
+}
+#endif
+#endif // !TARGET_OS_TV
+
+@end

package/apple/Handlers/RNRotationHandler.m

@@ -0,0 +1,169 @@
+//
+//  RNRotationHandler.m
+//  RNGestureHandler
+//
+//  Created by Krzysztof Magiera on 12/10/2017.
+//  Copyright © 2017 Software Mansion. All rights reserved.
+//
+
+#import "RNRotationHandler.h"
+
+#if !TARGET_OS_TV
+
+#if TARGET_OS_OSX
+@interface RNBetterRotationRecognizer : NSRotationGestureRecognizer {
+  CGFloat prevRotation;
+  NSTimeInterval prevTime;
+}
+
+@property (nonatomic, readonly) CGFloat velocity;
+#else
+@interface RNBetterRotationRecognizer : UIRotationGestureRecognizer
+#endif
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
+
+@end
+
+@implementation RNBetterRotationRecognizer {
+  __weak RNGestureHandler *_gestureHandler;
+}
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler
+{
+  if ((self = [super initWithTarget:self action:@selector(handleGesture:)])) {
+    _gestureHandler = gestureHandler;
+  }
+#if TARGET_OS_OSX
+  prevRotation = 0;
+  prevTime = 0;
+#endif
+  return self;
+}
+
+- (void)handleGesture:(UIGestureRecognizer *)recognizer
+{
+  if (self.state == UIGestureRecognizerStateBegan) {
+    self.rotation = 0;
+  }
+  [_gestureHandler handleGesture:recognizer];
+}
+
+- (void)interactionsBegan:(NSSet *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesBegan:touches withEvent:event];
+}
+
+- (void)interactionsMoved:(NSSet *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesMoved:touches withEvent:event];
+}
+
+- (void)interactionsEnded:(NSSet *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
+}
+
+- (void)interactionsCancelled:(NSSet *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
+}
+
+#if TARGET_OS_OSX
+- (void)rotateWithEvent:(NSEvent *)event
+{
+  [super rotateWithEvent:event];
+
+  switch (self.state) {
+    case NSGestureRecognizerStateBegan:
+      [_gestureHandler setCurrentPointerTypeToMouse];
+      [self interactionsBegan:[NSSet setWithObject:event] withEvent:event];
+      break;
+    case NSGestureRecognizerStateChanged:
+      [self interactionsMoved:[NSSet setWithObject:event] withEvent:event];
+      break;
+    case NSGestureRecognizerStateEnded:
+      [self interactionsEnded:[NSSet setWithObject:event] withEvent:event];
+      break;
+    case NSGestureRecognizerStateCancelled:
+      [self interactionsCancelled:[NSSet setWithObject:event] withEvent:event];
+      break;
+  }
+
+  _velocity = (self.rotation - prevRotation) / ((event.timestamp - prevTime) * 1000);
+  prevRotation = self.rotation;
+  prevTime = event.timestamp;
+}
+#else
+- (void)touchesBegan:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler setCurrentPointerType:event];
+  [super touchesBegan:touches withEvent:event];
+  [self interactionsBegan:touches withEvent:event];
+}
+
+- (void)touchesMoved:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesMoved:touches withEvent:event];
+  [self interactionsMoved:touches withEvent:event];
+}
+
+- (void)touchesEnded:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesEnded:touches withEvent:event];
+  [self interactionsEnded:touches withEvent:event];
+}
+
+- (void)touchesCancelled:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesCancelled:touches withEvent:event];
+  [self interactionsCancelled:touches withEvent:event];
+}
+#endif
+
+- (void)reset
+{
+  [_gestureHandler.pointerTracker reset];
+  [super reset];
+  [_gestureHandler reset];
+}
+
+@end
+#endif
+
+@implementation RNRotationGestureHandler
+
+- (instancetype)initWithTag:(NSNumber *)tag
+{
+  if ((self = [super initWithTag:tag])) {
+#if !TARGET_OS_TV
+    _recognizer = [[RNBetterRotationRecognizer alloc] initWithGestureHandler:self];
+#endif
+  }
+  return self;
+}
+
+#if !TARGET_OS_TV
+
+#if TARGET_OS_OSX
+- (RNGestureHandlerEventExtraData *)eventExtraData:(NSRotationGestureRecognizer *)recognizer
+{
+  return [RNGestureHandlerEventExtraData forRotation:-recognizer.rotation
+                                     withAnchorPoint:[recognizer locationInView:recognizer.view]
+                                        withVelocity:((RNBetterRotationRecognizer *)recognizer).velocity
+                                 withNumberOfTouches:2
+                                     withPointerType:RNGestureHandlerMouse];
+}
+#else
+- (RNGestureHandlerEventExtraData *)eventExtraData:(UIRotationGestureRecognizer *)recognizer
+{
+  return [RNGestureHandlerEventExtraData forRotation:recognizer.rotation
+                                     withAnchorPoint:[recognizer locationInView:recognizer.view]
+                                        withVelocity:recognizer.velocity
+                                 withNumberOfTouches:recognizer.numberOfTouches
+                                     withPointerType:_pointerType];
+}
+#endif
+#endif // !TARGET_OS_TV
+
+@end

package/{ios → apple}/Handlers/RNTapHandler.m

@@ -8,7 +8,9 @@
 
 #import "RNTapHandler.h"
 
+#if !TARGET_OS_OSX
 #import <UIKit/UIGestureRecognizerSubclass.h>
+#endif
 
 #import <React/RCTConvert.h>
 
@@ -69,9 +71,8 @@ static const NSTimeInterval defaultMaxDuration = 0.5;
   self.enabled = NO;
 }
 
-- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+- (void)interactionsBegan:(NSSet *)touches withEvent:(UIEvent *)event
 {
-  [super touchesBegan:touches withEvent:event];
   [_gestureHandler.pointerTracker touchesBegan:touches withEvent:event];
 
   if (_tapsSoFar == 0) {
@@ -79,7 +80,11 @@ static const NSTimeInterval defaultMaxDuration = 0.5;
     // is called (it resets the gesture handler), making it send whatever the last known state as oldState
     // in the event. If we reset it here it correctly sends UNDETERMINED as oldState.
     [_gestureHandler reset];
+#if TARGET_OS_OSX
+    _initPosition = [self locationInView:self.view.window.contentView];
+#else
     _initPosition = [self locationInView:self.view.window];
+#endif
   }
   _tapsSoFar++;
   if (_tapsSoFar) {
@@ -96,9 +101,8 @@ static const NSTimeInterval defaultMaxDuration = 0.5;
   [self triggerAction];
 }
 
-- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+- (void)interactionsMoved:(NSSet *)touches withEvent:(UIEvent *)event
 {
-  [super touchesMoved:touches withEvent:event];
   [_gestureHandler.pointerTracker touchesMoved:touches withEvent:event];
 
   NSInteger numberOfTouches = [touches count];
@@ -112,7 +116,6 @@ static const NSTimeInterval defaultMaxDuration = 0.5;
 
   if ([self shouldFailUnderCustomCriteria]) {
     self.state = UIGestureRecognizerStateFailed;
-    [self triggerAction];
     [self reset];
     return;
   }
@@ -121,9 +124,99 @@ static const NSTimeInterval defaultMaxDuration = 0.5;
   [self triggerAction];
 }
 
+- (void)interactionsEnded:(NSSet *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
+
+  if (_numberOfTaps == _tapsSoFar && _maxNumberOfTouches >= _minPointers) {
+    self.state = UIGestureRecognizerStateEnded;
+    [self reset];
+  } else {
+    [self performSelector:@selector(cancel) withObject:nil afterDelay:_maxDelay];
+  }
+}
+
+- (void)interactionsCancelled:(NSSet *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
+  self.state = UIGestureRecognizerStateCancelled;
+
+  [self reset];
+}
+
+#if TARGET_OS_OSX
+- (void)mouseDown:(NSEvent *)event
+{
+  [_gestureHandler setCurrentPointerTypeToMouse];
+  [super mouseDown:event];
+  [self interactionsBegan:[NSSet setWithObject:event] withEvent:event];
+}
+
+- (void)rightMouseDown:(NSEvent *)event
+{
+  [super rightMouseDown:event];
+  [self interactionsBegan:[NSSet setWithObject:event] withEvent:event];
+}
+
+- (void)mouseDragged:(NSEvent *)event
+{
+  [super mouseDragged:event];
+  [self interactionsMoved:[NSSet setWithObject:event] withEvent:event];
+}
+
+- (void)rightMouseDragged:(NSEvent *)event
+{
+  [super rightMouseDragged:event];
+  [self interactionsMoved:[NSSet setWithObject:event] withEvent:event];
+}
+
+- (void)mouseUp:(NSEvent *)event
+{
+  [super mouseUp:event];
+  [self interactionsEnded:[NSSet setWithObject:event] withEvent:event];
+}
+
+- (void)rightMouseUp:(NSEvent *)event
+{
+  [super rightMouseUp:event];
+  [self interactionsEnded:[NSSet setWithObject:event] withEvent:event];
+}
+#else
+
+- (void)touchesBegan:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler setCurrentPointerType:event];
+  [super touchesBegan:touches withEvent:event];
+  [self interactionsBegan:touches withEvent:event];
+}
+
+- (void)touchesMoved:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesMoved:touches withEvent:event];
+  [self interactionsMoved:touches withEvent:event];
+}
+
+- (void)touchesEnded:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesEnded:touches withEvent:event];
+  [self interactionsEnded:touches withEvent:event];
+}
+
+- (void)touchesCancelled:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesCancelled:touches withEvent:event];
+  [self interactionsCancelled:touches withEvent:event];
+}
+
+#endif
+
 - (CGPoint)translationInView
 {
+#if TARGET_OS_OSX
+  CGPoint currentPosition = [self locationInView:self.view.window.contentView];
+#else
   CGPoint currentPosition = [self locationInView:self.view.window];
+#endif
   return CGPointMake(currentPosition.x - _initPosition.x, currentPosition.y - _initPosition.y);
 }
 
@@ -148,33 +241,12 @@ static const NSTimeInterval defaultMaxDuration = 0.5;
   return NO;
 }
 
-- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
-{
-  [super touchesEnded:touches withEvent:event];
-  [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
-
-  if (_numberOfTaps == _tapsSoFar && _maxNumberOfTouches >= _minPointers) {
-    self.state = UIGestureRecognizerStateEnded;
-    [self reset];
-  } else {
-    [self performSelector:@selector(cancel) withObject:nil afterDelay:_maxDelay];
-  }
-}
-
-- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
-{
-  [super touchesCancelled:touches withEvent:event];
-  [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
-
-  self.state = UIGestureRecognizerStateCancelled;
-  [self reset];
-}
-
 - (void)reset
 {
   if (self.state == UIGestureRecognizerStateFailed) {
     [self triggerAction];
   }
+
   [_gestureHandler.pointerTracker reset];
 
   [NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(cancel) object:nil];
@@ -182,6 +254,7 @@ static const NSTimeInterval defaultMaxDuration = 0.5;
   _maxNumberOfTouches = 0;
   self.enabled = YES;
   [super reset];
+  [_gestureHandler reset];
 }
 
 @end

package/apple/RNGHStylusData.h

@@ -0,0 +1,77 @@
+//
+//  RNGHStylusData.h
+//  Pods
+//
+//  Created by Michał Bert on 18/09/2024.
+//
+
+#ifndef RNGHStylusData_h
+#define RNGHStylusData_h
+
+@interface RNGHStylusData : NSObject
+
+@property (atomic, assign) double tiltX;
+@property (atomic, assign) double tiltY;
+@property (atomic, assign) double altitudeAngle;
+@property (atomic, assign) double azimuthAngle;
+@property (atomic, assign) double pressure;
+
+- (NSDictionary *)toDictionary;
+
+@end
+
+static CGPoint ghSpherical2tilt(double altitudeAngle, double azimuthAngle)
+{
+  CGPoint tilts = {.x = 0.0, .y = 0.0};
+
+  const double radToDeg = 180 / M_PI;
+  const double eps = 0.000000001;
+
+  if (altitudeAngle < eps) {
+    // the pen is in the X-Y plane
+    if (azimuthAngle < eps || fabs(azimuthAngle - 2 * M_PI) < eps) {
+      // pen is on positive X axis
+      tilts.x = M_PI_2;
+    }
+    if (fabs(azimuthAngle - M_PI_2) < eps) {
+      // pen is on positive Y axis
+      tilts.y = M_PI_2;
+    }
+    if (fabs(azimuthAngle - M_PI) < eps) {
+      // pen is on negative X axis
+      tilts.x = -M_PI_2;
+    }
+    if (fabs(azimuthAngle - 3 * M_PI_2) < eps) {
+      // pen is on negative Y axis
+      tilts.y = -M_PI_2;
+    }
+    if (azimuthAngle > eps && fabs(azimuthAngle - M_PI_2) < eps) {
+      tilts.x = M_PI_2;
+      tilts.y = M_PI_2;
+    }
+    if (fabs(azimuthAngle - M_PI_2) > eps && fabs(azimuthAngle - M_PI) < eps) {
+      tilts.x = -M_PI_2;
+      tilts.y = M_PI_2;
+    }
+    if (azimuthAngle - M_PI > eps && fabs(azimuthAngle - 3 * M_PI_2) < eps) {
+      tilts.x = -M_PI_2;
+      tilts.y = -M_PI_2;
+    }
+    if (fabs(azimuthAngle - 3 * M_PI_2) > eps && fabs(azimuthAngle - 2 * M_PI) < eps) {
+      tilts.x = M_PI_2;
+      tilts.y = -M_PI_2;
+    }
+  } else {
+    const double tanAlt = tan(altitudeAngle);
+
+    tilts.x = atan(cos(azimuthAngle) / tanAlt);
+    tilts.y = atan(sin(azimuthAngle) / tanAlt);
+  }
+
+  tilts.x = round(tilts.x * radToDeg);
+  tilts.y = round(tilts.y * radToDeg);
+
+  return tilts;
+}
+
+#endif /* RNGHStylusData_h */

package/apple/RNGHStylusData.m

@@ -0,0 +1,37 @@
+//
+//  RNGHStylusData.m
+//  DoubleConversion
+//
+//  Created by Michał Bert on 18/09/2024.
+//
+
+#import "RNGHStylusData.h"
+#import <Foundation/Foundation.h>
+
+@implementation RNGHStylusData
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    self.tiltX = 0;
+    self.tiltY = 0;
+    self.altitudeAngle = M_PI_2;
+    self.azimuthAngle = 0;
+    self.pressure = 0;
+  }
+
+  return self;
+}
+
+- (NSDictionary *)toDictionary
+{
+  return @{
+    @"tiltX" : @(_tiltX),
+    @"tiltY" : @(_tiltY),
+    @"altitudeAngle" : @(_altitudeAngle),
+    @"azimuthAngle" : @(_azimuthAngle),
+    @"pressure" : @(_pressure),
+  };
+}
+
+@end

package/apple/RNGHUIKit.h

@@ -0,0 +1,29 @@
+#if !TARGET_OS_OSX
+
+#import <UIKit/UIKit.h>
+
+typedef UIView RNGHUIView;
+typedef UITouch RNGHUITouch;
+typedef UIScrollView RNGHUIScrollView;
+
+#define RNGHGestureRecognizerStateFailed UIGestureRecognizerStateFailed;
+#define RNGHGestureRecognizerStatePossible UIGestureRecognizerStatePossible;
+#define RNGHGestureRecognizerStateCancelled UIGestureRecognizerStateCancelled;
+#define RNGHGestureRecognizerStateBegan UIGestureRecognizerStateBegan;
+#define RNGHGestureRecognizerStateEnded UIGestureRecognizerStateEnded;
+
+#else // TARGET_OS_OSX [
+
+#import <React/RCTUIKit.h>
+
+typedef RCTUIView RNGHUIView;
+typedef RCTUITouch RNGHUITouch;
+typedef NSScrollView RNGHUIScrollView;
+
+#define RNGHGestureRecognizerStateFailed NSGestureRecognizerStateFailed;
+#define RNGHGestureRecognizerStatePossible NSGestureRecognizerStatePossible;
+#define RNGHGestureRecognizerStateCancelled NSGestureRecognizerStateCancelled;
+#define RNGHGestureRecognizerStateBegan NSGestureRecognizerStateBegan;
+#define RNGHGestureRecognizerStateEnded NSGestureRecognizerStateEnded;
+
+#endif // ] TARGET_OS_OSX