polymer-paper-elements-rails 0.0.1

data/app/assets/components/polymer-gestures/src/pinch.js

@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+ */
+
+/*
+ * Basic strategy: find the farthest apart points, use as diameter of circle
+ * react to size change and rotation of the chord
+ */
+
+/**
+ * @module pointer-gestures
+ * @submodule Events
+ * @class pinch
+ */
+/**
+ * Scale of the pinch zoom gesture
+ * @property scale
+ * @type Number
+ */
+/**
+ * Center X position of pointers causing pinch
+ * @property centerX
+ * @type Number
+ */
+/**
+ * Center Y position of pointers causing pinch
+ * @property centerY
+ * @type Number
+ */
+
+/**
+ * @module pointer-gestures
+ * @submodule Events
+ * @class rotate
+ */
+/**
+ * Angle (in degrees) of rotation. Measured from starting positions of pointers.
+ * @property angle
+ * @type Number
+ */
+/**
+ * Center X position of pointers causing rotation
+ * @property centerX
+ * @type Number
+ */
+/**
+ * Center Y position of pointers causing rotation
+ * @property centerY
+ * @type Number
+ */
+(function(scope) {
+  var dispatcher = scope.dispatcher;
+  var eventFactory = scope.eventFactory;
+  var pointermap = new scope.PointerMap();
+  var RAD_TO_DEG = 180 / Math.PI;
+  var pinch = {
+    events: [
+      'down',
+      'up',
+      'move',
+      'cancel'
+    ],
+    exposes: [
+      'pinchstart',
+      'pinch',
+      'pinchend',
+      'rotate'
+    ],
+    defaultActions: {
+      'pinch': 'none',
+      'rotate': 'none'
+    },
+    reference: {},
+    down: function(inEvent) {
+      pointermap.set(inEvent.pointerId, inEvent);
+      if (pointermap.pointers() == 2) {
+        var points = this.calcChord();
+        var angle = this.calcAngle(points);
+        this.reference = {
+          angle: angle,
+          diameter: points.diameter,
+          target: scope.targetFinding.LCA(points.a.target, points.b.target)
+        };
+
+        this.firePinch('pinchstart', points.diameter, points);
+      }
+    },
+    up: function(inEvent) {
+      var p = pointermap.get(inEvent.pointerId);
+      var num = pointermap.pointers();
+      if (p) {
+        if (num === 2) {
+          // fire 'pinchend' before deleting pointer
+          var points = this.calcChord();
+          this.firePinch('pinchend', points.diameter, points);
+        }
+        pointermap.delete(inEvent.pointerId);
+      }
+    },
+    move: function(inEvent) {
+      if (pointermap.has(inEvent.pointerId)) {
+        pointermap.set(inEvent.pointerId, inEvent);
+        if (pointermap.pointers() > 1) {
+          this.calcPinchRotate();
+        }
+      }
+    },
+    cancel: function(inEvent) {
+        this.up(inEvent);
+    },
+    firePinch: function(type, diameter, points) {
+      var zoom = diameter / this.reference.diameter;
+      var e = eventFactory.makeGestureEvent(type, {
+        bubbles: true,
+        cancelable: true,
+        scale: zoom,
+        centerX: points.center.x,
+        centerY: points.center.y,
+        _source: 'pinch'
+      });
+      this.reference.target.dispatchEvent(e);
+    },
+    fireRotate: function(angle, points) {
+      var diff = Math.round((angle - this.reference.angle) % 360);
+      var e = eventFactory.makeGestureEvent('rotate', {
+        bubbles: true,
+        cancelable: true,
+        angle: diff,
+        centerX: points.center.x,
+        centerY: points.center.y,
+        _source: 'pinch'
+      });
+      this.reference.target.dispatchEvent(e);
+    },
+    calcPinchRotate: function() {
+      var points = this.calcChord();
+      var diameter = points.diameter;
+      var angle = this.calcAngle(points);
+      if (diameter != this.reference.diameter) {
+        this.firePinch('pinch', diameter, points);
+      }
+      if (angle != this.reference.angle) {
+        this.fireRotate(angle, points);
+      }
+    },
+    calcChord: function() {
+      var pointers = [];
+      pointermap.forEach(function(p) {
+        pointers.push(p);
+      });
+      var dist = 0;
+      // start with at least two pointers
+      var points = {a: pointers[0], b: pointers[1]};
+      var x, y, d;
+      for (var i = 0; i < pointers.length; i++) {
+        var a = pointers[i];
+        for (var j = i + 1; j < pointers.length; j++) {
+          var b = pointers[j];
+          x = Math.abs(a.clientX - b.clientX);
+          y = Math.abs(a.clientY - b.clientY);
+          d = x + y;
+          if (d > dist) {
+            dist = d;
+            points = {a: a, b: b};
+          }
+        }
+      }
+      x = Math.abs(points.a.clientX + points.b.clientX) / 2;
+      y = Math.abs(points.a.clientY + points.b.clientY) / 2;
+      points.center = { x: x, y: y };
+      points.diameter = dist;
+      return points;
+    },
+    calcAngle: function(points) {
+      var x = points.a.clientX - points.b.clientX;
+      var y = points.a.clientY - points.b.clientY;
+      return (360 + Math.atan2(y, x) * RAD_TO_DEG) % 360;
+    }
+  };
+  dispatcher.registerGesture('pinch', pinch);
+})(window.PolymerGestures);

data/app/assets/components/polymer-gestures/src/platform-events.js

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+ */
+
+/**
+ * This module contains the handlers for native platform events.
+ * From here, the dispatcher is called to create unified pointer events.
+ * Included are touch events (v1), mouse events, and MSPointerEvents.
+ */
+(function(scope) {
+
+  var dispatcher = scope.dispatcher;
+  var nav = window.navigator;
+
+  if (window.PointerEvent) {
+    dispatcher.registerSource('pointer', scope.pointerEvents);
+  } else if (nav.msPointerEnabled) {
+    dispatcher.registerSource('ms', scope.msEvents);
+  } else {
+    dispatcher.registerSource('mouse', scope.mouseEvents);
+    if (window.ontouchstart !== undefined) {
+      dispatcher.registerSource('touch', scope.touchEvents);
+    }
+  }
+
+  // Work around iOS bugs https://bugs.webkit.org/show_bug.cgi?id=135628 and https://bugs.webkit.org/show_bug.cgi?id=136506
+  var ua = navigator.userAgent;
+  var IS_IOS = ua.match(/iPad|iPhone|iPod/) && 'ontouchstart' in window;
+
+  dispatcher.IS_IOS = IS_IOS;
+  scope.touchEvents.IS_IOS = IS_IOS;
+
+  dispatcher.register(document, true);
+})(window.PolymerGestures);

data/app/assets/components/polymer-gestures/src/pointer.js

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+ */
+
+(function(scope) {
+  var dispatcher = scope.dispatcher;
+  var pointermap = dispatcher.pointermap;
+  var pointerEvents = {
+    events: [
+      'pointerdown',
+      'pointermove',
+      'pointerup',
+      'pointercancel'
+    ],
+    prepareEvent: function(inEvent) {
+      var e = dispatcher.cloneEvent(inEvent);
+      e._source = 'pointer';
+      return e;
+    },
+    register: function(target) {
+      dispatcher.listen(target, this.events);
+    },
+    unregister: function(target) {
+      if (target.nodeType === Node.DOCUMENT_NODE) {
+        return;
+      }
+      dispatcher.unlisten(target, this.events);
+    },
+    cleanup: function(id) {
+      pointermap['delete'](id);
+    },
+    pointerdown: function(inEvent) {
+      var e = this.prepareEvent(inEvent);
+      e.target = scope.findTarget(inEvent);
+      pointermap.set(e.pointerId, e.target);
+      dispatcher.down(e);
+    },
+    pointermove: function(inEvent) {
+      var target = pointermap.get(inEvent.pointerId);
+      if (target) {
+        var e = this.prepareEvent(inEvent);
+        e.target = target;
+        dispatcher.move(e);
+      }
+    },
+    pointerup: function(inEvent) {
+      var e = this.prepareEvent(inEvent);
+      e.relatedTarget = scope.findTarget(inEvent);
+      e.target = pointermap.get(e.pointerId);
+      dispatcher.up(e);
+      this.cleanup(inEvent.pointerId);
+    },
+    pointercancel: function(inEvent) {
+      var e = this.prepareEvent(inEvent);
+      e.relatedTarget = scope.findTarget(inEvent);
+      e.target = pointermap.get(e.pointerId);
+      dispatcher.cancel(e);
+      this.cleanup(inEvent.pointerId);
+    }
+  };
+
+  scope.pointerEvents = pointerEvents;
+})(window.PolymerGestures);

data/app/assets/components/polymer-gestures/src/pointermap.js

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+ */
+
+/**
+ * This module implements an map of pointer states
+ */
+(function(scope) {
+  var USE_MAP = window.Map && window.Map.prototype.forEach;
+  var POINTERS_FN = function(){ return this.size; };
+  function PointerMap() {
+    if (USE_MAP) {
+      var m = new Map();
+      m.pointers = POINTERS_FN;
+      return m;
+    } else {
+      this.keys = [];
+      this.values = [];
+    }
+  }
+
+  PointerMap.prototype = {
+    set: function(inId, inEvent) {
+      var i = this.keys.indexOf(inId);
+      if (i > -1) {
+        this.values[i] = inEvent;
+      } else {
+        this.keys.push(inId);
+        this.values.push(inEvent);
+      }
+    },
+    has: function(inId) {
+      return this.keys.indexOf(inId) > -1;
+    },
+    'delete': function(inId) {
+      var i = this.keys.indexOf(inId);
+      if (i > -1) {
+        this.keys.splice(i, 1);
+        this.values.splice(i, 1);
+      }
+    },
+    get: function(inId) {
+      var i = this.keys.indexOf(inId);
+      return this.values[i];
+    },
+    clear: function() {
+      this.keys.length = 0;
+      this.values.length = 0;
+    },
+    // return value, key, map
+    forEach: function(callback, thisArg) {
+      this.values.forEach(function(v, i) {
+        callback.call(thisArg, v, this.keys[i], this);
+      }, this);
+    },
+    pointers: function() {
+      return this.keys.length;
+    }
+  };
+
+  scope.PointerMap = PointerMap;
+})(window.PolymerGestures);

data/app/assets/components/polymer-gestures/src/scope.js

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+ */
+window.PolymerGestures = {};

data/app/assets/components/polymer-gestures/src/tap.js

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+ */
+
+/**
+ * This event is fired when a pointer quickly goes down and up, and is used to
+ * denote activation.
+ *
+ * Any gesture event can prevent the tap event from being created by calling
+ * `event.preventTap`.
+ *
+ * Any pointer event can prevent the tap by setting the `tapPrevented` property
+ * on itself.
+ *
+ * @module PointerGestures
+ * @submodule Events
+ * @class tap
+ */
+/**
+ * X axis position of the tap.
+ * @property x
+ * @type Number
+ */
+/**
+ * Y axis position of the tap.
+ * @property y
+ * @type Number
+ */
+/**
+ * Type of the pointer that made the tap.
+ * @property pointerType
+ * @type String
+ */
+(function(scope) {
+  var dispatcher = scope.dispatcher;
+  var eventFactory = scope.eventFactory;
+  var pointermap = new scope.PointerMap();
+  var tap = {
+    events: [
+      'down',
+      'up'
+    ],
+    exposes: [
+      'tap'
+    ],
+    down: function(inEvent) {
+      if (inEvent.isPrimary && !inEvent.tapPrevented) {
+        pointermap.set(inEvent.pointerId, {
+          target: inEvent.target,
+          buttons: inEvent.buttons,
+          x: inEvent.clientX,
+          y: inEvent.clientY
+        });
+      }
+    },
+    shouldTap: function(e, downState) {
+      var tap = true;
+      if (e.pointerType === 'mouse') {
+        // only allow left click to tap for mouse
+        tap = (e.buttons ^ 1) && (downState.buttons & 1);
+      }
+      return tap && !e.tapPrevented;
+    },
+    up: function(inEvent) {
+      var start = pointermap.get(inEvent.pointerId);
+      if (start && this.shouldTap(inEvent, start)) {
+        // up.relatedTarget is target currently under finger
+        var t = scope.targetFinding.LCA(start.target, inEvent.relatedTarget);
+        if (t) {
+          var e = eventFactory.makeGestureEvent('tap', {
+            bubbles: true,
+            cancelable: true,
+            x: inEvent.clientX,
+            y: inEvent.clientY,
+            detail: inEvent.detail,
+            pointerType: inEvent.pointerType,
+            pointerId: inEvent.pointerId,
+            altKey: inEvent.altKey,
+            ctrlKey: inEvent.ctrlKey,
+            metaKey: inEvent.metaKey,
+            shiftKey: inEvent.shiftKey,
+            _source: 'tap'
+          });
+          t.dispatchEvent(e);
+        }
+      }
+      pointermap.delete(inEvent.pointerId);
+    }
+  };
+  // patch eventFactory to remove id from tap's pointermap for preventTap calls
+  eventFactory.preventTap = function(e) {
+    return function() {
+      e.tapPrevented = true;
+      pointermap.delete(e.pointerId);
+    };
+  };
+  dispatcher.registerGesture('tap', tap);
+})(window.PolymerGestures);