polymer-paper-elements-rails 0.0.1

data/app/assets/components/polymer-gestures/conf/karma.conf.js

@@ -0,0 +1,39 @@
+/*
+ * @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
+ */
+
+module.exports = function(karma) {
+  var common = require('../../tools/test/karma-common.conf.js');
+  karma.set(common.mixin_common_opts(karma, {
+    // base path, that will be used to resolve files and exclude
+    basePath: '../../',
+
+    // list of files / patterns to load in the browser
+    files: [
+      'polymer-gestures/node_modules/chai/chai.js',
+      'polymer-gestures/src/scope.js',
+      'polymer-gestures/src/targetfind.js',
+      'polymer-gestures/src/touch-action.js',
+      'polymer-gestures/src/eventFactory.js',
+      'polymer-gestures/src/pointermap.js',
+      'polymer-gestures/src/dispatcher.js',
+      'polymer-gestures/src/mouse.js',
+      'polymer-gestures/src/touch.js',
+      'polymer-gestures/src/ms.js',
+      'polymer-gestures/src/pointer.js',
+      'polymer-gestures/src/platform-events.js',
+      'polymer-gestures/src/track.js',
+      'polymer-gestures/src/hold.js',
+      'polymer-gestures/src/tap.js',
+      'polymer-gestures/test/js/setup.js',
+      'polymer-gestures/test/js/fake.js',
+      'polymer-gestures/test/js/*.js'
+    ]
+  }));
+};

data/app/assets/components/polymer-gestures/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "polymergestures",
+  "main": "Gruntfile.js",
+  "devDependencies": {
+    "mocha": "*",
+    "chai": "^1.9.1",
+    "grunt": "^0.4.4",
+    "grunt-contrib-concat": "^0.4.0",
+    "grunt-contrib-uglify": "^0.4.0",
+    "karma": "~0.12.0",
+    "karma-mocha": "*",
+    "karma-firefox-launcher": "*",
+    "karma-ie-launcher": "*",
+    "karma-script-launcher": "*",
+    "karma-crbot-reporter": "*",
+    "grunt-karma": "*",
+    "karma-safari-launcher": "~0.1.1",
+    "karma-firefox-launcher": "^0.1.3"
+  }
+}

data/app/assets/components/polymer-gestures/polymer-gestures.html

@@ -0,0 +1,21 @@
+<!-- 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 -->
+
+<script src="src/scope.js"></script>
+<script src="src/targetfind.js"></script>
+<script src="src/touch-action.js"></script>
+<script src="src/eventFactory.js"></script>
+<script src="src/pointermap.js"></script>
+<script src="src/dispatcher.js"></script>
+<script src="src/mouse.js"></script>
+<script src="src/touch.js"></script>
+<script src="src/ms.js"></script>
+<script src="src/pointer.js"></script>
+<script src="src/platform-events.js"></script>
+<script src="src/track.js"></script>
+<script src="src/hold.js"></script>
+<script src="src/tap.js"></script>

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

@@ -0,0 +1,46 @@
+/*
+ * 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() {
+  var thisFile = 'polymer-gestures.js';
+  var scopeName = 'PolymerGestures';
+  var modules = [
+    'src/scope.js',
+    'src/targetfind.js',
+    'src/touch-action.js',
+    'src/eventFactory.js',
+    'src/pointermap.js',
+    'src/dispatcher.js',
+    'src/mouse.js',
+    'src/touch.js',
+    'src/ms.js',
+    'src/pointer.js',
+    'src/platform-events.js',
+    'src/track.js',
+    'src/hold.js',
+    'src/tap.js',
+    'src/pinch.js'
+  ];
+
+  window[scopeName] = {
+    entryPointName: thisFile,
+    modules: modules
+  };
+
+  var script = document.currentScript || document.querySelector('script[src $= "' + thisFile + '"]');
+  var src = script.attributes.src.value;
+  var basePath = src.slice(0, src.indexOf(thisFile));
+
+  if (!window.PolymerLoader) {
+    var path = basePath + '../tools/loader/loader.js';
+    document.write('<script src="' + path + '"></script>');
+  }
+
+  document.write('<script>PolymerLoader.load("' + scopeName + '")</script>');
+
+})();

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

@@ -0,0 +1,474 @@
+/*
+ * 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 CLONE_PROPS = [
+    // MouseEvent
+    'bubbles',
+    'cancelable',
+    'view',
+    'detail',
+    'screenX',
+    'screenY',
+    'clientX',
+    'clientY',
+    'ctrlKey',
+    'altKey',
+    'shiftKey',
+    'metaKey',
+    'button',
+    'relatedTarget',
+    // DOM Level 3
+    'buttons',
+    // PointerEvent
+    'pointerId',
+    'width',
+    'height',
+    'pressure',
+    'tiltX',
+    'tiltY',
+    'pointerType',
+    'hwTimestamp',
+    'isPrimary',
+    // event instance
+    'type',
+    'target',
+    'currentTarget',
+    'which',
+    'pageX',
+    'pageY',
+    'timeStamp',
+    // gesture addons
+    'preventTap',
+    'tapPrevented',
+    '_source'
+  ];
+
+  var CLONE_DEFAULTS = [
+    // MouseEvent
+    false,
+    false,
+    null,
+    null,
+    0,
+    0,
+    0,
+    0,
+    false,
+    false,
+    false,
+    false,
+    0,
+    null,
+    // DOM Level 3
+    0,
+    // PointerEvent
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    '',
+    0,
+    false,
+    // event instance
+    '',
+    null,
+    null,
+    0,
+    0,
+    0,
+    0,
+    function(){},
+    false
+  ];
+
+  var HAS_SVG_INSTANCE = (typeof SVGElementInstance !== 'undefined');
+
+  var eventFactory = scope.eventFactory;
+
+  // set of recognizers to run for the currently handled event
+  var currentGestures;
+
+  /**
+   * This module is for normalizing events. Mouse and Touch events will be
+   * collected here, and fire PointerEvents that have the same semantics, no
+   * matter the source.
+   * Events fired:
+   *   - pointerdown: a pointing is added
+   *   - pointerup: a pointer is removed
+   *   - pointermove: a pointer is moved
+   *   - pointerover: a pointer crosses into an element
+   *   - pointerout: a pointer leaves an element
+   *   - pointercancel: a pointer will no longer generate events
+   */
+  var dispatcher = {
+    IS_IOS: false,
+    pointermap: new scope.PointerMap(),
+    requiredGestures: new scope.PointerMap(),
+    eventMap: Object.create(null),
+    // Scope objects for native events.
+    // This exists for ease of testing.
+    eventSources: Object.create(null),
+    eventSourceList: [],
+    gestures: [],
+    // map gesture event -> {listeners: int, index: gestures[int]}
+    dependencyMap: {
+      // make sure down and up are in the map to trigger "register"
+      down: {listeners: 0, index: -1},
+      up: {listeners: 0, index: -1}
+    },
+    gestureQueue: [],
+    /**
+     * Add a new event source that will generate pointer events.
+     *
+     * `inSource` must contain an array of event names named `events`, and
+     * functions with the names specified in the `events` array.
+     * @param {string} name A name for the event source
+     * @param {Object} source A new source of platform events.
+     */
+    registerSource: function(name, source) {
+      var s = source;
+      var newEvents = s.events;
+      if (newEvents) {
+        newEvents.forEach(function(e) {
+          if (s[e]) {
+            this.eventMap[e] = s[e].bind(s);
+          }
+        }, this);
+        this.eventSources[name] = s;
+        this.eventSourceList.push(s);
+      }
+    },
+    registerGesture: function(name, source) {
+      var obj = Object.create(null);
+      obj.listeners = 0;
+      obj.index = this.gestures.length;
+      for (var i = 0, g; i < source.exposes.length; i++) {
+        g = source.exposes[i].toLowerCase();
+        this.dependencyMap[g] = obj;
+      }
+      this.gestures.push(source);
+    },
+    register: function(element, initial) {
+      var l = this.eventSourceList.length;
+      for (var i = 0, es; (i < l) && (es = this.eventSourceList[i]); i++) {
+        // call eventsource register
+        es.register.call(es, element, initial);
+      }
+    },
+    unregister: function(element) {
+      var l = this.eventSourceList.length;
+      for (var i = 0, es; (i < l) && (es = this.eventSourceList[i]); i++) {
+        // call eventsource register
+        es.unregister.call(es, element);
+      }
+    },
+    // EVENTS
+    down: function(inEvent) {
+      this.requiredGestures.set(inEvent.pointerId, currentGestures);
+      this.fireEvent('down', inEvent);
+    },
+    move: function(inEvent) {
+      // pipe move events into gesture queue directly
+      inEvent.type = 'move';
+      this.fillGestureQueue(inEvent);
+    },
+    up: function(inEvent) {
+      this.fireEvent('up', inEvent);
+      this.requiredGestures.delete(inEvent.pointerId);
+    },
+    cancel: function(inEvent) {
+      inEvent.tapPrevented = true;
+      this.fireEvent('up', inEvent);
+      this.requiredGestures.delete(inEvent.pointerId);
+    },
+    addGestureDependency: function(node, currentGestures) {
+      var gesturesWanted = node._pgEvents;
+      if (gesturesWanted && currentGestures) {
+        var gk = Object.keys(gesturesWanted);
+        for (var i = 0, r, ri, g; i < gk.length; i++) {
+          // gesture
+          g = gk[i];
+          if (gesturesWanted[g] > 0) {
+            // lookup gesture recognizer
+            r = this.dependencyMap[g];
+            // recognizer index
+            ri = r ? r.index : -1;
+            currentGestures[ri] = true;
+          }
+        }
+      }
+    },
+    // LISTENER LOGIC
+    eventHandler: function(inEvent) {
+      // This is used to prevent multiple dispatch of events from
+      // platform events. This can happen when two elements in different scopes
+      // are set up to create pointer events, which is relevant to Shadow DOM.
+
+      var type = inEvent.type;
+
+      // only generate the list of desired events on "down"
+      if (type === 'touchstart' || type === 'mousedown' || type === 'pointerdown' || type === 'MSPointerDown') {
+        if (!inEvent._handledByPG) {
+          currentGestures = {};
+        }
+
+        // in IOS mode, there is only a listener on the document, so this is not re-entrant
+        if (this.IS_IOS) {
+          var ev = inEvent;
+          if (type === 'touchstart') {
+            var ct = inEvent.changedTouches[0];
+            // set up a fake event to give to the path builder
+            ev = {target: inEvent.target, clientX: ct.clientX, clientY: ct.clientY, path: inEvent.path};
+          }
+          // use event path if available, otherwise build a path from target finding
+          var nodes = inEvent.path || scope.targetFinding.path(ev);
+          for (var i = 0, n; i < nodes.length; i++) {
+            n = nodes[i];
+            this.addGestureDependency(n, currentGestures);
+          }
+        } else {
+          this.addGestureDependency(inEvent.currentTarget, currentGestures);
+        }
+      }
+
+      if (inEvent._handledByPG) {
+        return;
+      }
+      var fn = this.eventMap && this.eventMap[type];
+      if (fn) {
+        fn(inEvent);
+      }
+      inEvent._handledByPG = true;
+    },
+    // set up event listeners
+    listen: function(target, events) {
+      for (var i = 0, l = events.length, e; (i < l) && (e = events[i]); i++) {
+        this.addEvent(target, e);
+      }
+    },
+    // remove event listeners
+    unlisten: function(target, events) {
+      for (var i = 0, l = events.length, e; (i < l) && (e = events[i]); i++) {
+        this.removeEvent(target, e);
+      }
+    },
+    addEvent: function(target, eventName) {
+      target.addEventListener(eventName, this.boundHandler);
+    },
+    removeEvent: function(target, eventName) {
+      target.removeEventListener(eventName, this.boundHandler);
+    },
+    // EVENT CREATION AND TRACKING
+    /**
+     * Creates a new Event of type `inType`, based on the information in
+     * `inEvent`.
+     *
+     * @param {string} inType A string representing the type of event to create
+     * @param {Event} inEvent A platform event with a target
+     * @return {Event} A PointerEvent of type `inType`
+     */
+    makeEvent: function(inType, inEvent) {
+      var e = eventFactory.makePointerEvent(inType, inEvent);
+      e.preventDefault = inEvent.preventDefault;
+      e.tapPrevented = inEvent.tapPrevented;
+      e._target = e._target || inEvent.target;
+      return e;
+    },
+    // make and dispatch an event in one call
+    fireEvent: function(inType, inEvent) {
+      var e = this.makeEvent(inType, inEvent);
+      return this.dispatchEvent(e);
+    },
+    /**
+     * Returns a snapshot of inEvent, with writable properties.
+     *
+     * @param {Event} inEvent An event that contains properties to copy.
+     * @return {Object} An object containing shallow copies of `inEvent`'s
+     *    properties.
+     */
+    cloneEvent: function(inEvent) {
+      var eventCopy = Object.create(null), p;
+      for (var i = 0; i < CLONE_PROPS.length; i++) {
+        p = CLONE_PROPS[i];
+        eventCopy[p] = inEvent[p] || CLONE_DEFAULTS[i];
+        // Work around SVGInstanceElement shadow tree
+        // Return the <use> element that is represented by the instance for Safari, Chrome, IE.
+        // This is the behavior implemented by Firefox.
+        if (p === 'target' || p === 'relatedTarget') {
+          if (HAS_SVG_INSTANCE && eventCopy[p] instanceof SVGElementInstance) {
+            eventCopy[p] = eventCopy[p].correspondingUseElement;
+          }
+        }
+      }
+      // keep the semantics of preventDefault
+      eventCopy.preventDefault = function() {
+        inEvent.preventDefault();
+      };
+      return eventCopy;
+    },
+    /**
+     * Dispatches the event to its target.
+     *
+     * @param {Event} inEvent The event to be dispatched.
+     * @return {Boolean} True if an event handler returns true, false otherwise.
+     */
+    dispatchEvent: function(inEvent) {
+      var t = inEvent._target;
+      if (t) {
+        t.dispatchEvent(inEvent);
+        // clone the event for the gesture system to process
+        // clone after dispatch to pick up gesture prevention code
+        var clone = this.cloneEvent(inEvent);
+        clone.target = t;
+        this.fillGestureQueue(clone);
+      }
+    },
+    gestureTrigger: function() {
+      // process the gesture queue
+      for (var i = 0, e, rg; i < this.gestureQueue.length; i++) {
+        e = this.gestureQueue[i];
+        rg = e._requiredGestures;
+        if (rg) {
+          for (var j = 0, g, fn; j < this.gestures.length; j++) {
+            // only run recognizer if an element in the source event's path is listening for those gestures
+            if (rg[j]) {
+              g = this.gestures[j];
+              fn = g[e.type];
+              if (fn) {
+                fn.call(g, e);
+              }
+            }
+          }
+        }
+      }
+      this.gestureQueue.length = 0;
+    },
+    fillGestureQueue: function(ev) {
+      // only trigger the gesture queue once
+      if (!this.gestureQueue.length) {
+        requestAnimationFrame(this.boundGestureTrigger);
+      }
+      ev._requiredGestures = this.requiredGestures.get(ev.pointerId);
+      this.gestureQueue.push(ev);
+    }
+  };
+  dispatcher.boundHandler = dispatcher.eventHandler.bind(dispatcher);
+  dispatcher.boundGestureTrigger = dispatcher.gestureTrigger.bind(dispatcher);
+  scope.dispatcher = dispatcher;
+
+  /**
+   * Listen for `gesture` on `node` with the `handler` function
+   *
+   * If `handler` is the first listener for `gesture`, the underlying gesture recognizer is then enabled.
+   *
+   * @param {Element} node
+   * @param {string} gesture
+   * @return Boolean `gesture` is a valid gesture
+   */
+  scope.activateGesture = function(node, gesture) {
+    var g = gesture.toLowerCase();
+    var dep = dispatcher.dependencyMap[g];
+    if (dep) {
+      var recognizer = dispatcher.gestures[dep.index];
+      if (!node._pgListeners) {
+        dispatcher.register(node);
+        node._pgListeners = 0;
+      }
+      // TODO(dfreedm): re-evaluate bookkeeping to avoid using attributes
+      if (recognizer) {
+        var touchAction = recognizer.defaultActions && recognizer.defaultActions[g];
+        var actionNode;
+        switch(node.nodeType) {
+          case Node.ELEMENT_NODE:
+            actionNode = node;
+          break;
+          case Node.DOCUMENT_FRAGMENT_NODE:
+            actionNode = node.host;
+          break;
+          default:
+            actionNode = null;
+          break;
+        }
+        if (touchAction && actionNode && !actionNode.hasAttribute('touch-action')) {
+          actionNode.setAttribute('touch-action', touchAction);
+        }
+      }
+      if (!node._pgEvents) {
+        node._pgEvents = {};
+      }
+      node._pgEvents[g] = (node._pgEvents[g] || 0) + 1;
+      node._pgListeners++;
+    }
+    return Boolean(dep);
+  };
+
+  /**
+   *
+   * Listen for `gesture` from `node` with `handler` function.
+   *
+   * @param {Element} node
+   * @param {string} gesture
+   * @param {Function} handler
+   * @param {Boolean} capture
+   */
+  scope.addEventListener = function(node, gesture, handler, capture) {
+    if (handler) {
+      scope.activateGesture(node, gesture);
+      node.addEventListener(gesture, handler, capture);
+    }
+  };
+
+  /**
+   * Tears down the gesture configuration for `node`
+   *
+   * If `handler` is the last listener for `gesture`, the underlying gesture recognizer is disabled.
+   *
+   * @param {Element} node
+   * @param {string} gesture
+   * @return Boolean `gesture` is a valid gesture
+   */
+  scope.deactivateGesture = function(node, gesture) {
+    var g = gesture.toLowerCase();
+    var dep = dispatcher.dependencyMap[g];
+    if (dep) {
+      if (node._pgListeners > 0) {
+        node._pgListeners--;
+      }
+      if (node._pgListeners === 0) {
+        dispatcher.unregister(node);
+      }
+      if (node._pgEvents) {
+        if (node._pgEvents[g] > 0) {
+          node._pgEvents[g]--;
+        } else {
+          node._pgEvents[g] = 0;
+        }
+      }
+    }
+    return Boolean(dep);
+  };
+
+  /**
+   * Stop listening for `gesture` from `node` with `handler` function.
+   *
+   * @param {Element} node
+   * @param {string} gesture
+   * @param {Function} handler
+   * @param {Boolean} capture
+   */
+  scope.removeEventListener = function(node, gesture, handler, capture) {
+    if (handler) {
+      scope.deactivateGesture(node, gesture);
+      node.removeEventListener(gesture, handler, capture);
+    }
+  };
+})(window.PolymerGestures);