The Tor Browser: comparison accessible/src/jsat/Gestures.jsm

--1:000000000000
+:37eaf8f61155
+/* 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        (v)
+-> Dwell            (x)
+-> Swipe            (x)
+AndroidTap -> TripleTap        (v)
+-> TapHold          (x)
+-> Swipe            (x)
+DoubleTap -> TripleTap        (v)
+-> TapHold          (x)
+-> Explore          (x)
+TripleTap -> DoubleTapHold    (x)
+-> Explore          (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 Ci = Components.interfaces;
+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');
+// Maximum amount of time allowed for a gesture to be considered a multitouch.
+const MAX_MULTITOUCH = 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;
+// An android flag.
+const IS_ANDROID = Utils.MozBuildApp === 'mobile/android' &&
+Utils.AndroidSdkVersion >= 14;
+// A single pointer down/up sequence periodically precedes the tripple swipe
+// gesture on Android. This delay acounts for that.
+const ANDROID_TRIPLE_SWIPE_DELAY = 50;
+// The virtual touch ID generated by a mouse event.
+const MOUSE_ID = 'mouse';
+/**
+* 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: 400,
+/**
+* Maximum consecutive pointer event timeout.
+* @type {Number}
+*/
+maxConsecutiveGestureDelay: 400,
+/**
+* Delay before tap turns into dwell
+* @type {Number}
+*/
+dwellThreshold: 500,
+/**
+* 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 = Tap) {
+// Only create a new gesture on |pointerdown| event.
+if (aDetail.type !== 'pointerdown') {
+return;
+}
+let points = aDetail.points;
+let GestureConstructor = aGesture;
+if (IS_ANDROID && GestureConstructor === Tap && points.length === 1 &&
+points[0].identifier !== MOUSE_ID) {
+// Handle Android events when EBT is enabled. Two finger gestures are
+// translated to one.
+GestureConstructor = AndroidTap;
+}
+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.debug(() => {
+return ['Pointer event', aDetail.type, 'at:', aTimeStamp,
+JSON.stringify(aDetail.points)];
+});
+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 {
+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.debug('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() {
+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) {
+this.clearTimer();
+let delay = this._getDelay(aTimeStamp);
+let handler = () => {
+delete this._timer;
+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) {
+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 < MAX_MULTITOUCH);
+},
+/**
+* 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.debug('Resolving', this.id, 'gesture.');
+this.isComplete = true;
+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.debug('Rejecting', this.id, 'gesture.');
+this.isComplete = true;
+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() {
+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} aRejectTo 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.
+*/
+function TapGesture(aTimeStamp, aPoints, aLastEvent, aRejectTo, aTravelTo) {
+this._rejectToOnWait = aRejectTo;
+// 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;
+};
+/**
+* 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);
+}
+Tap.prototype = Object.create(TapGesture.prototype);
+Tap.prototype.type = 'tap';
+Tap.prototype.resolveTo = DoubleTap;
+/**
+* Tap (multi) gesture on Android.
+* @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 AndroidTap(aTimeStamp, aPoints, aLastEvent) {
+// If the pointer travels, reject to Swipe. On dwell threshold reject to
+// TapHold.
+TapGesture.call(this, aTimeStamp, aPoints, aLastEvent, TapHold, Swipe);
+}
+AndroidTap.prototype = Object.create(TapGesture.prototype);
+// Android double taps are translated to single taps.
+AndroidTap.prototype.type = 'doubletap';
+AndroidTap.prototype.resolveTo = TripleTap;
+/**
+* Clear the pointerup handler timer in case of the 3 pointer swipe.
+*/
+AndroidTap.prototype.clearThreeFingerSwipeTimer = function AndroidTap_clearThreeFingerSwipeTimer() {
+clearTimeout(this._threeFingerSwipeTimer);
+delete this._threeFingerSwipeTimer;
+};
+AndroidTap.prototype.pointerdown = function AndroidTap_pointerdown(aPoints, aTimeStamp) {
+this.clearThreeFingerSwipeTimer();
+TapGesture.prototype.pointerdown.call(this, aPoints, aTimeStamp);
+};
+AndroidTap.prototype.pointermove = function AndroidTap_pointermove(aPoints) {
+this.clearThreeFingerSwipeTimer();
+this._moved = true;
+TapGesture.prototype.pointermove.call(this, aPoints);
+};
+AndroidTap.prototype.pointerup = function AndroidTap_pointerup(aPoints) {
+if (this._moved) {
+// If there was a pointer move - handle the real gesture.
+TapGesture.prototype.pointerup.call(this, aPoints);
+} else {
+// Primptively delay the multi pointer gesture resolution, because Android
+// sometimes fires a pointerdown/poitnerup sequence before the real events.
+this._threeFingerSwipeTimer = setTimeout(() => {
+delete this._threeFingerSwipeTimer;
+TapGesture.prototype.pointerup.call(this, aPoints);
+}, ANDROID_TRIPLE_SWIPE_DELAY);
+}
+};
+/**
+* Reject an android tap gesture.
+* @param  {?Function} aRejectTo An optional next gesture constructor.
+* @return {Object} structure that looks like {
+*   id: gesture_id, // Current AndroidTap gesture id.
+*   gestureType: next_gesture // Optional
+* }
+*/
+AndroidTap.prototype._handleReject = function AndroidTap__handleReject(aRejectTo) {
+let keys = Object.keys(this.points);
+if (aRejectTo === Swipe && keys.length === 1) {
+let key = keys[0];
+let point = this.points[key];
+// Two finger swipe is translated into single swipe.
+this.points[key + '-copy'] = point;
+}
+return TapGesture.prototype._handleReject.call(this, aRejectTo);
+};
+/**
+* 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) {
+TapGesture.call(this, aTimeStamp, aPoints, aLastEvent, TapHold);
+}
+DoubleTap.prototype = Object.create(TapGesture.prototype);
+DoubleTap.prototype.type = 'doubletap';
+DoubleTap.prototype.resolveTo = TripleTap;
+/**
+* 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) {
+TapGesture.call(this, aTimeStamp, aPoints, aLastEvent, DoubleTapHold);
+}
+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;
+if (Math.abs(deltaX) > Math.abs(deltaY)) {
+// Horizontal swipe.
+detail.type = type + (deltaX > 0 ? 'right' : 'left');
+} else {
+// Vertival swipe.
+detail.type = type + (deltaY > 0 ? 'down' : 'up');
+}
+return detail;
+};

The Tor Browser / file comparison

comparison: accessible/src/jsat/Gestures.jsm

accessible/src/jsat/Gestures.jsm