API Docs for: 3.8.0
Show:

File: event/js/event-facade-dom.js

  1. /**
  2.  * Custom event engine, DOM event listener abstraction layer, synthetic DOM
  3.  * events.
  4.  * @module event
  5.  * @submodule event-base
  6.  */

  8. /**
  9.  * Wraps a DOM event, properties requiring browser abstraction are
  10.  * fixed here.  Provids a security layer when required.
  11.  * @class DOMEventFacade
  12.  * @param ev {Event} the DOM event
  13.  * @param currentTarget {HTMLElement} the element the listener was attached to
  14.  * @param wrapper {Event.Custom} the custom event wrapper for this DOM event
  15.  */

  17.     var ua = Y.UA,

  19.     EMPTY = {},

  21.     /**
  22.      * webkit key remapping required for Safari < 3.1
  23.      * @property webkitKeymap
  24.      * @private
  25.      */
  26.     webkitKeymap = {
  27.         63232: 38, // up
  28.         63233: 40, // down
  29.         63234: 37, // left
  30.         63235: 39, // right
  31.         63276: 33, // page up
  32.         63277: 34, // page down
  33.         25:     9, // SHIFT-TAB (Safari provides a different key code in
  34.                    // this case, even though the shiftKey modifier is set)
  35.         63272: 46, // delete
  36.         63273: 36, // home
  37.         63275: 35  // end
  38.     },

  40.     /**
  41.      * Returns a wrapped node.  Intended to be used on event targets,
  42.      * so it will return the node's parent if the target is a text
  43.      * node.
  44.      *
  45.      * If accessing a property of the node throws an error, this is
  46.      * probably the anonymous div wrapper Gecko adds inside text
  47.      * nodes.  This likely will only occur when attempting to access
  48.      * the relatedTarget.  In this case, we now return null because
  49.      * the anonymous div is completely useless and we do not know
  50.      * what the related target was because we can't even get to
  51.      * the element's parent node.
  52.      *
  53.      * @method resolve
  54.      * @private
  55.      */
  56.     resolve = function(n) {
  57.         if (!n) {
  58.             return n;
  59.         }
  60.         try {
  61.             if (n && 3 == n.nodeType) {
  62.                 n = n.parentNode;
  63.             }
  64.         } catch(e) {
  65.             return null;
  66.         }

  68.         return Y.one(n);
  69.     },

  71.     DOMEventFacade = function(ev, currentTarget, wrapper) {
  72.         this._event = ev;
  73.         this._currentTarget = currentTarget;
  74.         this._wrapper = wrapper || EMPTY;

  76.         // if not lazy init
  77.         this.init();
  78.     };

  80. Y.extend(DOMEventFacade, Object, {

  82.     init: function() {

  84.         var e = this._event,
  85.             overrides = this._wrapper.overrides,
  86.             x = e.pageX,
  87.             y = e.pageY,
  88.             c,
  89.             currentTarget = this._currentTarget;

  91.         this.altKey   = e.altKey;
  92.         this.ctrlKey  = e.ctrlKey;
  93.         this.metaKey  = e.metaKey;
  94.         this.shiftKey = e.shiftKey;
  95.         this.type     = (overrides && overrides.type) || e.type;
  96.         this.clientX  = e.clientX;
  97.         this.clientY  = e.clientY;

  99.         this.pageX = x;
  100.         this.pageY = y;

  102.         // charCode is unknown in keyup, keydown. keyCode is unknown in keypress.
  103.         // FF 3.6 - 8+? pass 0 for keyCode in keypress events.
  104.         // Webkit, FF 3.6-8+?, and IE9+? pass 0 for charCode in keydown, keyup.
  105.         // Webkit and IE9+? duplicate charCode in keyCode.
  106.         // Opera never sets charCode, always keyCode (though with the charCode).
  107.         // IE6-8 don't set charCode or which.
  108.         // All browsers other than IE6-8 set which=keyCode in keydown, keyup, and 
  109.         // which=charCode in keypress.
  110.         //
  111.         // Moral of the story: (e.which || e.keyCode) will always return the
  112.         // known code for that key event phase. e.keyCode is often different in
  113.         // keypress from keydown and keyup.
  114.         c = e.keyCode || e.charCode;

  116.         if (ua.webkit && (c in webkitKeymap)) {
  117.             c = webkitKeymap[c];
  118.         }

  120.         this.keyCode = c;
  121.         this.charCode = c;
  122.         // Fill in e.which for IE - implementers should always use this over
  123.         // e.keyCode or e.charCode.
  124.         this.which = e.which || e.charCode || c;
  125.         // this.button = e.button;
  126.         this.button = this.which;

  128.         this.target = resolve(e.target);
  129.         this.currentTarget = resolve(currentTarget);
  130.         this.relatedTarget = resolve(e.relatedTarget);

  132.         if (e.type == "mousewheel" || e.type == "DOMMouseScroll") {
  133.             this.wheelDelta = (e.detail) ? (e.detail * -1) : Math.round(e.wheelDelta / 80) || ((e.wheelDelta < 0) ? -1 : 1);
  134.         }

  136.         if (this._touch) {
  137.             this._touch(e, currentTarget, this._wrapper);
  138.         }
  139.     },

  141.     stopPropagation: function() {
  142.         this._event.stopPropagation();
  143.         this._wrapper.stopped = 1;
  144.         this.stopped = 1;
  145.     },

  147.     stopImmediatePropagation: function() {
  148.         var e = this._event;
  149.         if (e.stopImmediatePropagation) {
  150.             e.stopImmediatePropagation();
  151.         } else {
  152.             this.stopPropagation();
  153.         }
  154.         this._wrapper.stopped = 2;
  155.         this.stopped = 2;
  156.     },

  158.     preventDefault: function(returnValue) {
  159.         var e = this._event;
  160.         e.preventDefault();
  161.         e.returnValue = returnValue || false;
  162.         this._wrapper.prevented = 1;
  163.         this.prevented = 1;
  164.     },

  166.     halt: function(immediate) {
  167.         if (immediate) {
  168.             this.stopImmediatePropagation();
  169.         } else {
  170.             this.stopPropagation();
  171.         }

  173.         this.preventDefault();
  174.     }

  176. });

  178. DOMEventFacade.resolve = resolve;
  179. Y.DOM2EventFacade = DOMEventFacade;
  180. Y.DOMEventFacade = DOMEventFacade;

  182.     /**
  183.      * The native event
  184.      * @property _event
  185.      * @type {Native DOM Event}
  186.      * @private
  187.      */

  189.     /**
  190.     The name of the event (e.g. "click")

  192.     @property type
  193.     @type {String}
  194.     **/

  196.     /**
  197.     `true` if the "alt" or "option" key is pressed.

  199.     @property altKey
  200.     @type {Boolean}
  201.     **/

  203.     /**
  204.     `true` if the shift key is pressed.

  206.     @property shiftKey
  207.     @type {Boolean}
  208.     **/

  210.     /**
  211.     `true` if the "Windows" key on a Windows keyboard, "command" key on an
  212.     Apple keyboard, or "meta" key on other keyboards is pressed.

  214.     @property metaKey
  215.     @type {Boolean}
  216.     **/

  218.     /**
  219.     `true` if the "Ctrl" or "control" key is pressed.

  221.     @property ctrlKey
  222.     @type {Boolean}
  223.     **/

  225.     /**
  226.      * The X location of the event on the page (including scroll)
  227.      * @property pageX
  228.      * @type {Number}
  229.      */

  231.     /**
  232.      * The Y location of the event on the page (including scroll)
  233.      * @property pageY
  234.      * @type {Number}
  235.      */

  237.     /**
  238.      * The X location of the event in the viewport
  239.      * @property clientX
  240.      * @type {Number}
  241.      */

  243.     /**
  244.      * The Y location of the event in the viewport
  245.      * @property clientY
  246.      * @type {Number}
  247.      */

  249.     /**
  250.      * The keyCode for key events.  Uses charCode if keyCode is not available
  251.      * @property keyCode
  252.      * @type {Number}
  253.      */

  255.     /**
  256.      * The charCode for key events.  Same as keyCode
  257.      * @property charCode
  258.      * @type {Number}
  259.      */

  261.     /**
  262.      * The button that was pushed. 1 for left click, 2 for middle click, 3 for
  263.      * right click.  This is only reliably populated on `mouseup` events.
  264.      * @property button
  265.      * @type {Number}
  266.      */

  268.     /**
  269.      * The button that was pushed.  Same as button.
  270.      * @property which
  271.      * @type {Number}
  272.      */

  274.     /**
  275.      * Node reference for the targeted element
  276.      * @property target
  277.      * @type {Node}
  278.      */

  280.     /**
  281.      * Node reference for the element that the listener was attached to.
  282.      * @property currentTarget
  283.      * @type {Node}
  284.      */

  286.     /**
  287.      * Node reference to the relatedTarget
  288.      * @property relatedTarget
  289.      * @type {Node}
  290.      */

  292.     /**
  293.      * Number representing the direction and velocity of the movement of the mousewheel.
  294.      * Negative is down, the higher the number, the faster.  Applies to the mousewheel event.
  295.      * @property wheelDelta
  296.      * @type {Number}
  297.      */

  299.     /**
  300.      * Stops the propagation to the next bubble target
  301.      * @method stopPropagation
  302.      */

  304.     /**
  305.      * Stops the propagation to the next bubble target and
  306.      * prevents any additional listeners from being exectued
  307.      * on the current target.
  308.      * @method stopImmediatePropagation
  309.      */

  311.     /**
  312.      * Prevents the event's default behavior
  313.      * @method preventDefault
  314.      * @param returnValue {string} sets the returnValue of the event to this value
  315.      * (rather than the default false value).  This can be used to add a customized
  316.      * confirmation query to the beforeunload event).
  317.      */

  319.     /**
  320.      * Stops the event propagation and prevents the default
  321.      * event behavior.
  322.      * @method halt
  323.      * @param immediate {boolean} if true additional listeners
  324.      * on the current target will not be executed
  325.      */

  327.