+
+
+
+
+
diff --git a/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/log.html b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/log.html
new file mode 100644
index 00000000..8a8bb292
--- /dev/null
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/log.html
@@ -0,0 +1,61 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/multiple.html b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/multiple.html
new file mode 100644
index 00000000..544749e9
--- /dev/null
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/multiple.html
@@ -0,0 +1,73 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/nested.html b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/nested.html
new file mode 100644
index 00000000..d562173e
--- /dev/null
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/nested.html
@@ -0,0 +1,217 @@
+
+
+
+
+
+
+
+ Multiple instances the same time
+You can run multiple instances of Hammer on your page and they will recognize each completely isolated + from each other. This makes it possible to build multi-user interfaces.
+ +
+
+
+
+
+
+
+ 1.1
+ 1.2
+ 1.3
+ 1.4
+ 1.5
+
+
+
+
+ 2.1
+ 2.2
+ 2.3
+ 2.4
+ 2.5
+
+
+
+
+ 3.1
+ 3.2
+ 3.3
+ 3.4
+ 3.5
+
+
+
+
+ 4.1
+ 4.2
+ 4.3
+ 4.4
+ 4.5
+
+
+
+
+ 5.1
+ 5.2
+ 5.3
+ 5.4
+ 5.5
+
+
+
+
+
+
+
+
diff --git a/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/simulator-googlemaps.html b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/simulator-googlemaps.html
new file mode 100644
index 00000000..6100621f
--- /dev/null
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/simulator-googlemaps.html
@@ -0,0 +1,100 @@
+
+
+
+
+
+ Nested Pan recognizers
+ +Nested recognizers are possible with some threshold and with use of requireFailure().
+
+
+
+
+
+
+
+
+
+
diff --git a/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/simulator.html b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/simulator.html
new file mode 100644
index 00000000..cf4fa046
--- /dev/null
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/simulator.html
@@ -0,0 +1,118 @@
+
+
+
+
+
+ Gestures simulator
+Used for unit-testing Hammer.js. To test it on the Google Maps view, you should open your + + Inspector and emulate a touch-screen. + Or just open it on your touch-device.
+Currently, it only triggers touchEvents.
+
+
+
+
+
+
+
+
+
+
diff --git a/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/touchaction.html b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/touchaction.html
new file mode 100644
index 00000000..edff019a
--- /dev/null
+++ b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/touchaction.html
@@ -0,0 +1,91 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Hammer provides a kind of polyfill + for the browsers that don't support the touch-action property.
+ +Your browser has support for the touch-action property!
+ Your browser doesn't support the touch-action property,
+ so we use the polyfill.
+
+ touch-action: auto
+Should prevent nothing.
+ + +touch-action: pan-y
+Should prevent scrolling on horizontal movement. This is set by default when creating a Hammer instance.
+ + +touch-action: pan-x
+Should prevent scrolling on vertical movement.
+ + +touch-action: pan-x pan-y
+Should not prevent any scrolling on any movement. Horizontal and vertical scrolling handled by the browser directly.
+ + +touch-action: none
+Should prevent all.
+ +hi.
+ + + diff --git a/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/visual.html b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/visual.html new file mode 100644 index 00000000..b24a7a4f --- /dev/null +++ b/iut-expo-starter/node_modules/@egjs/hammerjs/tests/manual/visual.html @@ -0,0 +1,211 @@ + + + + + +
+
+### Declarative API exposing platform native touch and gesture system to React Native.
+
+React Native Gesture Handler provides native-driven gesture management APIs for building best possible touch-based experiences in React Native.
+
+With this library gestures are no longer controlled by the JS responder system, but instead are recognized and tracked in the UI thread.
+It makes touch interactions and gesture tracking not only smooth, but also dependable and deterministic.
+
+## Installation
+
+Check [getting started](https://docs.swmansion.com/react-native-gesture-handler/docs/#installation) section of our docs for the detailed installation instructions.
+
+## Fabric
+
+To learn how to use `react-native-gesture-handler` with Fabric architecture, head over to [Fabric README](README-Fabric.md). Instructions on how to run Fabric Example within this repo can be found in the [FabricExample README](FabricExample/README.md).
+
+## Documentation
+
+Check out our dedicated documentation page for info about this library, API reference and more: [https://docs.swmansion.com/react-native-gesture-handler/docs/](https://docs.swmansion.com/react-native-gesture-handler/docs/)
+
+## Examples
+
+If you want to play with the API but don't feel like trying it on a real app, you can run the example project. Clone the repo, go to the `example` folder and run:
+
+```bash
+yarn install
+```
+
+If you are running on ios, run `pod install` in the ios folder
+
+Run `yarn start` to start the metro bundler
+
+Run `yarn android` or `yarn ios` (depending on which platform you want to run the example app on).
+
+You will need to have an Android or iOS device or emulator connected as well as `react-native-cli` package installed globally.
+
+## React Native Support
+
+| version | react-native version |
+| ------- | -------------------- |
+| 2.0.0+ | 0.63.0+ |
+| 1.4.0+ | 0.60.0+ |
+| 1.1.0+ | 0.57.2+ |
+| <1.1.0 | 0.50.0+ |
+
+It may be possible to use newer versions of react-native-gesture-handler on React Native with version <= 0.59 by reverse Jetifying.
+Read more on that here -
+ *
- Create an instance of the {@code ScaleGestureDetector} for your + * {@link View} + *
- In the {@link View#onTouchEvent(MotionEvent)} method ensure you call + * {@link #onTouchEvent(MotionEvent)}. The methods defined in your + * callback will be executed when the events occur. + *
-
+ *
- One {@link OnScaleGestureListener#onScaleBegin(ScaleGestureDetector)} + *
- Zero or more {@link OnScaleGestureListener#onScale(ScaleGestureDetector)} + *
- One {@link OnScaleGestureListener#onScaleEnd(ScaleGestureDetector)} + *
Applications should pass a complete and consistent event stream to this method. + * A complete and consistent event stream involves all MotionEvents from the initial + * ACTION_DOWN to the final ACTION_UP or ACTION_CANCEL.
+ * + * @param event The event to process + * @return true if the event was processed and the detector wants to receive the + * rest of the MotionEvents in this event stream. + */ + public boolean onTouchEvent(MotionEvent event) { + mCurrTime = event.getEventTime(); + + final int action = event.getActionMasked(); + + // Forward the event to check for double tap gesture + if (mQuickScaleEnabled) { + mGestureDetector.onTouchEvent(event); + } + + final int count = event.getPointerCount(); + final boolean isStylusButtonDown = + (event.getButtonState() & MotionEvent.BUTTON_STYLUS_PRIMARY) != 0; + + final boolean anchoredScaleCancelled = + mAnchoredScaleMode == ANCHORED_SCALE_MODE_STYLUS && !isStylusButtonDown; + final boolean streamComplete = action == MotionEvent.ACTION_UP || + action == MotionEvent.ACTION_CANCEL || anchoredScaleCancelled; + + if (action == MotionEvent.ACTION_DOWN || streamComplete) { + // Reset any scale in progress with the listener. + // If it's an ACTION_DOWN we're beginning a new event stream. + // This means the app probably didn't give us all the events. Shame on it. + if (mInProgress) { + mListener.onScaleEnd(this); + mInProgress = false; + mInitialSpan = 0; + mAnchoredScaleMode = ANCHORED_SCALE_MODE_NONE; + } else if (inAnchoredScaleMode() && streamComplete) { + mInProgress = false; + mInitialSpan = 0; + mAnchoredScaleMode = ANCHORED_SCALE_MODE_NONE; + } + + if (streamComplete) { + return true; + } + } + + if (!mInProgress && mStylusScaleEnabled && !inAnchoredScaleMode() + && !streamComplete && isStylusButtonDown) { + // Start of a button scale gesture + mAnchoredScaleStartX = event.getX(); + mAnchoredScaleStartY = event.getY(); + mAnchoredScaleMode = ANCHORED_SCALE_MODE_STYLUS; + mInitialSpan = 0; + } + + final boolean configChanged = action == MotionEvent.ACTION_DOWN || + action == MotionEvent.ACTION_POINTER_UP || + action == MotionEvent.ACTION_POINTER_DOWN || anchoredScaleCancelled; + + final boolean pointerUp = action == MotionEvent.ACTION_POINTER_UP; + final int skipIndex = pointerUp ? event.getActionIndex() : -1; + + // Determine focal point + float sumX = 0, sumY = 0; + final int div = pointerUp ? count - 1 : count; + final float focusX; + final float focusY; + if (inAnchoredScaleMode()) { + // In anchored scale mode, the focal pt is always where the double tap + // or button down gesture started + focusX = mAnchoredScaleStartX; + focusY = mAnchoredScaleStartY; + if (event.getY() < focusY) { + mEventBeforeOrAboveStartingGestureEvent = true; + } else { + mEventBeforeOrAboveStartingGestureEvent = false; + } + } else { + for (int i = 0; i < count; i++) { + if (skipIndex == i) continue; + sumX += event.getX(i); + sumY += event.getY(i); + } + + focusX = sumX / div; + focusY = sumY / div; + } + + // Determine average deviation from focal point + float devSumX = 0, devSumY = 0; + for (int i = 0; i < count; i++) { + if (skipIndex == i) continue; + + // Convert the resulting diameter into a radius. + devSumX += Math.abs(event.getX(i) - focusX); + devSumY += Math.abs(event.getY(i) - focusY); + } + final float devX = devSumX / div; + final float devY = devSumY / div; + + // Span is the average distance between touch points through the focal point; + // i.e. the diameter of the circle with a radius of the average deviation from + // the focal point. + final float spanX = devX * 2; + final float spanY = devY * 2; + final float span; + if (inAnchoredScaleMode()) { + span = spanY; + } else { + span = (float) Math.hypot(spanX, spanY); + } + + // Dispatch begin/end events as needed. + // If the configuration changes, notify the app to reset its current state by beginning + // a fresh scale event stream. + final boolean wasInProgress = mInProgress; + mFocusX = focusX; + mFocusY = focusY; + if (!inAnchoredScaleMode() && mInProgress && (span < mMinSpan || configChanged)) { + mListener.onScaleEnd(this); + mInProgress = false; + mInitialSpan = span; + } + if (configChanged) { + mPrevSpanX = mCurrSpanX = spanX; + mPrevSpanY = mCurrSpanY = spanY; + mInitialSpan = mPrevSpan = mCurrSpan = span; + } + + final int minSpan = inAnchoredScaleMode() ? mSpanSlop : mMinSpan; + if (!mInProgress && span >= minSpan && + (wasInProgress || Math.abs(span - mInitialSpan) > mSpanSlop)) { + mPrevSpanX = mCurrSpanX = spanX; + mPrevSpanY = mCurrSpanY = spanY; + mPrevSpan = mCurrSpan = span; + mPrevTime = mCurrTime; + mInProgress = mListener.onScaleBegin(this); + } + + // Handle motion; focal point and span/scale factor are changing. + if (action == MotionEvent.ACTION_MOVE) { + mCurrSpanX = spanX; + mCurrSpanY = spanY; + mCurrSpan = span; + + boolean updatePrev = true; + + if (mInProgress) { + updatePrev = mListener.onScale(this); + } + + if (updatePrev) { + mPrevSpanX = mCurrSpanX; + mPrevSpanY = mCurrSpanY; + mPrevSpan = mCurrSpan; + mPrevTime = mCurrTime; + } + } + + return true; + } + + private boolean inAnchoredScaleMode() { + return mAnchoredScaleMode != ANCHORED_SCALE_MODE_NONE; + } + + /** + * Set whether the associated {@link OnScaleGestureListener} should receive onScale callbacks + * when the user performs a doubleTap followed by a swipe. Note that this is enabled by default + * if the app targets API 19 and newer. + * @param scales true to enable quick scaling, false to disable + */ + public void setQuickScaleEnabled(boolean scales) { + mQuickScaleEnabled = scales; + if (mQuickScaleEnabled && mGestureDetector == null) { + GestureDetector.SimpleOnGestureListener gestureListener = + new GestureDetector.SimpleOnGestureListener() { + @Override + public boolean onDoubleTap(MotionEvent e) { + // Double tap: start watching for a swipe + mAnchoredScaleStartX = e.getX(); + mAnchoredScaleStartY = e.getY(); + mAnchoredScaleMode = ANCHORED_SCALE_MODE_DOUBLE_TAP; + return true; + } + }; + mGestureDetector = new GestureDetector(mContext, gestureListener, mHandler); + } + } + + /** + * Return whether the quick scale gesture, in which the user performs a double tap followed by a + * swipe, should perform scaling. {@see #setQuickScaleEnabled(boolean)}. + */ + public boolean isQuickScaleEnabled() { + return mQuickScaleEnabled; + } + + /** + * Sets whether the associates {@link OnScaleGestureListener} should receive + * onScale callbacks when the user uses a stylus and presses the button. + * Note that this is enabled by default if the app targets API 23 and newer. + * + * @param scales true to enable stylus scaling, false to disable. + */ + public void setStylusScaleEnabled(boolean scales) { + mStylusScaleEnabled = scales; + } + + /** + * Return whether the stylus scale gesture, in which the user uses a stylus and presses the + * button, should perform scaling. {@see #setStylusScaleEnabled(boolean)} + */ + public boolean isStylusScaleEnabled() { + return mStylusScaleEnabled; + } + + /** + * Returns {@code true} if a scale gesture is in progress. + */ + public boolean isInProgress() { + return mInProgress; + } + + /** + * Get the X coordinate of the current gesture's focal point. + * If a gesture is in progress, the focal point is between + * each of the pointers forming the gesture. + * + * If {@link #isInProgress()} would return false, the result of this + * function is undefined. + * + * @return X coordinate of the focal point in pixels. + */ + public float getFocusX() { + return mFocusX; + } + + /** + * Get the Y coordinate of the current gesture's focal point. + * If a gesture is in progress, the focal point is between + * each of the pointers forming the gesture. + * + * If {@link #isInProgress()} would return false, the result of this + * function is undefined. + * + * @return Y coordinate of the focal point in pixels. + */ + public float getFocusY() { + return mFocusY; + } + + /** + * Return the average distance between each of the pointers forming the + * gesture in progress through the focal point. + * + * @return Distance between pointers in pixels. + */ + public float getCurrentSpan() { + return mCurrSpan; + } + + /** + * Return the average X distance between each of the pointers forming the + * gesture in progress through the focal point. + * + * @return Distance between pointers in pixels. + */ + public float getCurrentSpanX() { + return mCurrSpanX; + } + + /** + * Return the average Y distance between each of the pointers forming the + * gesture in progress through the focal point. + * + * @return Distance between pointers in pixels. + */ + public float getCurrentSpanY() { + return mCurrSpanY; + } + + /** + * Return the previous average distance between each of the pointers forming the + * gesture in progress through the focal point. + * + * @return Previous distance between pointers in pixels. + */ + public float getPreviousSpan() { + return mPrevSpan; + } + + /** + * Return the previous average X distance between each of the pointers forming the + * gesture in progress through the focal point. + * + * @return Previous distance between pointers in pixels. + */ + public float getPreviousSpanX() { + return mPrevSpanX; + } + + /** + * Return the previous average Y distance between each of the pointers forming the + * gesture in progress through the focal point. + * + * @return Previous distance between pointers in pixels. + */ + public float getPreviousSpanY() { + return mPrevSpanY; + } + + /** + * Return the scaling factor from the previous scale event to the current + * event. This value is defined as + * ({@link #getCurrentSpan()} / {@link #getPreviousSpan()}). + * + * @return The current scaling factor. + */ + public float getScaleFactor() { + if (inAnchoredScaleMode()) { + // Drag is moving up; the further away from the gesture + // start, the smaller the span should be, the closer, + // the larger the span, and therefore the larger the scale + final boolean scaleUp = + (mEventBeforeOrAboveStartingGestureEvent && (mCurrSpan < mPrevSpan)) || + (!mEventBeforeOrAboveStartingGestureEvent && (mCurrSpan > mPrevSpan)); + final float spanDiff = (Math.abs(1 - (mCurrSpan / mPrevSpan)) * SCALE_FACTOR); + return mPrevSpan <= mSpanSlop ? 1 : scaleUp ? (1 + spanDiff) : (1 - spanDiff); + } + return mPrevSpan > 0 ? mCurrSpan / mPrevSpan : 1; + } + + /** + * Return the time difference in milliseconds between the previous + * accepted scaling event and the current scaling event. + * + * @return Time difference since the last scaling event in milliseconds. + */ + public long getTimeDelta() { + return mCurrTime - mPrevTime; + } + + /** + * Return the event time of the current event being processed. + * + * @return Current event time in milliseconds. + */ + public long getEventTime() { + return mCurrTime; + } +} diff --git a/iut-expo-starter/node_modules/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/core/TapGestureHandler.kt b/iut-expo-starter/node_modules/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/core/TapGestureHandler.kt new file mode 100644 index 00000000..cb8adc77 --- /dev/null +++ b/iut-expo-starter/node_modules/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/core/TapGestureHandler.kt @@ -0,0 +1,168 @@ +package com.swmansion.gesturehandler.core + +import android.os.Handler +import android.os.Looper +import android.view.MotionEvent +import com.swmansion.gesturehandler.core.GestureUtils.getLastPointerX +import com.swmansion.gesturehandler.core.GestureUtils.getLastPointerY +import kotlin.math.abs + +class TapGestureHandler : GestureHandler