@vpmedia/phaser 1.0.1 → 1.0.3

package/src/phaser/core/input_mouse.js

@@ -0,0 +1,289 @@
+/**
+ * @author       Andras Csizmadia <andras@vpmedia.hu>
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    Copyright (c) 2018-present Richard Davey, Photon Storm Ltd., Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)
+ */
+import Signal from './signal';
+
+const NO_BUTTON = -1;
+const LEFT_BUTTON = 0;
+const MIDDLE_BUTTON = 1;
+const RIGHT_BUTTON = 2;
+const BACK_BUTTON = 3;
+const FORWARD_BUTTON = 4;
+const WHEEL_UP = 1;
+const WHEEL_DOWN = -1;
+
+class WheelEventProxy {
+
+  constructor(scaleFactor, deltaMode) {
+    this._scaleFactor = scaleFactor;
+    this._deltaMode = deltaMode;
+    this.originalEvent = null;
+    this.type = 'wheel';
+    this.deltaZ = { value: 0 };
+  }
+
+  bindEvent(event) {
+    // TODO
+    console.warn('input_mouse.bindEvent() is not implemented');
+    /*
+    if (!window.PhaserRegistry.isMouseWheelEventBinded && event) {
+      const makeBinder = (name) => {
+        return () => {
+          const v = this.originalEvent[name];
+          return typeof v !== 'function' ? v : v.bind(this.originalEvent);
+        };
+      };
+      window.PhaserRegistry.isMouseWheelEventBinded = true;
+    }
+    */
+    this.originalEvent = event;
+    return this;
+  }
+
+  get deltaMode() {
+    return this._deltaMode;
+  }
+
+  get deltaY() {
+    return (this._scaleFactor * (this.originalEvent.wheelDelta || this.originalEvent.detail)) || 0;
+  }
+
+  get deltaX() {
+    return (this._scaleFactor * this.originalEvent.wheelDeltaX) || 0;
+  }
+
+}
+
+export default class {
+
+  constructor(game) {
+    this.game = game;
+    this.input = game.input;
+    this.callbackContext = this.game;
+    this.mouseDownCallback = null;
+    this.mouseUpCallback = null;
+    this.mouseOutCallback = null;
+    this.mouseOverCallback = null;
+    this.mouseWheelCallback = null;
+    this.capture = false;
+    this.button = -1;
+    this.wheelDelta = 0;
+    this.enabled = true;
+    this.locked = false;
+    this.stopOnGameOut = false;
+    this.pointerLock = new Signal();
+    this.event = null;
+    this._onMouseDown = null;
+    this._onMouseMove = null;
+    this._onMouseUp = null;
+    this._onMouseOut = null;
+    this._onMouseOver = null;
+    this._onMouseWheel = null;
+    this._wheelEvent = null;
+  }
+
+  start() {
+    if (this.game.device.android && this.game.device.chrome === false) {
+      //  Android stock browser fires mouse events even if you preventDefault on the touchStart, so ...
+      return;
+    }
+    if (this._onMouseDown !== null) {
+      //  Avoid setting multiple listeners
+      return;
+    }
+    const scope = this;
+    this._onMouseDown = event => scope.onMouseDown(event);
+    this._onMouseMove = event => scope.onMouseMove(event);
+    this._onMouseUp = event => scope.onMouseUp(event);
+    this._onMouseUpGlobal = event => scope.onMouseUpGlobal(event);
+    this._onMouseOutGlobal = event => scope.onMouseOutGlobal(event);
+    this._onMouseOut = event => scope.onMouseOut(event);
+    this._onMouseOver = event => scope.onMouseOver(event);
+    this._onMouseWheel = event => scope.onMouseWheel(event);
+    const canvas = this.game.canvas;
+    canvas.addEventListener('mousedown', this._onMouseDown, true);
+    canvas.addEventListener('mousemove', this._onMouseMove, true);
+    canvas.addEventListener('mouseup', this._onMouseUp, true);
+    if (!this.game.device.cocoonJS) {
+      window.addEventListener('mouseup', this._onMouseUpGlobal, true);
+      window.addEventListener('mouseout', this._onMouseOutGlobal, true);
+      canvas.addEventListener('mouseover', this._onMouseOver, true);
+      canvas.addEventListener('mouseout', this._onMouseOut, true);
+    }
+    const wheelEvent = this.game.device.wheelEvent;
+    if (wheelEvent) {
+      canvas.addEventListener(wheelEvent, this._onMouseWheel, true);
+      if (wheelEvent === 'mousewheel') {
+        this._wheelEvent = new WheelEventProxy(-1 / 40, 1);
+      } else if (wheelEvent === 'DOMMouseScroll') {
+        this._wheelEvent = new WheelEventProxy(1, 1);
+      }
+    }
+  }
+
+  stop() {
+    const canvas = this.game.canvas;
+    canvas.removeEventListener('mousedown', this._onMouseDown, true);
+    canvas.removeEventListener('mousemove', this._onMouseMove, true);
+    canvas.removeEventListener('mouseup', this._onMouseUp, true);
+    canvas.removeEventListener('mouseover', this._onMouseOver, true);
+    canvas.removeEventListener('mouseout', this._onMouseOut, true);
+    const wheelEvent = this.game.device.wheelEvent;
+    if (wheelEvent) {
+      canvas.removeEventListener(wheelEvent, this._onMouseWheel, true);
+    }
+    window.removeEventListener('mouseup', this._onMouseUpGlobal, true);
+    window.removeEventListener('mouseout', this._onMouseOutGlobal, true);
+    document.removeEventListener('pointerlockchange', this._pointerLockChange, true);
+    document.removeEventListener('mozpointerlockchange', this._pointerLockChange, true);
+    document.removeEventListener('webkitpointerlockchange', this._pointerLockChange, true);
+  }
+
+  onMouseDown(event) {
+    this.event = event;
+    this.eventPreventDefault(event);
+    if (this.mouseDownCallback) {
+      this.mouseDownCallback.call(this.callbackContext, event);
+    }
+    if (!this.input.enabled || !this.enabled) {
+      return;
+    }
+    event.identifier = 0;
+    this.input.mousePointer.start(event);
+  }
+
+  onMouseMove(event) {
+    this.event = event;
+    this.eventPreventDefault(event);
+    if (this.mouseMoveCallback) {
+      this.mouseMoveCallback.call(this.callbackContext, event);
+    }
+    if (!this.input.enabled || !this.enabled) {
+      return;
+    }
+    event.identifier = 0;
+    this.input.mousePointer.move(event);
+  }
+
+  onMouseUp(event) {
+    this.event = event;
+    this.eventPreventDefault(event);
+    if (this.mouseUpCallback) {
+      this.mouseUpCallback.call(this.callbackContext, event);
+    }
+    if (!this.input.enabled || !this.enabled) {
+      return;
+    }
+    event.identifier = 0;
+    this.input.mousePointer.stop(event);
+  }
+
+  onMouseUpGlobal(event) {
+    if (!this.input.mousePointer.withinGame) {
+      if (this.mouseUpCallback) {
+        this.mouseUpCallback.call(this.callbackContext, event);
+      }
+      event.identifier = 0;
+      this.input.mousePointer.stop(event);
+    }
+  }
+
+  onMouseOutGlobal(event) {
+    this.event = event;
+    this.eventPreventDefault(event);
+    this.input.mousePointer.withinGame = false;
+    if (!this.input.enabled || !this.enabled) {
+      return;
+    }
+    //  If we get a mouseout event from the window then basically
+    //  something serious has gone down, usually along the lines of
+    //  the browser opening a context-menu or similar.
+    //  On OS X Chrome especially this is bad news, as it blocks
+    //  us then getting a mouseup event, so we need to force that through.
+    this.input.mousePointer.stop(event);
+  }
+
+  onMouseOut(event) {
+    this.event = event;
+    this.eventPreventDefault(event);
+    this.input.mousePointer.withinGame = false;
+    if (this.mouseOutCallback) {
+      this.mouseOutCallback.call(this.callbackContext, event);
+    }
+    if (!this.input.enabled || !this.enabled) {
+      return;
+    }
+    if (this.stopOnGameOut) {
+      event.identifier = 0;
+      this.input.mousePointer.stop(event);
+    }
+  }
+
+  onMouseOver(event) {
+    this.event = event;
+    this.eventPreventDefault(event);
+    this.input.mousePointer.withinGame = true;
+    if (this.mouseOverCallback) {
+      this.mouseOverCallback.call(this.callbackContext, event);
+    }
+  }
+
+  onMouseWheel(event) {
+    if (this._wheelEvent) {
+      event = this._wheelEvent.bindEvent(event);
+    }
+    this.event = event;
+    this.eventPreventDefault(event);
+    // reverse detail for firefox
+    this.wheelDelta = Math.max(-1, Math.min(1, -event.deltaY));
+    if (this.mouseWheelCallback) {
+      this.mouseWheelCallback.call(this.callbackContext, event);
+    }
+  }
+
+  requestPointerLock() {
+    if (this.game.device.pointerLock) {
+      const element = this.game.canvas;
+      element.requestPointerLock = element.requestPointerLock || element.mozRequestPointerLock || element.webkitRequestPointerLock;
+      element.requestPointerLock();
+      const scope = this;
+      this._pointerLockChange = event => scope.pointerLockChange(event);
+      document.addEventListener('pointerlockchange', this._pointerLockChange, true);
+      document.addEventListener('mozpointerlockchange', this._pointerLockChange, true);
+      document.addEventListener('webkitpointerlockchange', this._pointerLockChange, true);
+    }
+
+  }
+
+  pointerLockChange(event) {
+    const element = this.game.canvas;
+    if (document.pointerLockElement === element || document.mozPointerLockElement === element || document.webkitPointerLockElement === element) {
+      //  Pointer was successfully locked
+      this.locked = true;
+      this.pointerLock.dispatch(true, event);
+    } else {
+      //  Pointer was unlocked
+      this.locked = false;
+      this.pointerLock.dispatch(false, event);
+    }
+  }
+
+  releasePointerLock() {
+    document.exitPointerLock = document.exitPointerLock || document.mozExitPointerLock || document.webkitExitPointerLock;
+    document.exitPointerLock();
+    document.removeEventListener('pointerlockchange', this._pointerLockChange, true);
+    document.removeEventListener('mozpointerlockchange', this._pointerLockChange, true);
+    document.removeEventListener('webkitpointerlockchange', this._pointerLockChange, true);
+  }
+
+  eventPreventDefault(event) {
+    if (this.capture) {
+      if (typeof event.cancelable !== 'boolean' || event.cancelable) {
+        event.preventDefault();
+      }
+    }
+  }
+
+}

package/src/phaser/core/input_mspointer.js

@@ -0,0 +1,197 @@
+/**
+ * @author       Andras Csizmadia <andras@vpmedia.hu>
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    Copyright (c) 2018-present Richard Davey, Photon Storm Ltd., Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)
+ */
+
+export default class {
+
+  constructor(game) {
+    this.game = game;
+    this.input = game.input;
+    this.callbackContext = this.game;
+    this.pointerDownCallback = null;
+    this.pointerMoveCallback = null;
+    this.pointerUpCallback = null;
+    this.capture = true;
+    this.button = -1;
+    this.event = null;
+    this.enabled = true;
+    this._onMSPointerDown = null;
+    this._onMSPointerMove = null;
+    this._onMSPointerUp = null;
+    this._onMSPointerUpGlobal = null;
+    this._onMSPointerOut = null;
+    this._onMSPointerOver = null;
+  }
+
+  start() {
+    if (!this.game.device.mspointer || this._onMSPointerDown !== null) {
+      return;
+    }
+    const scope = this;
+    this._onMSPointerDown = event => scope.onPointerDown(event);
+    this._onMSPointerMove = event => scope.onPointerMove(event);
+    this._onMSPointerUp = event => scope.onPointerUp(event);
+    this._onMSPointerUpGlobal = event => scope.onPointerUpGlobal(event);
+    this._onMSPointerOut = event => scope.onPointerOut(event);
+    this._onMSPointerOver = event => scope.onPointerOver(event);
+    const canvas = this.game.canvas;
+    canvas.addEventListener('MSPointerDown', this._onMSPointerDown, false);
+    canvas.addEventListener('MSPointerMove', this._onMSPointerMove, false);
+    canvas.addEventListener('MSPointerUp', this._onMSPointerUp, false);
+    //  IE11+ uses non-prefix events
+    canvas.addEventListener('pointerdown', this._onMSPointerDown, false);
+    canvas.addEventListener('pointermove', this._onMSPointerMove, false);
+    canvas.addEventListener('pointerup', this._onMSPointerUp, false);
+    canvas.style['-ms-content-zooming'] = 'none';
+    canvas.style['-ms-touch-action'] = 'none';
+    if (!this.game.device.cocoonJS) {
+      window.addEventListener('MSPointerUp', this._onMSPointerUpGlobal, true);
+      canvas.addEventListener('MSPointerOver', this._onMSPointerOver, true);
+      canvas.addEventListener('MSPointerOut', this._onMSPointerOut, true);
+      //  IE11+ uses non-prefix events
+      window.addEventListener('pointerup', this._onMSPointerUpGlobal, true);
+      canvas.addEventListener('pointerover', this._onMSPointerOver, true);
+      canvas.addEventListener('pointerout', this._onMSPointerOut, true);
+    }
+  }
+
+  stop() {
+    if (!this.game.device.mspointer) {
+      return;
+    }
+    const canvas = this.game.canvas;
+    canvas.removeEventListener('MSPointerDown', this._onMSPointerDown, false);
+    canvas.removeEventListener('MSPointerMove', this._onMSPointerMove, false);
+    canvas.removeEventListener('MSPointerUp', this._onMSPointerUp, false);
+    //  IE11+ uses non-prefix events
+    canvas.removeEventListener('pointerdown', this._onMSPointerDown, false);
+    canvas.removeEventListener('pointermove', this._onMSPointerMove, false);
+    canvas.removeEventListener('pointerup', this._onMSPointerUp, false);
+    window.removeEventListener('MSPointerUp', this._onMSPointerUpGlobal, true);
+    canvas.removeEventListener('MSPointerOver', this._onMSPointerOver, true);
+    canvas.removeEventListener('MSPointerOut', this._onMSPointerOut, true);
+    //  IE11+ uses non-prefix events
+    window.removeEventListener('pointerup', this._onMSPointerUpGlobal, true);
+    canvas.removeEventListener('pointerover', this._onMSPointerOver, true);
+    canvas.removeEventListener('pointerout', this._onMSPointerOut, true);
+  }
+
+  onPointerDown(event) {
+    this.game.input.executeTouchLockCallbacks(false, event);
+    this.event = event;
+    this.eventPreventDefault(event);
+    if (this.pointerDownCallback) {
+      this.pointerDownCallback.call(this.callbackContext, event);
+    }
+    if (!this.input.enabled || !this.enabled) {
+      return;
+    }
+    event.identifier = event.pointerId;
+    if (event.pointerType === 'mouse' || event.pointerType === 0x00000004) {
+      this.input.mousePointer.start(event);
+    } else {
+      this.input.startPointer(event);
+    }
+  }
+
+  onPointerMove(event) {
+    this.event = event;
+    this.eventPreventDefault(event);
+    if (this.pointerMoveCallback) {
+      this.pointerMoveCallback.call(this.callbackContext, event);
+    }
+    if (!this.input.enabled || !this.enabled) {
+      return;
+    }
+    event.identifier = event.pointerId;
+    if (event.pointerType === 'mouse' || event.pointerType === 0x00000004) {
+      this.input.mousePointer.move(event);
+    } else {
+      this.input.updatePointer(event);
+    }
+  }
+
+  onPointerUp(event) {
+    this.game.input.executeTouchLockCallbacks(true, event);
+    this.event = event;
+    this.eventPreventDefault(event);
+    if (this.pointerUpCallback) {
+      this.pointerUpCallback.call(this.callbackContext, event);
+    }
+    if (!this.input.enabled || !this.enabled) {
+      return;
+    }
+    event.identifier = event.pointerId;
+    if (event.pointerType === 'mouse' || event.pointerType === 0x00000004) {
+      this.input.mousePointer.stop(event);
+    } else {
+      this.input.stopPointer(event);
+    }
+  }
+
+  onPointerUpGlobal(event) {
+    if ((event.pointerType === 'mouse' || event.pointerType === 0x00000004) && !this.input.mousePointer.withinGame) {
+      this.onPointerUp(event);
+    } else {
+      const pointer = this.input.getPointerFromIdentifier(event.identifier);
+      if (pointer && pointer.withinGame) {
+        this.onPointerUp(event);
+      }
+    }
+  }
+
+  onPointerOut(event) {
+    this.event = event;
+    this.eventPreventDefault(event);
+    let pointer;
+    if (event.pointerType === 'mouse' || event.pointerType === 0x00000004) {
+      this.input.mousePointer.withinGame = false;
+    } else {
+      pointer = this.input.getPointerFromIdentifier(event.identifier);
+      if (pointer) {
+        pointer.withinGame = false;
+      }
+    }
+    if (this.input.mouse.mouseOutCallback) {
+      this.input.mouse.mouseOutCallback.call(this.input.mouse.callbackContext, event);
+    }
+    if (!this.input.enabled || !this.enabled) {
+      return;
+    }
+    if (this.input.mouse.stopOnGameOut) {
+      event.identifier = 0;
+      if (pointer) {
+        pointer.stop(event);
+      } else {
+        this.input.mousePointer.stop(event);
+      }
+    }
+  }
+
+  onPointerOver(event) {
+    this.event = event;
+    this.eventPreventDefault(event);
+    if (event.pointerType === 'mouse' || event.pointerType === 0x00000004) {
+      this.input.mousePointer.withinGame = true;
+    } else {
+      const pointer = this.input.getPointerFromIdentifier(event.identifier);
+      if (pointer) {
+        pointer.withinGame = true;
+      }
+    }
+    if (this.input.mouse.mouseOverCallback) {
+      this.input.mouse.mouseOverCallback.call(this.input.mouse.callbackContext, event);
+    }
+  }
+
+  eventPreventDefault(event) {
+    if (this.capture) {
+      if (typeof event.cancelable !== 'boolean' || event.cancelable) {
+        event.preventDefault();
+      }
+    }
+  }
+
+}