@nativescript-community/gesturehandler 0.2.2 → 2.0.0

package/.history/plugin/platforms/android/include_20220218092908.gradle

@@ -0,0 +1,19 @@
+import groovy.json.JsonSlurper
+dependencies {
+    implementation(name:'widgets-release', ext:'aar')
+    implementation "androidx.annotation:annotation:1.1.0"
+}
+repositories {
+    def appDir = "$rootDir/../../.."
+    def widgetsDir = "$appDir/node_modules/@nativescript/core/platforms/android"
+    def appPackageJsonFile = file("$appDir/package.json")
+    if (appPackageJsonFile.exists()) {
+        def appPackageJson = new JsonSlurper().parseText(appPackageJsonFile.text)
+        if (appPackageJson.dependencies['@akylas/nativescript'] != null) {
+            widgetsDir = "$appDir/node_modules/@akylas/nativescript/platforms/android"
+        }
+    }
+    flatDir {
+        dirs "$widgetsDir"
+    }
+}

package/.history/plugin/platforms/android/java/com/nativescript/gesturehandler/GestureLayout_20220217101931.java

@@ -0,0 +1,185 @@
+package com.nativescript.gesturehandler;
+
+import android.content.Context;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import android.util.Log;
+
+import com.swmansion.gesturehandler.GestureHandlerOrchestrator;
+import com.swmansion.gesturehandler.GestureHandlerRegistryImpl;
+import com.swmansion.gesturehandler.PointerEventsConfig;
+import com.swmansion.gesturehandler.GestureHandler;
+import com.swmansion.gesturehandler.ViewConfigurationHelper;
+
+import java.util.ArrayList;
+
+public class GestureLayout extends FrameLayout {
+    public GestureLayout(Context context, int rootGestureTag) {
+        super(context);
+        mRootGestureTag = rootGestureTag;
+    }
+
+    private int mRootGestureTag;
+    private GestureHandlerOrchestrator mOrchestrator;
+    private GestureHandlerRegistryImpl mRegistry;
+    private ViewConfigurationHelper configurationHelper;
+    RootViewGestureHandler rootGestureHandler;
+
+    private boolean mShouldIntercept = false;
+    private boolean mPassingTouch = false;
+    private boolean mDispatchToOrchestra = true;
+    private boolean mShouldAddRootGesture = true;
+
+    public void setShouldIntercept(boolean value) {
+        if (GestureHandler.debug) {
+            Log.d("JS", "PageLayout setShouldIntercept " + value);
+        }
+        this.mShouldIntercept = value;
+    }
+
+    public void setPassingTouch(boolean value) {
+        this.mPassingTouch = value;
+    }
+    public void setShouldAddRootGesture(boolean value) {
+        this.mShouldAddRootGesture = value;
+    }
+
+    public int getRootGestureTag() {
+        return mRootGestureTag;
+    }
+
+    public void setDispatchToOrchestra(boolean value) {
+        if (GestureHandler.debug) {
+            Log.d("JS", "PageLayout setDispatchToOrchestra " + value);
+        }
+        this.mDispatchToOrchestra = value;
+    }
+
+    public GestureHandlerRegistryImpl registry() {
+        return this.mRegistry;
+    }
+    // requestDisallowInterceptTouchEvent(disallowIntercept) {
+    //     console.log('requestDisallowInterceptTouchEvent');
+    //     if (this.mGestureRootHelper != null) {
+    //         this.mGestureRootHelper.requestDisallowInterceptTouchEvent(disallowIntercept);
+    //     }
+    //     super.requestDisallowInterceptTouchEvent(disallowIntercept);
+    // }
+
+    // dispatchTouchEvent(ev) {
+    //     if (this.mGestureRootHelper != null && this.mGestureRootHelper.dispatchTouchEvent(ev)) {
+    //         return true;
+    //     }
+    //     return super.dispatchTouchEvent(ev);
+    // }
+    public void tryCancelAllHandlers() {
+        if (GestureHandler.debug) {
+            Log.d("JS", "PageLayout tryCancelAllHandlers ");
+        }
+        ArrayList<GestureHandler> handlers = this.mRegistry.getAllHandlers();
+        if (handlers != null) {
+            for(int i = 0; i < handlers.size(); i++) {
+                GestureHandler handler = handlers.get(i);
+                if (handler != this.rootGestureHandler) {
+                    handler.cancel();
+                }
+            }
+        }
+        // In order to cancel handlers we activate handler that is hooked to the root view
+        // if (this.rootGestureHandler != null && this.rootGestureHandler.getState() == com.swmansion.gesturehandler.GestureHandler.STATE_BEGAN) {
+        //     // Try activate main JS handler
+        //     this.rootGestureHandler.activate();
+        //     this.rootGestureHandler.end();
+        // }
+    }
+
+    public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
+        if (GestureHandler.debug) {
+            Log.d("JS", "PageLayout requestDisallowInterceptTouchEvent " + disallowIntercept + " " + this.mPassingTouch);
+        }
+        // If this method gets called it means that some native view is attempting to grab lock for
+        // touch event delivery. In that case we cancel all gesture recognizers
+        if (this.mOrchestrator != null && !this.mPassingTouch) {
+            // if we are in the process of delivering touch events via GH orchestrator, we don't want to
+            // treat it as a native gesture capturing the lock
+            this.tryCancelAllHandlers();
+        }
+        super.requestDisallowInterceptTouchEvent(disallowIntercept);
+    }
+
+    public boolean dispatchTouchEventToOrchestrator(MotionEvent ev) {
+        if (this.mOrchestrator != null) {
+            this.mPassingTouch = true;
+            this.mOrchestrator.onTouchEvent(ev);
+            this.mPassingTouch = false;
+        }
+        if (GestureHandler.debug) {
+            Log.d("JS", "PageLayout dispatchTouchEventToOrchestrator " + this.mShouldIntercept);
+        }
+        return this.mShouldIntercept;
+    }
+
+    public boolean dispatchTouchEvent(MotionEvent ev) {
+        if (GestureHandler.debug) {
+            Log.d("JS", "PageLayout dispatchTouchEvent " + this.mDispatchToOrchestra);
+        }
+        if (this.mDispatchToOrchestra && this.dispatchTouchEventToOrchestrator(ev)) {
+            return true;
+        }
+        final boolean handled = super.dispatchTouchEvent(ev);
+        if (GestureHandler.debug) {
+            Log.d("JS", "PageLayout dispatchTouchEvent to children " + handled);
+        }
+        // we need to always return true or gestures wont work on layouts because they don't handle touch so dispatchTouchEvent returns false
+        return true;
+    }
+
+    // onInterceptTouchEvent(ev: android.view.MotionEvent) {
+    //     return this.mShouldIntercept;
+    // }
+
+    // onTouchEvent(ev: android.view.MotionEvent) {
+    //     console.log('onTouchEvent', ev);
+    //     this.mOrchestrator.onTouchEvent(ev);
+    //     return super.onTouchEvent(ev);
+    // }
+
+    /**
+     * This method is used to enable root view to start processing touch events through the gesture
+     * handler library logic. Unless this method is called (which happens as a result of instantiating
+     * new gesture handler from JS) the root view component will just proxy all touch related methods
+     * to its superclass. Thus in the "disabled" state all touch related events will fallback to
+     * default behavior.
+     */
+    public void initialize() {
+        this.mRegistry = new com.swmansion.gesturehandler.GestureHandlerRegistryImpl();
+        this.configurationHelper = new com.swmansion.gesturehandler.ViewConfigurationHelper() {
+            public PointerEventsConfig getPointerEventsConfigForView(View view) {
+                return view.isEnabled() ? com.swmansion.gesturehandler.PointerEventsConfig.AUTO : com.swmansion.gesturehandler.PointerEventsConfig.NONE;
+            }
+
+            public boolean isViewClippingChildren(ViewGroup parent) {
+                return false;
+            }
+
+            public View getChildInDrawingOrderAtIndex(ViewGroup parent, int index) {
+                return parent.getChildAt(index);
+            }
+        };
+        this.mOrchestrator = new com.swmansion.gesturehandler.GestureHandlerOrchestrator(this, this.mRegistry, this.configurationHelper);
+        this.mOrchestrator.setMinimumAlphaForTraversal(0.01f);
+
+        this.rootGestureHandler = new RootViewGestureHandler();
+        this.rootGestureHandler.setTag(mRootGestureTag);
+        this.mRegistry.registerHandler(this.rootGestureHandler);
+        this.mRegistry.attachHandlerToView(mRootGestureTag, this);
+    }
+
+    public void tearDown() {
+        this.configurationHelper = null;
+        this.mOrchestrator = null;
+        this.mRegistry = null;
+    }
+}

package/.history/plugin/platforms/ios/src/GestureHandler_20201106183454.h

@@ -0,0 +1,98 @@
+//
+//  GestureHandler.h
+//  GestureHandler
+//
+//  Created by Martin Guillon on 6/5/19.
+//  Copyright © 2019 Stefan Dragnev. All rights reserved.
+//
+
+#import "GestureHandlerState.h"
+#import "GestureHandlerDirection.h"
+#import "GestureHandlerEvents.h"
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+#define VEC_LEN_SQ(pt) (pt.x * pt.x + pt.y * pt.y)
+#define TEST_MIN_IF_NOT_NAN(value, limit) \
+(!isnan(limit) && ((limit < 0 && value <= limit) || (limit >= 0 && value >= limit)))
+
+#define TEST_MAX_IF_NOT_NAN(value, max) \
+(!isnan(max) && ((max < 0 && value < max) || (max >= 0 && value > max)))
+
+#define APPLY_PROP(recognizer, config, type, prop, propName) do { \
+id value = config[propName]; \
+if (value != nil) recognizer.prop = [value type]; \
+} while(0)
+
+#define APPLY_FLOAT_PROP(prop) do { APPLY_PROP(recognizer, config, floatValue, prop, @#prop); } while(0)
+#define APPLY_INT_PROP(prop) do { APPLY_PROP(recognizer, config, integerValue, prop, @#prop); } while(0)
+#define APPLY_NAMED_INT_PROP(prop, propName) do { APPLY_PROP(recognizer, config, integerValue, prop, propName); } while(0)
+
+//@protocol GestureHandlerEventEmitter
+//
+//- (void)sendTouchEvent:(nonnull GestureHandlerEvent *)event;
+//
+//- (void)sendStateChangeEvent:(nonnull GestureHandlerStateChange *)event;
+//
+//@end
+
+
+@protocol RootViewGestureRecognizerDelegate <UIGestureRecognizerDelegate>
+
+@required
+- (BOOL)gestureRecognizer:(nullable UIGestureRecognizer *)gestureRecognizer
+    didActivateInRootView:(nullable UIView *)rootView;
+
+@end
+
+
+@class GestureHandler;
+@protocol GestureHandlerDelegate  <NSObject>
+
+@optional
+- (BOOL)gestureHandler:(nullable GestureHandler *)gestureHandler shouldActivateForEvent:(nullable NSDictionary *)data;
+
+@required
+- (void)gestureHandler:(nullable GestureHandler *)gestureHandler
+ didChangeState:(GestureHandlerState)state prevState:(GestureHandlerState)state extraData:(nullable NSDictionary *)data view:(nullable UIView *)view;
+
+ @required
+- (void)gestureHandler:(nullable GestureHandler *)gestureHandler
+ touchEventOnView:(nullable UIView *)view state:(GestureHandlerState)state extraData:(nullable NSDictionary *)data;
+
+@end
+
+@interface GestureHandler : NSObject <UIGestureRecognizerDelegate> {
+  
+@protected UIGestureRecognizer *_recognizer;
+@protected GestureHandlerState _lastState;
+  
+}
+
++ (nullable GestureHandler *)findGestureHandlerByRecognizer:(nonnull UIGestureRecognizer *)recognizer;
+
+- (nonnull instancetype)initWithTag:(nonnull NSNumber *)tag;
+
+@property (nonatomic, readonly, nonnull) NSNumber *tag;
+//@property (nonatomic, weak, nullable) id<GestureHandlerEventEmitter> emitter;
+@property (nonatomic, readonly, nullable) UIGestureRecognizer *recognizer;
+@property (nonatomic) BOOL enabled;
+@property(nonatomic) BOOL shouldCancelWhenOutside;
+@property (nullable, nonatomic, weak) id<GestureHandlerDelegate> delegate;
+
+- (void)bindToView:(nonnull UIView *)view;
+- (void)unbindFromView;
+- (void)configure:(nullable NSDictionary *)config NS_REQUIRES_SUPER;
+- (void)handleGesture:(nonnull id)recognizer;
+- (BOOL)containsPointInView;
+- (GestureHandlerState)state;
+- (nullable NSMutableDictionary *)eventExtraData:(nonnull id)recognizer;
+
+- (void)reset;
+- (void)sendEventsInState:(GestureHandlerState)state
+           forView:(nonnull UIView *)view
+            withExtraData:(nullable NSDictionary*)extraData;
+
+@end
+

package/.history/plugin/platforms/ios/src/GestureHandler_20201111112216.m

@@ -0,0 +1,365 @@
+#import "GestureHandler.h"
+
+#import "NativeViewHandler.h"
+
+#import <UIKit/UIGestureRecognizerSubclass.h>
+
+
+@interface UIGestureRecognizer (GestureHandler)
+@property (nonatomic, readonly) GestureHandler *gestureHandler;
+@end
+
+
+@implementation UIGestureRecognizer (GestureHandler)
+
+- (GestureHandler *)gestureHandler
+{
+    id delegate = self.delegate;
+    if ([delegate isKindOfClass:[GestureHandler class]]) {
+        return (GestureHandler *)delegate;
+    }
+    return nil;
+}
+
+@end
+
+typedef struct GHHitSlop {
+    CGFloat top, left, bottom, right, width, height;
+} RNGHHitSlop;
+
+static RNGHHitSlop RNGHHitSlopEmpty = { NAN, NAN, NAN, NAN, NAN, NAN };
+
+#define GH_HIT_SLOP_GET(key) (prop[key] == nil ? NAN : [prop[key] doubleValue])
+#define GH_HIT_SLOP_IS_SET(hitSlop) (!isnan(hitSlop.left) || !isnan(hitSlop.right) || \
+                                        !isnan(hitSlop.top) || !isnan(hitSlop.bottom))
+#define GH_HIT_SLOP_INSET(key) (isnan(hitSlop.key) ? 0. : hitSlop.key)
+
+CGRect GHHitSlopInsetRect(CGRect rect, RNGHHitSlop hitSlop) {
+    rect.origin.x -= GH_HIT_SLOP_INSET(left);
+    rect.origin.y -= GH_HIT_SLOP_INSET(top);
+
+    if (!isnan(hitSlop.width)) {
+        if (!isnan(hitSlop.right)) {
+            rect.origin.x = rect.size.width - hitSlop.width + GH_HIT_SLOP_INSET(right);
+        }
+        rect.size.width = hitSlop.width;
+    } else {
+        rect.size.width += (GH_HIT_SLOP_INSET(left) + GH_HIT_SLOP_INSET(right));
+    }
+    if (!isnan(hitSlop.height)) {
+        if (!isnan(hitSlop.bottom)) {
+            rect.origin.y = rect.size.height - hitSlop.height + GH_HIT_SLOP_INSET(bottom);
+        }
+        rect.size.height = hitSlop.height;
+    } else {
+        rect.size.height += (GH_HIT_SLOP_INSET(top) + GH_HIT_SLOP_INSET(bottom));
+    }
+    return rect;
+}
+
+
+@implementation GestureHandler {
+    NSArray<NSNumber *> *_handlersToWaitFor;
+    NSArray<NSNumber *> *_simultaneousHandlers;
+    RNGHHitSlop _hitSlop;
+}
+
+- (instancetype)initWithTag:(NSNumber *)tag
+{
+    if ((self = [super init])) {
+        _tag = tag;
+        _lastState = GestureHandlerStateUndetermined;
+        _hitSlop = RNGHHitSlopEmpty;
+    }
+    return self;
+}
+
+- (void)configure:(NSDictionary *)config
+{
+    _handlersToWaitFor = config[@"waitFor"];
+    _simultaneousHandlers = config[@"simultaneousHandlers"];
+
+    id prop = config[@"enabled"];
+    if (prop != nil) {
+        self.enabled = [prop boolValue];
+    } else {
+        self.enabled = YES;
+    }
+
+    prop = config[@"shouldCancelWhenOutside"];
+    if (prop != nil) {
+        _shouldCancelWhenOutside = [prop boolValue];
+    // } else {
+        // _shouldCancelWhenOutside = NO;
+    }
+
+    prop = config[@"hitSlop"];
+    if ([prop isKindOfClass:[NSNumber class]]) {
+        _hitSlop.left = _hitSlop.right = _hitSlop.top = _hitSlop.bottom = [prop doubleValue];
+    } else if (prop != nil) {
+        _hitSlop.left = _hitSlop.right = GH_HIT_SLOP_GET(@"horizontal");
+        _hitSlop.top = _hitSlop.bottom = GH_HIT_SLOP_GET(@"vertical");
+        _hitSlop.left = GH_HIT_SLOP_GET(@"left");
+        _hitSlop.right = GH_HIT_SLOP_GET(@"right");
+        _hitSlop.top = GH_HIT_SLOP_GET(@"top");
+        _hitSlop.bottom = GH_HIT_SLOP_GET(@"bottom");
+        _hitSlop.width = GH_HIT_SLOP_GET(@"width");
+        _hitSlop.height = GH_HIT_SLOP_GET(@"height");
+        if (isnan(_hitSlop.left) && isnan(_hitSlop.right) && !isnan(_hitSlop.width)) {
+            NSLog(@"When width is set one of left or right pads need to be defined");
+        }
+        if (!isnan(_hitSlop.width) && !isnan(_hitSlop.left) && !isnan(_hitSlop.right)) {
+            NSLog(@"Cannot have all of left, right and width defined");
+        }
+        if (isnan(_hitSlop.top) && isnan(_hitSlop.bottom) && !isnan(_hitSlop.height)) {
+            NSLog(@"When height is set one of top or bottom pads need to be defined");
+        }
+        if (!isnan(_hitSlop.height) && !isnan(_hitSlop.top) && !isnan(_hitSlop.bottom)) {
+            NSLog(@"Cannot have all of top, bottom and height defined");
+        }
+    }
+}
+
+- (void)setEnabled:(BOOL)enabled
+{
+    _enabled = enabled;
+    self.recognizer.enabled = enabled;
+}
+
+- (void)bindToView:(UIView *)view
+{
+    // view.userInteractionEnabled = YES;
+    self.recognizer.delegate = self;
+    [view addGestureRecognizer:self.recognizer];
+}
+
+- (void)unbindFromView
+{
+    [self.recognizer.view removeGestureRecognizer:self.recognizer];
+    self.recognizer.delegate = nil;
+}
+
+- (NSMutableDictionary *)eventExtraData:(UIGestureRecognizer *)recognizer
+{
+  CGPoint position = [recognizer locationInView:recognizer.view];
+  CGPoint absolutePosition = [recognizer locationInView:recognizer.view.window];
+  NSMutableDictionary* result = [NSMutableDictionary new];
+  NSUInteger numberOfTouches = recognizer.numberOfTouches;
+  [result setObject:@(numberOfTouches) forKey:@"numberOfPointers"];
+  [result setObject:@(position.x) forKey:@"x"];
+  [result setObject:@(position.y) forKey:@"y"];
+  [result setObject:@(absolutePosition.y) forKey:@"absoluteX"];
+  [result setObject:@(absolutePosition.y) forKey:@"absoluteY"];
+  NSMutableArray* positions = [NSMutableArray arrayWithCapacity:2*numberOfTouches];
+  for (NSUInteger i = 0; i <numberOfTouches; i++) {
+    CGPoint pos = [recognizer locationOfTouch:i inView:recognizer.view];
+
+    [positions insertObject:@(pos.x) atIndex:2*i];
+    [positions insertObject:@(pos.y) atIndex:2*i+1];
+  }
+  [result setObject:positions forKey:@"positions"];
+  return result;
+}
+
+- (void)handleGesture:(UIGestureRecognizer *)recognizer
+{
+    NSMutableDictionary *eventData = [self eventExtraData:recognizer];
+  [self sendEventsInState:[self stateForRecognizer:recognizer] forView:recognizer.view withExtraData:eventData];
+}
+
+- (void)sendEventsInState:(GestureHandlerState)state
+           forView:(nonnull UIView *)view
+            withExtraData:(nullable NSDictionary *)extraData
+{
+    if (state != _lastState) {
+        if (state == GestureHandlerStateEnd && _lastState != GestureHandlerStateActive) {
+          if (self.delegate) {
+            [self.delegate gestureHandler:self didChangeState:GestureHandlerStateActive prevState:_lastState extraData:extraData view:view];
+          }
+            _lastState = GestureHandlerStateActive;
+        }
+        if (self.delegate) {
+          [self.delegate gestureHandler:self didChangeState:state prevState:_lastState extraData:extraData view:view];
+        }
+        _lastState = state;
+    }
+
+    if (state == GestureHandlerStateActive) {
+      if (self.delegate) {
+        [self.delegate gestureHandler:self touchEventOnView:view state:state extraData:extraData];
+      }
+    }
+}
+
+- (GestureHandlerState)state
+{
+    switch (_recognizer.state) {
+        case UIGestureRecognizerStateBegan:
+        case UIGestureRecognizerStatePossible:
+            return GestureHandlerStateBegan;
+        case UIGestureRecognizerStateEnded:
+            return GestureHandlerStateEnd;
+        case UIGestureRecognizerStateFailed:
+            return GestureHandlerStateFailed;
+        case UIGestureRecognizerStateCancelled:
+            return GestureHandlerStateCancelled;
+        case UIGestureRecognizerStateChanged:
+            return GestureHandlerStateActive;
+    }
+    return GestureHandlerStateUndetermined;
+}
+- (GestureHandlerState)stateForRecognizer:(UIGestureRecognizer*)recognizer
+{
+    switch (recognizer.state) {
+        case UIGestureRecognizerStateBegan:
+        case UIGestureRecognizerStatePossible:
+            return GestureHandlerStateBegan;
+        case UIGestureRecognizerStateEnded:
+            return GestureHandlerStateEnd;
+        case UIGestureRecognizerStateFailed:
+            return GestureHandlerStateFailed;
+        case UIGestureRecognizerStateCancelled:
+            return GestureHandlerStateCancelled;
+        case UIGestureRecognizerStateChanged:
+            return GestureHandlerStateActive;
+    }
+    return GestureHandlerStateUndetermined;
+}
+
+#pragma mark UIGestureRecognizerDelegate
+
++ (GestureHandler *)findGestureHandlerByRecognizer:(UIGestureRecognizer *)recognizer
+{
+    GestureHandler *handler = recognizer.gestureHandler;
+    if (handler != nil) {
+        return handler;
+    }
+
+    // We may try to extract "DummyGestureHandler" in case when "otherGestureRecognizer" belongs to
+    // a native view being wrapped with "NativeViewGestureHandler"
+    UIView *view = recognizer.view;
+//    while (reactView != nil && reactView.reactTag == nil) {
+//        reactView = reactView.superview;
+//    }
+
+    for (UIGestureRecognizer *recognizer in view.gestureRecognizers) {
+        if ([recognizer isKindOfClass:[DummyGestureRecognizer class]]) {
+            return recognizer.gestureHandler;
+        }
+    }
+
+    return nil;
+}
+
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+shouldBeRequiredToFailByGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
+{
+    GestureHandler *handler = [GestureHandler findGestureHandlerByRecognizer:otherGestureRecognizer];
+    if ([handler isKindOfClass:[NativeViewGestureHandler class]]) {
+        for (NSNumber *handlerTag in handler->_handlersToWaitFor) {
+            if ([_tag isEqual:handlerTag]) {
+                return YES;
+            }
+        }
+    }
+
+    return NO;
+}
+
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+shouldRequireFailureOfGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
+{
+    if ([_handlersToWaitFor count]) {
+        GestureHandler *handler = [GestureHandler findGestureHandlerByRecognizer:otherGestureRecognizer];
+        if (handler != nil) {
+            for (NSNumber *handlerTag in _handlersToWaitFor) {
+                if ([handler.tag isEqual:handlerTag]) {
+                    return YES;
+                }
+            }
+        }
+    }
+    return NO;
+}
+
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
+{
+   if (gestureRecognizer.view == otherGestureRecognizer.view && [gestureRecognizer isKindOfClass:[UISwipeGestureRecognizer class]]  && [otherGestureRecognizer isKindOfClass:[UISwipeGestureRecognizer class]]) {
+      return YES;
+    }
+    if (_recognizer.state == UIGestureRecognizerStateBegan && _recognizer.state == UIGestureRecognizerStatePossible) {
+        return YES;
+    }
+    if ([_simultaneousHandlers count]) {
+        GestureHandler *handler = [GestureHandler findGestureHandlerByRecognizer:otherGestureRecognizer];
+        if (handler != nil) {
+            for (NSNumber *handlerTag in _simultaneousHandlers) {
+                if ([handler.tag isEqual:handlerTag]) {
+                    return YES;
+                }
+            }
+        }
+    }
+    return NO;
+}
+
+- (void)reset
+{
+    _lastState = GestureHandlerStateUndetermined;
+}
+
+ - (BOOL)containsPointInView
+ {
+     CGPoint pt = [_recognizer locationInView:_recognizer.view];
+     CGRect hitFrame = GHHitSlopInsetRect(_recognizer.view.bounds, _hitSlop);
+     return CGRectContainsPoint(hitFrame, pt);
+ }
+
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer
+{
+    [self reset];
+    if (self.delegate && [self.delegate respondsToSelector:@selector(gestureHandler:shouldActivateForEvent:)]) {
+        if (![self.delegate gestureHandler:self shouldActivateForEvent:[self eventExtraData:gestureRecognizer]]) {
+          return FALSE;
+        }
+    }
+    return YES;
+}
+
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldReceiveTouch:(UITouch *)touch
+{
+#if TARGET_IPHONE_SIMULATOR
+    // we get unwanted touch on simulator which messes everything
+    UIView* view = gestureRecognizer.view;
+    CGPoint location = [touch locationInView:gestureRecognizer.view];
+    if (touch.phase == UITouchPhaseBegan && location.x == 0 && round(location.y) == view.window.bounds.size.height) {
+        return NO;
+    }
+#endif // TARGET_IPHONE_SIMULATOR
+
+    // If hitSlop is set we use it to determine if a given gesture recognizer should start processing
+    // touch stream. This only works for negative values of hitSlop as this method won't be triggered
+    // unless touch startes in the bounds of the attached view. To acheve similar effect with positive
+    // values of hitSlop one should set hitSlop for the underlying view. This limitation is due to the
+    // fact that hitTest method is only available at the level of UIView
+    if (GH_HIT_SLOP_IS_SET(_hitSlop)) {
+        CGPoint location = [touch locationInView:gestureRecognizer.view];
+        CGRect hitFrame = GHHitSlopInsetRect(gestureRecognizer.view.bounds, _hitSlop);
+        return CGRectContainsPoint(hitFrame, location);
+    }
+    return YES;
+}
+
+//- (void)sendTouchEvent:(GestureHandlerEvent *)event
+//{
+//  //    [_eventDispatcher sendEvent:event];
+//}
+//
+//- (void)sendStateChangeEvent:(GestureHandlerStateChange *)event
+//{
+//  //    [_eventDispatcher sendEvent:event];
+//}
+
+
+@end