The Tor Browser: toolkit/devtools/touch-events.js@6474c204b198 (annotated)

toolkit/devtools/touch-events.js@6474c204b198 (annotated)

toolkit/devtools/touch-events.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* vim: set ft=javascript ts=2 et sw=2 tw=80: */
 /* 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/. */
 let {CC, Cc, Ci, Cu, Cr} = require('chrome');
 Cu.import('resource://gre/modules/Services.jsm');
 let handlerCount = 0;
 let orig_w3c_touch_events = Services.prefs.getIntPref('dom.w3c_touch_events.enabled');
 let trackedWindows = new WeakMap();
 // =================== Touch ====================
 // Simulate touch events on desktop
 function TouchEventHandler (window) {
   // Returns an already instanciated handler for this window
   let cached = trackedWindows.get(window);
   if (cached) {
     return cached;
   }
   let contextMenuTimeout = 0;
   let threshold = 25;
   try {
     threshold = Services.prefs.getIntPref('ui.dragThresholdX');
   } catch(e) {}
   let delay = 500;
   try {
     delay = Services.prefs.getIntPref('ui.click_hold_context_menus.delay');
   } catch(e) {}
   let TouchEventHandler = {
     enabled: false,
     events: ['mousedown', 'mousemove', 'mouseup'],
     start: function teh_start() {
       if (this.enabled)
         return false;
       this.enabled = true;
       let isReloadNeeded = Services.prefs.getIntPref('dom.w3c_touch_events.enabled') != 1;
       Services.prefs.setIntPref('dom.w3c_touch_events.enabled', 1);
       this.events.forEach((function(evt) {
         // Only listen trusted events to prevent messing with
         // event dispatched manually within content documents
         window.addEventListener(evt, this, true, false);
       }).bind(this));
       return isReloadNeeded;
     },
     stop: function teh_stop() {
       if (!this.enabled)
         return;
       this.enabled = false;
       Services.prefs.setIntPref('dom.w3c_touch_events.enabled', orig_w3c_touch_events);
       this.events.forEach((function(evt) {
         window.removeEventListener(evt, this, true);
       }).bind(this));
     },
     handleEvent: function teh_handleEvent(evt) {
       // Ignore all but real mouse event coming from physical mouse
       // (especially ignore mouse event being dispatched from a touch event)
       if (evt.button || evt.mozInputSource != Ci.nsIDOMMouseEvent.MOZ_SOURCE_MOUSE || evt.isSynthesized) {
         return;
       }
       // The gaia system window use an hybrid system even on the device which is
       // a mix of mouse/touch events. So let's not cancel *all* mouse events
       // if it is the current target.
       let content = this.getContent(evt.target);
       let isSystemWindow = content.location.toString().indexOf("system.gaiamobile.org") != -1;
       let eventTarget = this.target;
       let type = '';
       switch (evt.type) {
         case 'mousedown':
           this.target = evt.target;
           contextMenuTimeout =
             this.sendContextMenu(evt.target, evt.pageX, evt.pageY, delay);
           this.cancelClick = false;
           this.startX = evt.pageX;
           this.startY = evt.pageY;
           // Capture events so if a different window show up the events
           // won't be dispatched to something else.
           evt.target.setCapture(false);
           type = 'touchstart';
           break;
         case 'mousemove':
           if (!eventTarget)
             return;
           if (!this.cancelClick) {
             if (Math.abs(this.startX - evt.pageX) > threshold ||
                 Math.abs(this.startY - evt.pageY) > threshold) {
               this.cancelClick = true;
               content.clearTimeout(contextMenuTimeout);
             }
           }
           type = 'touchmove';
           break;
         case 'mouseup':
           if (!eventTarget)
             return;
           this.target = null;
           content.clearTimeout(contextMenuTimeout);
           type = 'touchend';
           // Only register click listener after mouseup to ensure
           // catching only real user click. (Especially ignore click
           // being dispatched on form submit)
           if (evt.detail == 1) {
             window.addEventListener('click', this, true, false);
           }
           break;
         case 'click':
           // Mouse events has been cancelled so dispatch a sequence
           // of events to where touchend has been fired
           evt.preventDefault();
           evt.stopImmediatePropagation();
           window.removeEventListener('click', this, true, false);
           if (this.cancelClick)
             return;
           ignoreEvents = true;
           content.setTimeout(function dispatchMouseEvents(self) {
             try {
               self.fireMouseEvent('mousedown', evt);
               self.fireMouseEvent('mousemove', evt);
               self.fireMouseEvent('mouseup', evt);
             } catch(e) {
               Cu.reportError('Exception in touch event helper: ' + e);
             }
             ignoreEvents = false;
          }, 0, this);
           return;
       }
       let target = eventTarget || this.target;
       if (target && type) {
         this.sendTouchEvent(evt, target, type);
       }
       if (!isSystemWindow) {
         evt.preventDefault();
         evt.stopImmediatePropagation();
       }
     },
     fireMouseEvent: function teh_fireMouseEvent(type, evt)  {
       let content = this.getContent(evt.target);
       var utils = content.QueryInterface(Ci.nsIInterfaceRequestor)
                          .getInterface(Ci.nsIDOMWindowUtils);
       utils.sendMouseEvent(type, evt.clientX, evt.clientY, 0, 1, 0, true, 0, Ci.nsIDOMMouseEvent.MOZ_SOURCE_TOUCH);
     },
     sendContextMenu: function teh_sendContextMenu(target, x, y, delay) {
       let doc = target.ownerDocument;
       let evt = doc.createEvent('MouseEvent');
       evt.initMouseEvent('contextmenu', true, true, doc.defaultView,
 , x, y, x, y, false, false, false, false,
 , null);
       let content = this.getContent(target);
       let timeout = content.setTimeout((function contextMenu() {
         target.dispatchEvent(evt);
         this.cancelClick = true;
       }).bind(this), delay);
       return timeout;
     },
     sendTouchEvent: function teh_sendTouchEvent(evt, target, name) {
       // When running OOP b2g desktop, we need to send the touch events
       // using the mozbrowser api on the unwrapped frame.
       if (target.localName == "iframe" && target.mozbrowser === true) {
         if (name == "touchstart") {
           this.touchstartTime = Date.now();
         } else if (name == "touchend") {
           // If we have a 'fast' tap, don't send a click as both will be turned
           // into a click and that breaks eg. checkboxes.
           if (Date.now() - this.touchstartTime < delay) {
             this.cancelClick = true;
           }
         }
         let unwraped = XPCNativeWrapper.unwrap(target);
         unwraped.sendTouchEvent(name, [0],                    // event type, id
                                 [evt.clientX], [evt.clientY], // x, y
                                 [1], [1],                     // rx, ry
                                 [0], [0],                     // rotation, force
 );                           // count
         return;
       }
       let document = target.ownerDocument;
       let content = this.getContent(target);
       let touchEvent = document.createEvent('touchevent');
       let point = document.createTouch(content, target, 0,
                                        evt.pageX, evt.pageY,
                                        evt.screenX, evt.screenY,
                                        evt.clientX, evt.clientY,
 , 1, 0, 0);
       let touches = document.createTouchList(point);
       let targetTouches = touches;
       let changedTouches = touches;
       touchEvent.initTouchEvent(name, true, true, content, 0,
                                 false, false, false, false,
                                 touches, targetTouches, changedTouches);
       target.dispatchEvent(touchEvent);
       return touchEvent;
     },
     getContent: function teh_getContent(target) {
       let win = target.ownerDocument.defaultView;
       return win;
     }
   };
   trackedWindows.set(window, TouchEventHandler);
   return TouchEventHandler;
 }
 exports.TouchEventHandler = TouchEventHandler;