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

package/android/src/main/java/com/swmansion/gesturehandler/react/eventbuilders/PanGestureHandlerEventDataBuilder.kt

@@ -0,0 +1,50 @@
+package com.swmansion.gesturehandler.react.eventbuilders
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.PixelUtil
+import com.swmansion.gesturehandler.core.PanGestureHandler
+import com.swmansion.gesturehandler.core.StylusData
+
+class PanGestureHandlerEventDataBuilder(handler: PanGestureHandler) :
+  GestureHandlerEventDataBuilder<PanGestureHandler>(handler) {
+  private val x: Float
+  private val y: Float
+  private val absoluteX: Float
+  private val absoluteY: Float
+  private val translationX: Float
+  private val translationY: Float
+  private val velocityX: Float
+  private val velocityY: Float
+  private val stylusData: StylusData
+
+  init {
+    x = handler.lastRelativePositionX
+    y = handler.lastRelativePositionY
+    absoluteX = handler.lastPositionInWindowX
+    absoluteY = handler.lastPositionInWindowY
+    translationX = handler.translationX
+    translationY = handler.translationY
+    velocityX = handler.velocityX
+    velocityY = handler.velocityY
+    stylusData = handler.stylusData
+  }
+
+  override fun buildEventData(eventData: WritableMap) {
+    super.buildEventData(eventData)
+
+    with(eventData) {
+      putDouble("x", PixelUtil.toDIPFromPixel(x).toDouble())
+      putDouble("y", PixelUtil.toDIPFromPixel(y).toDouble())
+      putDouble("absoluteX", PixelUtil.toDIPFromPixel(absoluteX).toDouble())
+      putDouble("absoluteY", PixelUtil.toDIPFromPixel(absoluteY).toDouble())
+      putDouble("translationX", PixelUtil.toDIPFromPixel(translationX).toDouble())
+      putDouble("translationY", PixelUtil.toDIPFromPixel(translationY).toDouble())
+      putDouble("velocityX", PixelUtil.toDIPFromPixel(velocityX).toDouble())
+      putDouble("velocityY", PixelUtil.toDIPFromPixel(velocityY).toDouble())
+
+      if (stylusData.pressure != -1.0) {
+        putMap("stylusData", stylusData.toReadableMap())
+      }
+    }
+  }
+}

package/android/src/main/java/com/swmansion/gesturehandler/react/eventbuilders/PinchGestureHandlerEventDataBuilder.kt

@@ -0,0 +1,31 @@
+package com.swmansion.gesturehandler.react.eventbuilders
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.PixelUtil
+import com.swmansion.gesturehandler.core.PinchGestureHandler
+
+class PinchGestureHandlerEventDataBuilder(handler: PinchGestureHandler) :
+  GestureHandlerEventDataBuilder<PinchGestureHandler>(handler) {
+  private val scale: Double
+  private val focalX: Float
+  private val focalY: Float
+  private val velocity: Double
+
+  init {
+    scale = handler.scale
+    focalX = handler.focalPointX
+    focalY = handler.focalPointY
+    velocity = handler.velocity
+  }
+
+  override fun buildEventData(eventData: WritableMap) {
+    super.buildEventData(eventData)
+
+    with(eventData) {
+      putDouble("scale", scale)
+      putDouble("focalX", PixelUtil.toDIPFromPixel(focalX).toDouble())
+      putDouble("focalY", PixelUtil.toDIPFromPixel(focalY).toDouble())
+      putDouble("velocity", velocity)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/gesturehandler/react/eventbuilders/RotationGestureHandlerEventDataBuilder.kt

@@ -0,0 +1,31 @@
+package com.swmansion.gesturehandler.react.eventbuilders
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.PixelUtil
+import com.swmansion.gesturehandler.core.RotationGestureHandler
+
+class RotationGestureHandlerEventDataBuilder(handler: RotationGestureHandler) :
+  GestureHandlerEventDataBuilder<RotationGestureHandler>(handler) {
+  private val rotation: Double
+  private val anchorX: Float
+  private val anchorY: Float
+  private val velocity: Double
+
+  init {
+    rotation = handler.rotation
+    anchorX = handler.anchorX
+    anchorY = handler.anchorY
+    velocity = handler.velocity
+  }
+
+  override fun buildEventData(eventData: WritableMap) {
+    super.buildEventData(eventData)
+
+    with(eventData) {
+      putDouble("rotation", rotation)
+      putDouble("anchorX", PixelUtil.toDIPFromPixel(anchorX).toDouble())
+      putDouble("anchorY", PixelUtil.toDIPFromPixel(anchorY).toDouble())
+      putDouble("velocity", velocity)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/gesturehandler/react/eventbuilders/TapGestureHandlerEventDataBuilder.kt

@@ -0,0 +1,31 @@
+package com.swmansion.gesturehandler.react.eventbuilders
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.PixelUtil
+import com.swmansion.gesturehandler.core.TapGestureHandler
+
+class TapGestureHandlerEventDataBuilder(handler: TapGestureHandler) :
+  GestureHandlerEventDataBuilder<TapGestureHandler>(handler) {
+  private val x: Float
+  private val y: Float
+  private val absoluteX: Float
+  private val absoluteY: Float
+
+  init {
+    x = handler.lastRelativePositionX
+    y = handler.lastRelativePositionY
+    absoluteX = handler.lastPositionInWindowX
+    absoluteY = handler.lastPositionInWindowY
+  }
+
+  override fun buildEventData(eventData: WritableMap) {
+    super.buildEventData(eventData)
+
+    with(eventData) {
+      putDouble("x", PixelUtil.toDIPFromPixel(x).toDouble())
+      putDouble("y", PixelUtil.toDIPFromPixel(y).toDouble())
+      putDouble("absoluteX", PixelUtil.toDIPFromPixel(absoluteX).toDouble())
+      putDouble("absoluteY", PixelUtil.toDIPFromPixel(absoluteY).toDouble())
+    }
+  }
+}

package/android/src/main/jni/CMakeLists.txt

@@ -1,25 +1,41 @@
 project(GestureHandler)
 cmake_minimum_required(VERSION 3.9.0)
 
+string(
+  APPEND
+  CMAKE_CXX_FLAGS
+  " -DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}")
+
 set(CMAKE_VERBOSE_MAKEFILE ON)
-set(CMAKE_CXX_STANDARD 17)
+if(${REACT_NATIVE_MINOR_VERSION} GREATER_EQUAL 73)
+    set(CMAKE_CXX_STANDARD 20)
+else()
+    set(CMAKE_CXX_STANDARD 17)
+endif()
 
+set(PACKAGE_NAME "gesturehandler")
 set(REACT_ANDROID_DIR "${REACT_NATIVE_DIR}/ReactAndroid")
 
 include(${REACT_ANDROID_DIR}/cmake-utils/folly-flags.cmake)
 add_compile_options(${folly_FLAGS})
 
-add_library(gesturehandler
+add_library(${PACKAGE_NAME}
   SHARED
   cpp-adapter.cpp
 )
 
+target_include_directories(
+  ${PACKAGE_NAME}
+  PRIVATE
+  "${REACT_NATIVE_DIR}/ReactCommon"
+)
+
 find_package(ReactAndroid REQUIRED CONFIG)
+find_package(fbjni REQUIRED CONFIG)
 
 target_link_libraries(
-  gesturehandler
-  ReactAndroid::react_render_core
-  ReactAndroid::react_render_uimanager
+  ${PACKAGE_NAME}
+  ReactAndroid::reactnative
   ReactAndroid::jsi
-  ReactAndroid::react_nativemodule_core
+  fbjni::fbjni
 )

package/android/src/main/jni/cpp-adapter.cpp

@@ -7,38 +7,47 @@ using namespace facebook;
 using namespace react;
 
 void decorateRuntime(jsi::Runtime &runtime) {
-  auto isFormsStackingContext = jsi::Function::createFromHostFunction(
-      runtime,
-      jsi::PropNameID::forAscii(runtime, "isFormsStackingContext"),
-      1,
-      [](jsi::Runtime &runtime,
-         const jsi::Value &thisValue,
-         const jsi::Value *arguments,
-         size_t count) -> jsi::Value {
-        if (!arguments[0].isObject()) {
-          return jsi::Value::null();
-        }
-
-        auto shadowNode = arguments[0]
-                              .asObject(runtime)
-                              .getHostObject<ShadowNodeWrapper>(runtime)
-                              ->shadowNode;
-        bool isFormsStackingContext = shadowNode->getTraits().check(
-            ShadowNodeTraits::FormsStackingContext);
-
-        return jsi::Value(isFormsStackingContext);
-      });
-  runtime.global().setProperty(
-      runtime, "isFormsStackingContext", std::move(isFormsStackingContext));
+    auto isViewFlatteningDisabled = jsi::Function::createFromHostFunction(
+            runtime,
+            jsi::PropNameID::forAscii(runtime, "isViewFlatteningDisabled"),
+            1,
+            [](jsi::Runtime &runtime,
+               const jsi::Value &thisValue,
+               const jsi::Value *arguments,
+               size_t count) -> jsi::Value {
+                if (!arguments[0].isObject()) {
+                    return jsi::Value::null();
+                }
+
+#if REACT_NATIVE_MINOR_VERSION >= 81
+                auto shadowNode = Bridging<std::shared_ptr<const ShadowNode>>::fromJs(
+                        runtime, arguments[0]);
+#else
+                auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
+#endif
+
+                bool isViewFlatteningDisabled = shadowNode->getTraits().check(
+                        ShadowNodeTraits::FormsStackingContext);
+
+                // This is done using component names instead of type checking because
+                // of duplicate symbols for RN types, which prevent RTTI from working.
+                const char *componentName = shadowNode->getComponentName();
+                bool isTextComponent = strcmp(componentName, "Paragraph") == 0 ||
+                                       strcmp(componentName, "Text") == 0;
+
+                return jsi::Value(isViewFlatteningDisabled || isTextComponent);
+            });
+    runtime.global().setProperty(
+            runtime, "isViewFlatteningDisabled", std::move(isViewFlatteningDisabled));
 }
 
 extern "C" JNIEXPORT void JNICALL
 Java_com_swmansion_gesturehandler_react_RNGestureHandlerModule_decorateRuntime(
-    JNIEnv *env,
-    jobject clazz,
-    jlong jsiPtr) {
-  jsi::Runtime *runtime = reinterpret_cast<jsi::Runtime *>(jsiPtr);
-  if (runtime) {
-    decorateRuntime(*runtime);
-  }
+        JNIEnv *env,
+        jobject clazz,
+        jlong jsiPtr) {
+    jsi::Runtime *runtime = reinterpret_cast<jsi::Runtime *>(jsiPtr);
+    if (runtime) {
+        decorateRuntime(*runtime);
+    }
 }

package/android/svg/src/main/java/com/swmansion/gesturehandler/RNSVGHitTester.kt

@@ -0,0 +1,65 @@
+package com.swmansion.gesturehandler
+
+import android.view.View
+import androidx.core.view.children
+import com.horcrux.svg.SvgView
+import com.horcrux.svg.VirtualView
+
+class RNSVGHitTester {
+  companion object {
+    private fun getRootSvgView(view: View): SvgView {
+      var rootSvgView: SvgView
+
+      rootSvgView = if (view is VirtualView) {
+        view.svgView!!
+      } else {
+        view as SvgView
+      }
+
+      while (isSvgElement(rootSvgView.parent)) {
+        rootSvgView = if (rootSvgView.parent is VirtualView) {
+          (rootSvgView.parent as VirtualView).svgView!!
+        } else {
+          rootSvgView.parent as SvgView
+        }
+      }
+
+      return rootSvgView
+    }
+
+    fun isSvgElement(view: Any): Boolean = (view is VirtualView || view is SvgView)
+
+    fun hitTest(view: View, posX: Float, posY: Float): Boolean {
+      val rootSvgView = getRootSvgView(view)
+      val viewLocation = intArrayOf(0, 0)
+      val rootLocation = intArrayOf(0, 0)
+
+      view.getLocationOnScreen(viewLocation)
+      rootSvgView.getLocationOnScreen(rootLocation)
+
+      // convert View-relative coordinates into SvgView-relative coordinates
+      val rootX = posX + viewLocation[0] - rootLocation[0]
+      val rootY = posY + viewLocation[1] - rootLocation[1]
+
+      val pressedId = rootSvgView.reactTagForTouch(rootX, rootY)
+      val hasBeenPressed = view.id == pressedId
+
+      // hitTest(view, ...) should only be called after isSvgElement(view) returns true
+      // Consequently, `view` will always be either SvgView or VirtualView
+
+      val pressIsInBounds =
+        posX in 0.0..view.width.toDouble() &&
+          posY in 0.0..view.height.toDouble()
+
+      if (view is SvgView) {
+        val childrenIds = view.children.map { it.id }
+
+        val hasChildBeenPressed = pressedId in childrenIds
+
+        return (hasBeenPressed || hasChildBeenPressed) && pressIsInBounds
+      }
+
+      return hasBeenPressed && pressIsInBounds
+    }
+  }
+}

package/{ios → apple}/Handlers/RNFlingHandler.h

@@ -1,3 +1,4 @@
+#import "../RNGHVector.h"
 #import "RNGestureHandler.h"
 
 @interface RNFlingGestureHandler : RNGestureHandler

package/apple/Handlers/RNFlingHandler.m

@@ -0,0 +1,313 @@
+#import "RNFlingHandler.h"
+
+#if !TARGET_OS_OSX
+
+@interface RNBetterSwipeGestureRecognizer : UISwipeGestureRecognizer
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
+
+@end
+
+@implementation RNBetterSwipeGestureRecognizer {
+  __weak RNGestureHandler *_gestureHandler;
+  CGPoint _lastPoint; // location of the most recently updated touch, relative to the view
+  bool _hasBegan; // whether the `BEGAN` event has been sent
+}
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler
+{
+  if ((self = [super initWithTarget:gestureHandler action:@selector(handleGesture:)])) {
+    _gestureHandler = gestureHandler;
+    _lastPoint = CGPointZero;
+    _hasBegan = NO;
+  }
+  return self;
+}
+
+- (void)touchesBegan:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler setCurrentPointerType:event];
+  _lastPoint = [[[touches allObjects] objectAtIndex:0] locationInView:_gestureHandler.recognizer.view];
+  [_gestureHandler reset];
+  [super touchesBegan:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesBegan:touches withEvent:event];
+
+  // self.numberOfTouches doesn't work for this because in case than one finger is required,
+  // when holding one finger on the screen and tapping with the second one, numberOfTouches is equal
+  // to 2 only for the first tap but 1 for all the following ones
+  if (!_hasBegan) {
+    [self triggerAction];
+    _hasBegan = YES;
+  }
+}
+
+- (void)touchesMoved:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  _lastPoint = [[[touches allObjects] objectAtIndex:0] locationInView:_gestureHandler.recognizer.view];
+  [super touchesMoved:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesMoved:touches withEvent:event];
+}
+
+- (void)touchesEnded:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  _lastPoint = [[[touches allObjects] objectAtIndex:0] locationInView:_gestureHandler.recognizer.view];
+  [super touchesEnded:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
+
+  [self triggerAction];
+}
+
+- (void)touchesCancelled:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  _lastPoint = [[[touches allObjects] objectAtIndex:0] locationInView:_gestureHandler.recognizer.view];
+  [super touchesCancelled:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
+
+  [self triggerAction];
+}
+
+- (void)triggerAction
+{
+  [_gestureHandler handleGesture:self];
+}
+
+- (void)reset
+{
+  // TODO: On iOS 26 swiping in "wrong" direction doesn't send `onFinalize` callback. This is because now in `reset`
+  // default state is `UIGestureRecognizerStatePossible`
+  [self triggerAction]; // Keeping it will not break old iOS because we check if we do not send the same state twice.
+  [_gestureHandler.pointerTracker reset];
+  _hasBegan = NO;
+  [super reset];
+  [_gestureHandler reset];
+}
+
+- (CGPoint)getLastLocation
+{
+  // I think keeping the location of only one touch is enough since it would be used to determine the direction
+  // of the movement, and if it's wrong the recognizer fails anyway.
+  // In case the location of all touches is required, touch events are the way to go
+  return _lastPoint;
+}
+
+@end
+
+#else
+
+@interface RNBetterSwipeGestureRecognizer : NSGestureRecognizer {
+  dispatch_block_t failFlingAction;
+  int maxDuration;
+  int minVelocity;
+  double defaultAlignmentCone;
+  double axialDeviationCosine;
+  double diagonalDeviationCosine;
+}
+
+@property (atomic, assign) RNGestureHandlerDirection direction;
+@property (atomic, assign) int numberOfTouchesRequired;
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
+
+@end
+
+@implementation RNBetterSwipeGestureRecognizer {
+  __weak RNGestureHandler *_gestureHandler;
+
+  NSPoint startPosition;
+  double startTime;
+}
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler
+{
+  if ((self = [super initWithTarget:self action:@selector(handleGesture:)])) {
+    _gestureHandler = gestureHandler;
+
+    maxDuration = 1.0;
+    minVelocity = 700;
+
+    defaultAlignmentCone = 30;
+    axialDeviationCosine = [self coneToDeviation:defaultAlignmentCone];
+    diagonalDeviationCosine = [self coneToDeviation:(90 - defaultAlignmentCone)];
+  }
+  return self;
+}
+
+- (void)handleGesture:(NSPanGestureRecognizer *)gestureRecognizer
+{
+  [_gestureHandler handleGesture:self];
+}
+
+- (void)mouseDown:(NSEvent *)event
+{
+  [super mouseDown:event];
+
+  startPosition = [self locationInView:self.view];
+  startTime = CACurrentMediaTime();
+
+  self.state = NSGestureRecognizerStatePossible;
+
+  __weak typeof(self) weakSelf = self;
+
+  failFlingAction = dispatch_block_create(0, ^{
+    __strong typeof(self) strongSelf = weakSelf;
+
+    if (strongSelf) {
+      strongSelf.state = NSGestureRecognizerStateFailed;
+    }
+  });
+
+  dispatch_after(
+      dispatch_time(DISPATCH_TIME_NOW, (int64_t)(maxDuration * NSEC_PER_SEC)),
+      dispatch_get_main_queue(),
+      failFlingAction);
+}
+
+- (void)mouseDragged:(NSEvent *)event
+{
+  [super mouseDragged:event];
+
+  NSPoint currentPosition = [self locationInView:self.view];
+  double currentTime = CACurrentMediaTime();
+
+  NSPoint distance;
+  distance.x = currentPosition.x - startPosition.x;
+  distance.y = startPosition.y - currentPosition.y;
+
+  double timeDelta = currentTime - startTime;
+
+  Vector *velocityVector = [Vector fromVelocityX:(distance.x / timeDelta) withVelocityY:(distance.y / timeDelta)];
+
+  [self tryActivate:velocityVector];
+}
+
+- (void)mouseUp:(NSEvent *)event
+{
+  [super mouseUp:event];
+
+  dispatch_block_cancel(failFlingAction);
+
+  self.state =
+      self.state == NSGestureRecognizerStateChanged ? NSGestureRecognizerStateEnded : NSGestureRecognizerStateFailed;
+}
+
+- (void)tryActivate:(Vector *)velocityVector
+{
+  bool isAligned = NO;
+
+  for (int i = 0; i < directionsSize; ++i) {
+    if ([self getAlignment:axialDirections[i]
+            withMinimalAlignmentCosine:axialDeviationCosine
+                    withVelocityVector:velocityVector]) {
+      isAligned = YES;
+      break;
+    }
+  }
+
+  if (!isAligned) {
+    for (int i = 0; i < directionsSize; ++i) {
+      if ([self getAlignment:diagonalDirections[i]
+              withMinimalAlignmentCosine:diagonalDeviationCosine
+                      withVelocityVector:velocityVector]) {
+        isAligned = YES;
+        break;
+      }
+    }
+  }
+
+  bool isFastEnough = velocityVector.magnitude >= minVelocity;
+
+  if (isAligned && isFastEnough) {
+    self.state = NSGestureRecognizerStateChanged;
+  }
+}
+
+- (BOOL)getAlignment:(RNGestureHandlerDirection)direction
+    withMinimalAlignmentCosine:(double)minimalAlignmentCosine
+            withVelocityVector:(Vector *)velocityVector
+{
+  Vector *directionVector = [Vector fromDirection:direction];
+  return ((self.direction & direction) == direction) &&
+      [velocityVector isSimilar:directionVector withThreshold:minimalAlignmentCosine];
+}
+
+- (double)coneToDeviation:(double)degrees
+{
+  double radians = (degrees * M_PI) / 180;
+  return cos(radians / 2);
+}
+
+@end
+
+#endif
+
+@implementation RNFlingGestureHandler
+
+- (instancetype)initWithTag:(NSNumber *)tag
+{
+  if ((self = [super initWithTag:tag])) {
+    _recognizer = [[RNBetterSwipeGestureRecognizer alloc] initWithGestureHandler:self];
+  }
+  return self;
+}
+
+- (void)resetConfig
+{
+  [super resetConfig];
+  RNBetterSwipeGestureRecognizer *recognizer = (RNBetterSwipeGestureRecognizer *)_recognizer;
+  recognizer.direction = RNGestureHandlerDirectionRight;
+#if !TARGET_OS_TV
+  recognizer.numberOfTouchesRequired = 1;
+#endif
+}
+
+- (void)configure:(NSDictionary *)config
+{
+  [super configure:config];
+  RNBetterSwipeGestureRecognizer *recognizer = (RNBetterSwipeGestureRecognizer *)_recognizer;
+
+  id prop = config[@"direction"];
+  if (prop != nil) {
+    recognizer.direction = [RCTConvert NSInteger:prop];
+  }
+
+#if !TARGET_OS_TV
+  prop = config[@"numberOfPointers"];
+  if (prop != nil) {
+    recognizer.numberOfTouchesRequired = [RCTConvert NSInteger:prop];
+  }
+#endif
+}
+
+#if !TARGET_OS_OSX
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer
+{
+  RNGestureHandlerState savedState = _lastState;
+  BOOL shouldBegin = [super gestureRecognizerShouldBegin:gestureRecognizer];
+  _lastState = savedState;
+
+  return shouldBegin;
+}
+
+- (RNGestureHandlerEventExtraData *)eventExtraData:(id)_recognizer
+{
+  // For some weird reason [recognizer locationInView:recognizer.view.window] returns (0, 0).
+  // To calculate the correct absolute position, first calculate the absolute position of the
+  // view inside the root view controller (https://stackoverflow.com/a/7448573) and then
+  // add the relative touch position to it.
+
+  RNBetterSwipeGestureRecognizer *recognizer = (RNBetterSwipeGestureRecognizer *)_recognizer;
+
+  CGPoint viewAbsolutePosition = [recognizer.view convertPoint:recognizer.view.bounds.origin
+                                                        toView:RCTKeyWindow().rootViewController.view];
+  CGPoint locationInView = [recognizer getLastLocation];
+
+  return [RNGestureHandlerEventExtraData
+               forPosition:locationInView
+      withAbsolutePosition:CGPointMake(
+                               viewAbsolutePosition.x + locationInView.x, viewAbsolutePosition.y + locationInView.y)
+       withNumberOfTouches:recognizer.numberOfTouches
+           withPointerType:_pointerType];
+}
+#endif
+
+@end