summaryrefslogtreecommitdiffstats
path: root/accessible/jsat/Gestures.jsm
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /accessible/jsat/Gestures.jsm
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'accessible/jsat/Gestures.jsm')
-rw-r--r--accessible/jsat/Gestures.jsm956
1 files changed, 956 insertions, 0 deletions
diff --git a/accessible/jsat/Gestures.jsm b/accessible/jsat/Gestures.jsm
new file mode 100644
index 000000000..cc431614c
--- /dev/null
+++ b/accessible/jsat/Gestures.jsm
@@ -0,0 +1,956 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* global Components, GestureSettings, XPCOMUtils, Utils, Promise, Logger */
+/* exported GestureSettings, GestureTracker */
+
+/******************************************************************************
+ All gestures have the following pathways when being resolved(v)/rejected(x):
+ Tap -> DoubleTap (x)
+ -> Dwell (x)
+ -> Swipe (x)
+
+ DoubleTap -> TripleTap (x)
+ -> TapHold (x)
+
+ TripleTap -> DoubleTapHold (x)
+
+ Dwell -> DwellEnd (v)
+
+ Swipe -> Explore (x)
+
+ TapHold -> TapHoldEnd (v)
+
+ DoubleTapHold -> DoubleTapHoldEnd (v)
+
+ DwellEnd -> Explore (x)
+
+ TapHoldEnd -> Explore (x)
+
+ DoubleTapHoldEnd -> Explore (x)
+
+ ExploreEnd -> Explore (x)
+
+ Explore -> ExploreEnd (v)
+******************************************************************************/
+
+'use strict';
+
+const Cu = Components.utils;
+
+this.EXPORTED_SYMBOLS = ['GestureSettings', 'GestureTracker']; // jshint ignore:line
+
+Cu.import('resource://gre/modules/XPCOMUtils.jsm');
+
+XPCOMUtils.defineLazyModuleGetter(this, 'Utils', // jshint ignore:line
+ 'resource://gre/modules/accessibility/Utils.jsm');
+XPCOMUtils.defineLazyModuleGetter(this, 'Logger', // jshint ignore:line
+ 'resource://gre/modules/accessibility/Utils.jsm');
+XPCOMUtils.defineLazyModuleGetter(this, 'setTimeout', // jshint ignore:line
+ 'resource://gre/modules/Timer.jsm');
+XPCOMUtils.defineLazyModuleGetter(this, 'clearTimeout', // jshint ignore:line
+ 'resource://gre/modules/Timer.jsm');
+XPCOMUtils.defineLazyModuleGetter(this, 'Promise', // jshint ignore:line
+ 'resource://gre/modules/Promise.jsm');
+
+// Default maximum duration of swipe
+const SWIPE_MAX_DURATION = 200;
+// Default maximum amount of time allowed for a gesture to be considered a
+// multitouch
+const MAX_MULTITOUCH = 125;
+// Default maximum consecutive pointer event timeout
+const MAX_CONSECUTIVE_GESTURE_DELAY = 200;
+// Default delay before tap turns into dwell
+const DWELL_THRESHOLD = 250;
+// Minimal swipe distance in inches
+const SWIPE_MIN_DISTANCE = 0.4;
+// Maximum distance the pointer could move during a tap in inches
+const TAP_MAX_RADIUS = 0.2;
+// Directness coefficient. It is based on the maximum 15 degree angle between
+// consequent pointer move lines.
+const DIRECTNESS_COEFF = 1.44;
+// Amount in inches from the edges of the screen for it to be an edge swipe
+const EDGE = 0.1;
+// Multiply timeouts by this constant, x2 works great too for slower users.
+const TIMEOUT_MULTIPLIER = 1;
+// A single pointer down/up sequence periodically precedes the tripple swipe
+// gesture on Android. This delay acounts for that.
+const IS_ANDROID = Utils.MozBuildApp === 'mobile/android' &&
+ Utils.AndroidSdkVersion >= 14;
+
+/**
+ * A point object containing distance travelled data.
+ * @param {Object} aPoint A point object that looks like: {
+ * x: x coordinate in pixels,
+ * y: y coordinate in pixels
+ * }
+ */
+function Point(aPoint) {
+ this.startX = this.x = aPoint.x;
+ this.startY = this.y = aPoint.y;
+ this.distanceTraveled = 0;
+ this.totalDistanceTraveled = 0;
+}
+
+Point.prototype = {
+ /**
+ * Update the current point coordiates.
+ * @param {Object} aPoint A new point coordinates.
+ */
+ update: function Point_update(aPoint) {
+ let lastX = this.x;
+ let lastY = this.y;
+ this.x = aPoint.x;
+ this.y = aPoint.y;
+ this.distanceTraveled = this.getDistanceToCoord(lastX, lastY);
+ this.totalDistanceTraveled += this.distanceTraveled;
+ },
+
+ reset: function Point_reset() {
+ this.distanceTraveled = 0;
+ this.totalDistanceTraveled = 0;
+ },
+
+ /**
+ * Get distance between the current point coordinates and the given ones.
+ * @param {Number} aX A pixel value for the x coordinate.
+ * @param {Number} aY A pixel value for the y coordinate.
+ * @return {Number} A distance between point's current and the given
+ * coordinates.
+ */
+ getDistanceToCoord: function Point_getDistanceToCoord(aX, aY) {
+ return Math.hypot(this.x - aX, this.y - aY);
+ },
+
+ /**
+ * Get the direct distance travelled by the point so far.
+ */
+ get directDistanceTraveled() {
+ return this.getDistanceToCoord(this.startX, this.startY);
+ }
+};
+
+/**
+ * An externally accessible collection of settings used in gesture resolition.
+ * @type {Object}
+ */
+this.GestureSettings = { // jshint ignore:line
+ /**
+ * Maximum duration of swipe
+ * @type {Number}
+ */
+ swipeMaxDuration: SWIPE_MAX_DURATION * TIMEOUT_MULTIPLIER,
+
+ /**
+ * Maximum amount of time allowed for a gesture to be considered a multitouch.
+ * @type {Number}
+ */
+ maxMultitouch: MAX_MULTITOUCH * TIMEOUT_MULTIPLIER,
+
+ /**
+ * Maximum consecutive pointer event timeout.
+ * @type {Number}
+ */
+ maxConsecutiveGestureDelay:
+ MAX_CONSECUTIVE_GESTURE_DELAY * TIMEOUT_MULTIPLIER,
+
+ /**
+ * A maximum time we wait for a next pointer down event to consider a sequence
+ * a multi-action gesture.
+ * @type {Number}
+ */
+ maxGestureResolveTimeout:
+ MAX_CONSECUTIVE_GESTURE_DELAY * TIMEOUT_MULTIPLIER,
+
+ /**
+ * Delay before tap turns into dwell
+ * @type {Number}
+ */
+ dwellThreshold: DWELL_THRESHOLD * TIMEOUT_MULTIPLIER,
+
+ /**
+ * Minimum distance that needs to be travelled for the pointer move to be
+ * fired.
+ * @type {Number}
+ */
+ travelThreshold: 0.025
+};
+
+/**
+ * An interface that handles the pointer events and calculates the appropriate
+ * gestures.
+ * @type {Object}
+ */
+this.GestureTracker = { // jshint ignore:line
+ /**
+ * Reset GestureTracker to its initial state.
+ * @return {[type]} [description]
+ */
+ reset: function GestureTracker_reset() {
+ if (this.current) {
+ this.current.clearTimer();
+ }
+ delete this.current;
+ },
+
+ /**
+ * Create a new gesture object and attach resolution handler to it as well as
+ * handle the incoming pointer event.
+ * @param {Object} aDetail A new pointer event detail.
+ * @param {Number} aTimeStamp A new pointer event timeStamp.
+ * @param {Function} aGesture A gesture constructor (default: Tap).
+ */
+ _init: function GestureTracker__init(aDetail, aTimeStamp, aGesture) {
+ // Only create a new gesture on |pointerdown| event.
+ if (aDetail.type !== 'pointerdown') {
+ return;
+ }
+ let GestureConstructor = aGesture || (IS_ANDROID ? DoubleTap : Tap);
+ this._create(GestureConstructor);
+ this._update(aDetail, aTimeStamp);
+ },
+
+ /**
+ * Handle the incoming pointer event with the existing gesture object(if
+ * present) or with the newly created one.
+ * @param {Object} aDetail A new pointer event detail.
+ * @param {Number} aTimeStamp A new pointer event timeStamp.
+ */
+ handle: function GestureTracker_handle(aDetail, aTimeStamp) {
+ Logger.gesture(() => {
+ return ['Pointer event', Utils.dpi, 'at:', aTimeStamp, JSON.stringify(aDetail)];
+ });
+ this[this.current ? '_update' : '_init'](aDetail, aTimeStamp);
+ },
+
+ /**
+ * Create a new gesture object and attach resolution handler to it.
+ * @param {Function} aGesture A gesture constructor.
+ * @param {Number} aTimeStamp An original pointer event timeStamp.
+ * @param {Array} aPoints All changed points associated with the new pointer
+ * event.
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+ _create: function GestureTracker__create(aGesture, aTimeStamp, aPoints, aLastEvent) {
+ this.current = new aGesture(aTimeStamp, aPoints, aLastEvent); /* A constructor name should start with an uppercase letter. */ // jshint ignore:line
+ this.current.then(this._onFulfill.bind(this));
+ },
+
+ /**
+ * Handle the incoming pointer event with the existing gesture object.
+ * @param {Object} aDetail A new pointer event detail.
+ * @param {Number} aTimeStamp A new pointer event timeStamp.
+ */
+ _update: function GestureTracker_update(aDetail, aTimeStamp) {
+ this.current[aDetail.type](aDetail.points, aTimeStamp);
+ },
+
+ /**
+ * A resolution handler function for the current gesture promise.
+ * @param {Object} aResult A resolution payload with the relevant gesture id
+ * and an optional new gesture contructor.
+ */
+ _onFulfill: function GestureTracker__onFulfill(aResult) {
+ let {id, gestureType} = aResult;
+ let current = this.current;
+ // Do nothing if there's no existing gesture or there's already a newer
+ // gesture.
+ if (!current || current.id !== id) {
+ return;
+ }
+ // Only create a gesture if we got a constructor.
+ if (gestureType) {
+ this._create(gestureType, current.startTime, current.points,
+ current.lastEvent);
+ } else {
+ this.current.clearTimer();
+ delete this.current;
+ }
+ }
+};
+
+/**
+ * Compile a mozAccessFuGesture detail structure.
+ * @param {String} aType A gesture type.
+ * @param {Object} aPoints Gesture's points.
+ * @param {String} xKey A default key for the x coordinate. Default is
+ * 'startX'.
+ * @param {String} yKey A default key for the y coordinate. Default is
+ * 'startY'.
+ * @return {Object} a mozAccessFuGesture detail structure.
+ */
+function compileDetail(aType, aPoints, keyMap = {x: 'startX', y: 'startY'}) {
+ let touches = [];
+ let maxDeltaX = 0;
+ let maxDeltaY = 0;
+ for (let identifier in aPoints) {
+ let point = aPoints[identifier];
+ let touch = {};
+ for (let key in keyMap) {
+ touch[key] = point[keyMap[key]];
+ }
+ touches.push(touch);
+ let deltaX = point.x - point.startX;
+ let deltaY = point.y - point.startY;
+ // Determine the maximum x and y travel intervals.
+ if (Math.abs(maxDeltaX) < Math.abs(deltaX)) {
+ maxDeltaX = deltaX;
+ }
+ if (Math.abs(maxDeltaY) < Math.abs(deltaY)) {
+ maxDeltaY = deltaY;
+ }
+ // Since the gesture is resolving, reset the points' distance information
+ // since they are passed to the next potential gesture.
+ point.reset();
+ }
+ return {
+ type: aType,
+ touches: touches,
+ deltaX: maxDeltaX,
+ deltaY: maxDeltaY
+ };
+}
+
+/**
+ * A general gesture object.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * Default is an empty object.
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function Gesture(aTimeStamp, aPoints = {}, aLastEvent = undefined) {
+ this.startTime = Date.now();
+ Logger.gesture('Creating', this.id, 'gesture.');
+ this.points = aPoints;
+ this.lastEvent = aLastEvent;
+ this._deferred = Promise.defer();
+ // Call this._handleResolve or this._handleReject when the promise is
+ // fulfilled with either resolve or reject.
+ this.promise = this._deferred.promise.then(this._handleResolve.bind(this),
+ this._handleReject.bind(this));
+ this.startTimer(aTimeStamp);
+}
+
+Gesture.prototype = {
+ /**
+ * Get the gesture timeout delay.
+ * @return {Number}
+ */
+ _getDelay: function Gesture__getDelay() {
+ // If nothing happens withing the
+ // GestureSettings.maxConsecutiveGestureDelay, we should not wait for any
+ // more pointer events and consider them the part of the same gesture -
+ // reject this gesture promise.
+ return GestureSettings.maxConsecutiveGestureDelay;
+ },
+
+ /**
+ * Clear the existing timer.
+ */
+ clearTimer: function Gesture_clearTimer() {
+ Logger.gesture('clearTimeout', this.type);
+ clearTimeout(this._timer);
+ delete this._timer;
+ },
+
+ /**
+ * Start the timer for gesture timeout.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that
+ * started the gesture resolution sequence.
+ */
+ startTimer: function Gesture_startTimer(aTimeStamp) {
+ Logger.gesture('startTimer', this.type);
+ this.clearTimer();
+ let delay = this._getDelay(aTimeStamp);
+ let handler = () => {
+ Logger.gesture('timer handler');
+ this.clearTimer();
+ if (!this._inProgress) {
+ this._deferred.reject();
+ } else if (this._rejectToOnWait) {
+ this._deferred.reject(this._rejectToOnWait);
+ }
+ };
+ if (delay <= 0) {
+ handler();
+ } else {
+ this._timer = setTimeout(handler, delay);
+ }
+ },
+
+ /**
+ * Add a gesture promise resolution callback.
+ * @param {Function} aCallback
+ */
+ then: function Gesture_then(aCallback) {
+ this.promise.then(aCallback);
+ },
+
+ /**
+ * Update gesture's points. Test the points set with the optional gesture test
+ * function.
+ * @param {Array} aPoints An array with the changed points from the new
+ * pointer event.
+ * @param {String} aType Pointer event type.
+ * @param {Boolean} aCanCreate A flag that enables including the new points.
+ * Default is false.
+ * @param {Boolean} aNeedComplete A flag that indicates that the gesture is
+ * completing. Default is false.
+ * @return {Boolean} Indicates whether the gesture can be complete (it is
+ * set to true iff the aNeedComplete is true and there was a change to at
+ * least one point that belongs to the gesture).
+ */
+ _update: function Gesture__update(aPoints, aType, aCanCreate = false, aNeedComplete = false) {
+ let complete;
+ let lastEvent;
+ for (let point of aPoints) {
+ let identifier = point.identifier;
+ let gesturePoint = this.points[identifier];
+ if (gesturePoint) {
+ if (aType === 'pointerdown' && aCanCreate) {
+ // scratch the previous pointer with that id.
+ this.points[identifier] = new Point(point);
+ } else {
+ gesturePoint.update(point);
+ }
+ if (aNeedComplete) {
+ // Since the gesture is completing and at least one of the gesture
+ // points is updated, set the return value to true.
+ complete = true;
+ }
+ lastEvent = lastEvent || aType;
+ } else if (aCanCreate) {
+ // Only create a new point if aCanCreate is true.
+ this.points[identifier] =
+ new Point(point);
+ lastEvent = lastEvent || aType;
+ }
+ }
+ this.lastEvent = lastEvent || this.lastEvent;
+ // If test function is defined test the points.
+ if (this.test) {
+ this.test(complete);
+ }
+ return complete;
+ },
+
+ /**
+ * Emit a mozAccessFuGesture (when the gesture is resolved).
+ * @param {Object} aDetail a compiled mozAccessFuGesture detail structure.
+ */
+ _emit: function Gesture__emit(aDetail) {
+ let evt = new Utils.win.CustomEvent('mozAccessFuGesture', {
+ bubbles: true,
+ cancelable: true,
+ detail: aDetail
+ });
+ Utils.win.dispatchEvent(evt);
+ },
+
+ /**
+ * Handle the pointer down event.
+ * @param {Array} aPoints A new pointer down points.
+ * @param {Number} aTimeStamp A new pointer down timeStamp.
+ */
+ pointerdown: function Gesture_pointerdown(aPoints, aTimeStamp) {
+ this._inProgress = true;
+ this._update(aPoints, 'pointerdown',
+ aTimeStamp - this.startTime < GestureSettings.maxMultitouch);
+ },
+
+ /**
+ * Handle the pointer move event.
+ * @param {Array} aPoints A new pointer move points.
+ */
+ pointermove: function Gesture_pointermove(aPoints) {
+ this._update(aPoints, 'pointermove');
+ },
+
+ /**
+ * Handle the pointer up event.
+ * @param {Array} aPoints A new pointer up points.
+ */
+ pointerup: function Gesture_pointerup(aPoints) {
+ let complete = this._update(aPoints, 'pointerup', false, true);
+ if (complete) {
+ this._deferred.resolve();
+ }
+ },
+
+ /**
+ * A subsequent gesture constructor to resolve the current one to. E.g.
+ * tap->doubletap, dwell->dwellend, etc.
+ * @type {Function}
+ */
+ resolveTo: null,
+
+ /**
+ * A unique id for the gesture. Composed of the type + timeStamp.
+ */
+ get id() {
+ delete this._id;
+ this._id = this.type + this.startTime;
+ return this._id;
+ },
+
+ /**
+ * A gesture promise resolve callback. Compile and emit the gesture.
+ * @return {Object} Returns a structure to the gesture handler that looks like
+ * this: {
+ * id: current gesture id,
+ * gestureType: an optional subsequent gesture constructor.
+ * }
+ */
+ _handleResolve: function Gesture__handleResolve() {
+ if (this.isComplete) {
+ return;
+ }
+ Logger.gesture('Resolving', this.id, 'gesture.');
+ this.isComplete = true;
+ this.clearTimer();
+ let detail = this.compile();
+ if (detail) {
+ this._emit(detail);
+ }
+ return {
+ id: this.id,
+ gestureType: this.resolveTo
+ };
+ },
+
+ /**
+ * A gesture promise reject callback.
+ * @return {Object} Returns a structure to the gesture handler that looks like
+ * this: {
+ * id: current gesture id,
+ * gestureType: an optional subsequent gesture constructor.
+ * }
+ */
+ _handleReject: function Gesture__handleReject(aRejectTo) {
+ if (this.isComplete) {
+ return;
+ }
+ Logger.gesture('Rejecting', this.id, 'gesture.');
+ this.isComplete = true;
+ this.clearTimer();
+ return {
+ id: this.id,
+ gestureType: aRejectTo
+ };
+ },
+
+ /**
+ * A default compilation function used to build the mozAccessFuGesture event
+ * detail. The detail always includes the type and the touches associated
+ * with the gesture.
+ * @return {Object} Gesture event detail.
+ */
+ compile: function Gesture_compile() {
+ return compileDetail(this.type, this.points);
+ }
+};
+
+/**
+ * A mixin for an explore related object.
+ */
+function ExploreGesture() {
+ this.compile = () => {
+ // Unlike most of other gestures explore based gestures compile using the
+ // current point position and not the start one.
+ return compileDetail(this.type, this.points, {x: 'x', y: 'y'});
+ };
+}
+
+/**
+ * Check the in progress gesture for completion.
+ */
+function checkProgressGesture(aGesture) {
+ aGesture._inProgress = true;
+ if (aGesture.lastEvent === 'pointerup') {
+ if (aGesture.test) {
+ aGesture.test(true);
+ }
+ aGesture._deferred.resolve();
+ }
+}
+
+/**
+ * A common travel gesture. When the travel gesture is created, all subsequent
+ * pointer events' points are tested for their total distance traveled. If that
+ * distance exceeds the _threshold distance, the gesture will be rejected to a
+ * _travelTo gesture.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ * @param {Function} aTravelTo A contructor for the gesture to reject to when
+ * travelling (default: Explore).
+ * @param {Number} aThreshold Travel threshold (default:
+ * GestureSettings.travelThreshold).
+ */
+function TravelGesture(aTimeStamp, aPoints, aLastEvent, aTravelTo = Explore, aThreshold = GestureSettings.travelThreshold) {
+ Gesture.call(this, aTimeStamp, aPoints, aLastEvent);
+ this._travelTo = aTravelTo;
+ this._threshold = aThreshold;
+}
+
+TravelGesture.prototype = Object.create(Gesture.prototype);
+
+/**
+ * Test the gesture points for travel. The gesture will be rejected to
+ * this._travelTo gesture iff at least one point crosses this._threshold.
+ */
+TravelGesture.prototype.test = function TravelGesture_test() {
+ if (!this._travelTo) {
+ return;
+ }
+ for (let identifier in this.points) {
+ let point = this.points[identifier];
+ if (point.totalDistanceTraveled / Utils.dpi > this._threshold) {
+ this._deferred.reject(this._travelTo);
+ return;
+ }
+ }
+};
+
+/**
+ * DwellEnd gesture.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function DwellEnd(aTimeStamp, aPoints, aLastEvent) {
+ this._inProgress = true;
+ // If the pointer travels, reject to Explore.
+ TravelGesture.call(this, aTimeStamp, aPoints, aLastEvent);
+ checkProgressGesture(this);
+}
+
+DwellEnd.prototype = Object.create(TravelGesture.prototype);
+DwellEnd.prototype.type = 'dwellend';
+
+/**
+ * TapHoldEnd gesture. This gesture can be represented as the following diagram:
+ * pointerdown-pointerup-pointerdown-*wait*-pointerup.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function TapHoldEnd(aTimeStamp, aPoints, aLastEvent) {
+ this._inProgress = true;
+ // If the pointer travels, reject to Explore.
+ TravelGesture.call(this, aTimeStamp, aPoints, aLastEvent);
+ checkProgressGesture(this);
+}
+
+TapHoldEnd.prototype = Object.create(TravelGesture.prototype);
+TapHoldEnd.prototype.type = 'tapholdend';
+
+/**
+ * DoubleTapHoldEnd gesture. This gesture can be represented as the following
+ * diagram:
+ * pointerdown-pointerup-pointerdown-pointerup-pointerdown-*wait*-pointerup.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function DoubleTapHoldEnd(aTimeStamp, aPoints, aLastEvent) {
+ this._inProgress = true;
+ // If the pointer travels, reject to Explore.
+ TravelGesture.call(this, aTimeStamp, aPoints, aLastEvent);
+ checkProgressGesture(this);
+}
+
+DoubleTapHoldEnd.prototype = Object.create(TravelGesture.prototype);
+DoubleTapHoldEnd.prototype.type = 'doubletapholdend';
+
+/**
+ * A common tap gesture object.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ * @param {Function} aRejectToOnWait A constructor for the next gesture to
+ * reject to in case no pointermove or pointerup happens within the
+ * GestureSettings.dwellThreshold.
+ * @param {Function} aTravelTo An optional constuctor for the next gesture to
+ * reject to in case the the TravelGesture test fails.
+ * @param {Function} aRejectToOnPointerDown A constructor for the gesture to
+ * reject to if a finger comes down immediately after the tap.
+ */
+function TapGesture(aTimeStamp, aPoints, aLastEvent, aRejectToOnWait, aTravelTo, aRejectToOnPointerDown) {
+ this._rejectToOnWait = aRejectToOnWait;
+ this._rejectToOnPointerDown = aRejectToOnPointerDown;
+ // If the pointer travels, reject to aTravelTo.
+ TravelGesture.call(this, aTimeStamp, aPoints, aLastEvent, aTravelTo,
+ TAP_MAX_RADIUS);
+}
+
+TapGesture.prototype = Object.create(TravelGesture.prototype);
+TapGesture.prototype._getDelay = function TapGesture__getDelay() {
+ // If, for TapGesture, no pointermove or pointerup happens within the
+ // GestureSettings.dwellThreshold, reject.
+ // Note: the original pointer event's timeStamp is irrelevant here.
+ return GestureSettings.dwellThreshold;
+};
+
+TapGesture.prototype.pointerup = function TapGesture_pointerup(aPoints) {
+ if (this._rejectToOnPointerDown) {
+ let complete = this._update(aPoints, 'pointerup', false, true);
+ if (complete) {
+ this.clearTimer();
+ if (GestureSettings.maxGestureResolveTimeout) {
+ this._pointerUpTimer = setTimeout(() => {
+ clearTimeout(this._pointerUpTimer);
+ delete this._pointerUpTimer;
+ this._deferred.resolve();
+ }, GestureSettings.maxGestureResolveTimeout);
+ } else {
+ this._deferred.resolve();
+ }
+ }
+ } else {
+ TravelGesture.prototype.pointerup.call(this, aPoints);
+ }
+};
+
+TapGesture.prototype.pointerdown = function TapGesture_pointerdown(aPoints, aTimeStamp) {
+ if (this._pointerUpTimer) {
+ clearTimeout(this._pointerUpTimer);
+ delete this._pointerUpTimer;
+ this._deferred.reject(this._rejectToOnPointerDown);
+ } else {
+ TravelGesture.prototype.pointerdown.call(this, aPoints, aTimeStamp);
+ }
+};
+
+
+/**
+ * Tap gesture.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function Tap(aTimeStamp, aPoints, aLastEvent) {
+ // If the pointer travels, reject to Swipe.
+ TapGesture.call(this, aTimeStamp, aPoints, aLastEvent, Dwell, Swipe, DoubleTap);
+}
+
+Tap.prototype = Object.create(TapGesture.prototype);
+Tap.prototype.type = 'tap';
+
+
+/**
+ * Double Tap gesture.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function DoubleTap(aTimeStamp, aPoints, aLastEvent) {
+ this._inProgress = true;
+ TapGesture.call(this, aTimeStamp, aPoints, aLastEvent, TapHold, null, TripleTap);
+}
+
+DoubleTap.prototype = Object.create(TapGesture.prototype);
+DoubleTap.prototype.type = 'doubletap';
+
+/**
+ * Triple Tap gesture.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function TripleTap(aTimeStamp, aPoints, aLastEvent) {
+ this._inProgress = true;
+ TapGesture.call(this, aTimeStamp, aPoints, aLastEvent, DoubleTapHold, null, null);
+}
+
+TripleTap.prototype = Object.create(TapGesture.prototype);
+TripleTap.prototype.type = 'tripletap';
+
+/**
+ * Common base object for gestures that are created as resolved.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function ResolvedGesture(aTimeStamp, aPoints, aLastEvent) {
+ Gesture.call(this, aTimeStamp, aPoints, aLastEvent);
+ // Resolve the guesture right away.
+ this._deferred.resolve();
+}
+
+ResolvedGesture.prototype = Object.create(Gesture.prototype);
+
+/**
+ * Dwell gesture
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function Dwell(aTimeStamp, aPoints, aLastEvent) {
+ ResolvedGesture.call(this, aTimeStamp, aPoints, aLastEvent);
+}
+
+Dwell.prototype = Object.create(ResolvedGesture.prototype);
+Dwell.prototype.type = 'dwell';
+Dwell.prototype.resolveTo = DwellEnd;
+
+/**
+ * TapHold gesture
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function TapHold(aTimeStamp, aPoints, aLastEvent) {
+ ResolvedGesture.call(this, aTimeStamp, aPoints, aLastEvent);
+}
+
+TapHold.prototype = Object.create(ResolvedGesture.prototype);
+TapHold.prototype.type = 'taphold';
+TapHold.prototype.resolveTo = TapHoldEnd;
+
+/**
+ * DoubleTapHold gesture
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function DoubleTapHold(aTimeStamp, aPoints, aLastEvent) {
+ ResolvedGesture.call(this, aTimeStamp, aPoints, aLastEvent);
+}
+
+DoubleTapHold.prototype = Object.create(ResolvedGesture.prototype);
+DoubleTapHold.prototype.type = 'doubletaphold';
+DoubleTapHold.prototype.resolveTo = DoubleTapHoldEnd;
+
+/**
+ * Explore gesture
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function Explore(aTimeStamp, aPoints, aLastEvent) {
+ ExploreGesture.call(this);
+ ResolvedGesture.call(this, aTimeStamp, aPoints, aLastEvent);
+}
+
+Explore.prototype = Object.create(ResolvedGesture.prototype);
+Explore.prototype.type = 'explore';
+Explore.prototype.resolveTo = ExploreEnd;
+
+/**
+ * ExploreEnd gesture.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function ExploreEnd(aTimeStamp, aPoints, aLastEvent) {
+ this._inProgress = true;
+ ExploreGesture.call(this);
+ // If the pointer travels, reject to Explore.
+ TravelGesture.call(this, aTimeStamp, aPoints, aLastEvent);
+ checkProgressGesture(this);
+}
+
+ExploreEnd.prototype = Object.create(TravelGesture.prototype);
+ExploreEnd.prototype.type = 'exploreend';
+
+/**
+ * Swipe gesture.
+ * @param {Number} aTimeStamp An original pointer event's timeStamp that started
+ * the gesture resolution sequence.
+ * @param {Object} aPoints An existing set of points (from previous events).
+ * @param {?String} aLastEvent Last pointer event type.
+ */
+function Swipe(aTimeStamp, aPoints, aLastEvent) {
+ this._inProgress = true;
+ this._rejectToOnWait = Explore;
+ Gesture.call(this, aTimeStamp, aPoints, aLastEvent);
+ checkProgressGesture(this);
+}
+
+Swipe.prototype = Object.create(Gesture.prototype);
+Swipe.prototype.type = 'swipe';
+Swipe.prototype._getDelay = function Swipe__getDelay(aTimeStamp) {
+ // Swipe should be completed within the GestureSettings.swipeMaxDuration from
+ // the initial pointer down event.
+ return GestureSettings.swipeMaxDuration - this.startTime + aTimeStamp;
+};
+
+/**
+ * Determine wither the gesture was Swipe or Explore.
+ * @param {Booler} aComplete A flag that indicates whether the gesture is and
+ * will be complete after the test.
+ */
+Swipe.prototype.test = function Swipe_test(aComplete) {
+ if (!aComplete) {
+ // No need to test if the gesture is not completing or can't be complete.
+ return;
+ }
+ let reject = true;
+ // If at least one point travelled for more than SWIPE_MIN_DISTANCE and it was
+ // direct enough, consider it a Swipe.
+ for (let identifier in this.points) {
+ let point = this.points[identifier];
+ let directDistance = point.directDistanceTraveled;
+ if (directDistance / Utils.dpi >= SWIPE_MIN_DISTANCE ||
+ directDistance * DIRECTNESS_COEFF >= point.totalDistanceTraveled) {
+ reject = false;
+ }
+ }
+ if (reject) {
+ this._deferred.reject(Explore);
+ }
+};
+
+/**
+ * Compile a swipe related mozAccessFuGesture event detail.
+ * @return {Object} A mozAccessFuGesture detail object.
+ */
+Swipe.prototype.compile = function Swipe_compile() {
+ let type = this.type;
+ let detail = compileDetail(type, this.points,
+ {x1: 'startX', y1: 'startY', x2: 'x', y2: 'y'});
+ let deltaX = detail.deltaX;
+ let deltaY = detail.deltaY;
+ let edge = EDGE * Utils.dpi;
+ if (Math.abs(deltaX) > Math.abs(deltaY)) {
+ // Horizontal swipe.
+ let startPoints = detail.touches.map(touch => touch.x1);
+ if (deltaX > 0) {
+ detail.type = type + 'right';
+ detail.edge = Math.min.apply(null, startPoints) <= edge;
+ } else {
+ detail.type = type + 'left';
+ detail.edge =
+ Utils.win.screen.width - Math.max.apply(null, startPoints) <= edge;
+ }
+ } else {
+ // Vertical swipe.
+ let startPoints = detail.touches.map(touch => touch.y1);
+ if (deltaY > 0) {
+ detail.type = type + 'down';
+ detail.edge = Math.min.apply(null, startPoints) <= edge;
+ } else {
+ detail.type = type + 'up';
+ detail.edge =
+ Utils.win.screen.height - Math.max.apply(null, startPoints) <= edge;
+ }
+ }
+ return detail;
+};