docs/source/EventObject.html

   1 <!DOCTYPE html>
   2 <html>
   3 <head>
   4   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   5   <title>The source code</title>
   6   <link href="../prettify/prettify.css" type="text/css" rel="stylesheet" />
   7   <script type="text/javascript" src="../prettify/prettify.js"></script>
   8   <style type="text/css">
   9     .highlight { display: block; background-color: #ddd; }
  10   </style>
  11   <script type="text/javascript">
  12     function highlight() {
  13       document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
  14     }
  15   </script>
  16 </head>
  17 <body onload="prettyPrint(); highlight();">
  18   <pre class="prettyprint lang-js"><span id='Ext-EventObject'>/**
  19 </span> * @class Ext.EventObject
  20
  21 Just as {@link Ext.core.Element} wraps around a native DOM node, Ext.EventObject
  22 wraps the browser's native event-object normalizing cross-browser differences,
  23 such as which mouse button is clicked, keys pressed, mechanisms to stop
  24 event-propagation along with a method to prevent default actions from taking place.
  25
  26 For example:
  27
  28     function handleClick(e, t){ // e is not a standard event object, it is a Ext.EventObject
  29         e.preventDefault();
  30         var target = e.getTarget(); // same as t (the target HTMLElement)
  31         ...
  32     }
  33
  34     var myDiv = {@link Ext#get Ext.get}(&quot;myDiv&quot;);  // get reference to an {@link Ext.core.Element}
  35     myDiv.on(         // 'on' is shorthand for addListener
  36         &quot;click&quot;,      // perform an action on click of myDiv
  37         handleClick   // reference to the action handler
  38     );
  39
  40     // other methods to do the same:
  41     Ext.EventManager.on(&quot;myDiv&quot;, 'click', handleClick);
  42     Ext.EventManager.addListener(&quot;myDiv&quot;, 'click', handleClick);
  43
  44  * @singleton
  45  * @markdown
  46  */
  47 Ext.define('Ext.EventObjectImpl', {
  48     uses: ['Ext.util.Point'],
  49
  50 <span id='Ext-EventObject-property-BACKSPACE'>    /** Key constant @type Number */
  51 </span>    BACKSPACE: 8,
  52 <span id='Ext-EventObject-property-TAB'>    /** Key constant @type Number */
  53 </span>    TAB: 9,
  54 <span id='Ext-EventObject-property-NUM_CENTER'>    /** Key constant @type Number */
  55 </span>    NUM_CENTER: 12,
  56 <span id='Ext-EventObject-property-ENTER'>    /** Key constant @type Number */
  57 </span>    ENTER: 13,
  58 <span id='Ext-EventObject-property-RETURN'>    /** Key constant @type Number */
  59 </span>    RETURN: 13,
  60 <span id='Ext-EventObject-property-SHIFT'>    /** Key constant @type Number */
  61 </span>    SHIFT: 16,
  62 <span id='Ext-EventObject-property-CTRL'>    /** Key constant @type Number */
  63 </span>    CTRL: 17,
  64 <span id='Ext-EventObject-property-ALT'>    /** Key constant @type Number */
  65 </span>    ALT: 18,
  66 <span id='Ext-EventObject-property-PAUSE'>    /** Key constant @type Number */
  67 </span>    PAUSE: 19,
  68 <span id='Ext-EventObject-property-CAPS_LOCK'>    /** Key constant @type Number */
  69 </span>    CAPS_LOCK: 20,
  70 <span id='Ext-EventObject-property-ESC'>    /** Key constant @type Number */
  71 </span>    ESC: 27,
  72 <span id='Ext-EventObject-property-SPACE'>    /** Key constant @type Number */
  73 </span>    SPACE: 32,
  74 <span id='Ext-EventObject-property-PAGE_UP'>    /** Key constant @type Number */
  75 </span>    PAGE_UP: 33,
  76 <span id='Ext-EventObject-property-PAGE_DOWN'>    /** Key constant @type Number */
  77 </span>    PAGE_DOWN: 34,
  78 <span id='Ext-EventObject-property-END'>    /** Key constant @type Number */
  79 </span>    END: 35,
  80 <span id='Ext-EventObject-property-HOME'>    /** Key constant @type Number */
  81 </span>    HOME: 36,
  82 <span id='Ext-EventObject-property-LEFT'>    /** Key constant @type Number */
  83 </span>    LEFT: 37,
  84 <span id='Ext-EventObject-property-UP'>    /** Key constant @type Number */
  85 </span>    UP: 38,
  86 <span id='Ext-EventObject-property-RIGHT'>    /** Key constant @type Number */
  87 </span>    RIGHT: 39,
  88 <span id='Ext-EventObject-property-DOWN'>    /** Key constant @type Number */
  89 </span>    DOWN: 40,
  90 <span id='Ext-EventObject-property-PRINT_SCREEN'>    /** Key constant @type Number */
  91 </span>    PRINT_SCREEN: 44,
  92 <span id='Ext-EventObject-property-INSERT'>    /** Key constant @type Number */
  93 </span>    INSERT: 45,
  94 <span id='Ext-EventObject-property-DELETE'>    /** Key constant @type Number */
  95 </span>    DELETE: 46,
  96 <span id='Ext-EventObject-property-ZERO'>    /** Key constant @type Number */
  97 </span>    ZERO: 48,
  98 <span id='Ext-EventObject-property-ONE'>    /** Key constant @type Number */
  99 </span>    ONE: 49,
 100 <span id='Ext-EventObject-property-TWO'>    /** Key constant @type Number */
 101 </span>    TWO: 50,
 102 <span id='Ext-EventObject-property-THREE'>    /** Key constant @type Number */
 103 </span>    THREE: 51,
 104 <span id='Ext-EventObject-property-FOUR'>    /** Key constant @type Number */
 105 </span>    FOUR: 52,
 106 <span id='Ext-EventObject-property-FIVE'>    /** Key constant @type Number */
 107 </span>    FIVE: 53,
 108 <span id='Ext-EventObject-property-SIX'>    /** Key constant @type Number */
 109 </span>    SIX: 54,
 110 <span id='Ext-EventObject-property-SEVEN'>    /** Key constant @type Number */
 111 </span>    SEVEN: 55,
 112 <span id='Ext-EventObject-property-EIGHT'>    /** Key constant @type Number */
 113 </span>    EIGHT: 56,
 114 <span id='Ext-EventObject-property-NINE'>    /** Key constant @type Number */
 115 </span>    NINE: 57,
 116 <span id='Ext-EventObject-property-A'>    /** Key constant @type Number */
 117 </span>    A: 65,
 118 <span id='Ext-EventObject-property-B'>    /** Key constant @type Number */
 119 </span>    B: 66,
 120 <span id='Ext-EventObject-property-C'>    /** Key constant @type Number */
 121 </span>    C: 67,
 122 <span id='Ext-EventObject-property-D'>    /** Key constant @type Number */
 123 </span>    D: 68,
 124 <span id='Ext-EventObject-property-E'>    /** Key constant @type Number */
 125 </span>    E: 69,
 126 <span id='Ext-EventObject-property-F'>    /** Key constant @type Number */
 127 </span>    F: 70,
 128 <span id='Ext-EventObject-property-G'>    /** Key constant @type Number */
 129 </span>    G: 71,
 130 <span id='Ext-EventObject-property-H'>    /** Key constant @type Number */
 131 </span>    H: 72,
 132 <span id='Ext-EventObject-property-I'>    /** Key constant @type Number */
 133 </span>    I: 73,
 134 <span id='Ext-EventObject-property-J'>    /** Key constant @type Number */
 135 </span>    J: 74,
 136 <span id='Ext-EventObject-property-K'>    /** Key constant @type Number */
 137 </span>    K: 75,
 138 <span id='Ext-EventObject-property-L'>    /** Key constant @type Number */
 139 </span>    L: 76,
 140 <span id='Ext-EventObject-property-M'>    /** Key constant @type Number */
 141 </span>    M: 77,
 142 <span id='Ext-EventObject-property-N'>    /** Key constant @type Number */
 143 </span>    N: 78,
 144 <span id='Ext-EventObject-property-O'>    /** Key constant @type Number */
 145 </span>    O: 79,
 146 <span id='Ext-EventObject-property-P'>    /** Key constant @type Number */
 147 </span>    P: 80,
 148 <span id='Ext-EventObject-property-Q'>    /** Key constant @type Number */
 149 </span>    Q: 81,
 150 <span id='Ext-EventObject-property-R'>    /** Key constant @type Number */
 151 </span>    R: 82,
 152 <span id='Ext-EventObject-property-S'>    /** Key constant @type Number */
 153 </span>    S: 83,
 154 <span id='Ext-EventObject-property-T'>    /** Key constant @type Number */
 155 </span>    T: 84,
 156 <span id='Ext-EventObject-property-U'>    /** Key constant @type Number */
 157 </span>    U: 85,
 158 <span id='Ext-EventObject-property-V'>    /** Key constant @type Number */
 159 </span>    V: 86,
 160 <span id='Ext-EventObject-property-W'>    /** Key constant @type Number */
 161 </span>    W: 87,
 162 <span id='Ext-EventObject-property-X'>    /** Key constant @type Number */
 163 </span>    X: 88,
 164 <span id='Ext-EventObject-property-Y'>    /** Key constant @type Number */
 165 </span>    Y: 89,
 166 <span id='Ext-EventObject-property-Z'>    /** Key constant @type Number */
 167 </span>    Z: 90,
 168 <span id='Ext-EventObject-property-CONTEXT_MENU'>    /** Key constant @type Number */
 169 </span>    CONTEXT_MENU: 93,
 170 <span id='Ext-EventObject-property-NUM_ZERO'>    /** Key constant @type Number */
 171 </span>    NUM_ZERO: 96,
 172 <span id='Ext-EventObject-property-NUM_ONE'>    /** Key constant @type Number */
 173 </span>    NUM_ONE: 97,
 174 <span id='Ext-EventObject-property-NUM_TWO'>    /** Key constant @type Number */
 175 </span>    NUM_TWO: 98,
 176 <span id='Ext-EventObject-property-NUM_THREE'>    /** Key constant @type Number */
 177 </span>    NUM_THREE: 99,
 178 <span id='Ext-EventObject-property-NUM_FOUR'>    /** Key constant @type Number */
 179 </span>    NUM_FOUR: 100,
 180 <span id='Ext-EventObject-property-NUM_FIVE'>    /** Key constant @type Number */
 181 </span>    NUM_FIVE: 101,
 182 <span id='Ext-EventObject-property-NUM_SIX'>    /** Key constant @type Number */
 183 </span>    NUM_SIX: 102,
 184 <span id='Ext-EventObject-property-NUM_SEVEN'>    /** Key constant @type Number */
 185 </span>    NUM_SEVEN: 103,
 186 <span id='Ext-EventObject-property-NUM_EIGHT'>    /** Key constant @type Number */
 187 </span>    NUM_EIGHT: 104,
 188 <span id='Ext-EventObject-property-NUM_NINE'>    /** Key constant @type Number */
 189 </span>    NUM_NINE: 105,
 190 <span id='Ext-EventObject-property-NUM_MULTIPLY'>    /** Key constant @type Number */
 191 </span>    NUM_MULTIPLY: 106,
 192 <span id='Ext-EventObject-property-NUM_PLUS'>    /** Key constant @type Number */
 193 </span>    NUM_PLUS: 107,
 194 <span id='Ext-EventObject-property-NUM_MINUS'>    /** Key constant @type Number */
 195 </span>    NUM_MINUS: 109,
 196 <span id='Ext-EventObject-property-NUM_PERIOD'>    /** Key constant @type Number */
 197 </span>    NUM_PERIOD: 110,
 198 <span id='Ext-EventObject-property-NUM_DIVISION'>    /** Key constant @type Number */
 199 </span>    NUM_DIVISION: 111,
 200 <span id='Ext-EventObject-property-F1'>    /** Key constant @type Number */
 201 </span>    F1: 112,
 202 <span id='Ext-EventObject-property-F2'>    /** Key constant @type Number */
 203 </span>    F2: 113,
 204 <span id='Ext-EventObject-property-F3'>    /** Key constant @type Number */
 205 </span>    F3: 114,
 206 <span id='Ext-EventObject-property-F4'>    /** Key constant @type Number */
 207 </span>    F4: 115,
 208 <span id='Ext-EventObject-property-F5'>    /** Key constant @type Number */
 209 </span>    F5: 116,
 210 <span id='Ext-EventObject-property-F6'>    /** Key constant @type Number */
 211 </span>    F6: 117,
 212 <span id='Ext-EventObject-property-F7'>    /** Key constant @type Number */
 213 </span>    F7: 118,
 214 <span id='Ext-EventObject-property-F8'>    /** Key constant @type Number */
 215 </span>    F8: 119,
 216 <span id='Ext-EventObject-property-F9'>    /** Key constant @type Number */
 217 </span>    F9: 120,
 218 <span id='Ext-EventObject-property-F10'>    /** Key constant @type Number */
 219 </span>    F10: 121,
 220 <span id='Ext-EventObject-property-F11'>    /** Key constant @type Number */
 221 </span>    F11: 122,
 222 <span id='Ext-EventObject-property-F12'>    /** Key constant @type Number */
 223 </span>    F12: 123,
 224 <span id='Ext-EventObject-property-WHEEL_SCALE'>    /**
 225 </span>     * The mouse wheel delta scaling factor. This value depends on browser version and OS and
 226      * attempts to produce a similar scrolling experience across all platforms and browsers.
 227      *
 228      * To change this value:
 229      *
 230      *      Ext.EventObjectImpl.prototype.WHEEL_SCALE = 72;
 231      *
 232      * @type Number
 233      * @markdown
 234      */
 235     WHEEL_SCALE: (function () {
 236         var scale;
 237
 238         if (Ext.isGecko) {
 239             // Firefox uses 3 on all platforms
 240             scale = 3;
 241         } else if (Ext.isMac) {
 242             // Continuous scrolling devices have momentum and produce much more scroll than
 243             // discrete devices on the same OS and browser. To make things exciting, Safari
 244             // (and not Chrome) changed from small values to 120 (like IE).
 245
 246             if (Ext.isSafari &amp;&amp; Ext.webKitVersion &gt;= 532.0) {
 247                 // Safari changed the scrolling factor to match IE (for details see
 248                 // https://bugs.webkit.org/show_bug.cgi?id=24368). The WebKit version where this
 249                 // change was introduced was 532.0
 250                 //      Detailed discussion:
 251                 //      https://bugs.webkit.org/show_bug.cgi?id=29601
 252                 //      http://trac.webkit.org/browser/trunk/WebKit/chromium/src/mac/WebInputEventFactory.mm#L1063
 253                 scale = 120;
 254             } else {
 255                 // MS optical wheel mouse produces multiples of 12 which is close enough
 256                 // to help tame the speed of the continuous mice...
 257                 scale = 12;
 258             }
 259
 260             // Momentum scrolling produces very fast scrolling, so increase the scale factor
 261             // to help produce similar results cross platform. This could be even larger and
 262             // it would help those mice, but other mice would become almost unusable as a
 263             // result (since we cannot tell which device type is in use).
 264             scale *= 3;
 265         } else {
 266             // IE, Opera and other Windows browsers use 120.
 267             scale = 120;
 268         }
 269
 270         return scale;
 271     })(),
 272
 273 <span id='Ext-EventObject-property-clickRe'>    /**
 274 </span>     * Simple click regex
 275      * @private
 276      */
 277     clickRe: /(dbl)?click/,
 278     // safari keypress events for special keys return bad keycodes
 279     safariKeys: {
 280         3: 13, // enter
 281         63234: 37, // left
 282         63235: 39, // right
 283         63232: 38, // up
 284         63233: 40, // down
 285         63276: 33, // page up
 286         63277: 34, // page down
 287         63272: 46, // delete
 288         63273: 36, // home
 289         63275: 35 // end
 290     },
 291     // normalize button clicks, don't see any way to feature detect this.
 292     btnMap: Ext.isIE ? {
 293         1: 0,
 294         4: 1,
 295         2: 2
 296     } : {
 297         0: 0,
 298         1: 1,
 299         2: 2
 300     },
 301
 302     constructor: function(event, freezeEvent){
 303         if (event) {
 304             this.setEvent(event.browserEvent || event, freezeEvent);
 305         }
 306     },
 307
 308     setEvent: function(event, freezeEvent){
 309         var me = this, button, options;
 310
 311         if (event == me || (event &amp;&amp; event.browserEvent)) { // already wrapped
 312             return event;
 313         }
 314         me.browserEvent = event;
 315         if (event) {
 316             // normalize buttons
 317             button = event.button ? me.btnMap[event.button] : (event.which ? event.which - 1 : -1);
 318             if (me.clickRe.test(event.type) &amp;&amp; button == -1) {
 319                 button = 0;
 320             }
 321             options = {
 322                 type: event.type,
 323                 button: button,
 324                 shiftKey: event.shiftKey,
 325                 // mac metaKey behaves like ctrlKey
 326                 ctrlKey: event.ctrlKey || event.metaKey || false,
 327                 altKey: event.altKey,
 328                 // in getKey these will be normalized for the mac
 329                 keyCode: event.keyCode,
 330                 charCode: event.charCode,
 331                 // cache the targets for the delayed and or buffered events
 332                 target: Ext.EventManager.getTarget(event),
 333                 relatedTarget: Ext.EventManager.getRelatedTarget(event),
 334                 currentTarget: event.currentTarget,
 335                 xy: (freezeEvent ? me.getXY() : null)
 336             };
 337         } else {
 338             options = {
 339                 button: -1,
 340                 shiftKey: false,
 341                 ctrlKey: false,
 342                 altKey: false,
 343                 keyCode: 0,
 344                 charCode: 0,
 345                 target: null,
 346                 xy: [0, 0]
 347             };
 348         }
 349         Ext.apply(me, options);
 350         return me;
 351     },
 352
 353 <span id='Ext-EventObject-method-stopEvent'>    /**
 354 </span>     * Stop the event (preventDefault and stopPropagation)
 355      */
 356     stopEvent: function(){
 357         this.stopPropagation();
 358         this.preventDefault();
 359     },
 360
 361 <span id='Ext-EventObject-method-preventDefault'>    /**
 362 </span>     * Prevents the browsers default handling of the event.
 363      */
 364     preventDefault: function(){
 365         if (this.browserEvent) {
 366             Ext.EventManager.preventDefault(this.browserEvent);
 367         }
 368     },
 369
 370 <span id='Ext-EventObject-method-stopPropagation'>    /**
 371 </span>     * Cancels bubbling of the event.
 372      */
 373     stopPropagation: function(){
 374         var browserEvent = this.browserEvent;
 375
 376         if (browserEvent) {
 377             if (browserEvent.type == 'mousedown') {
 378                 Ext.EventManager.stoppedMouseDownEvent.fire(this);
 379             }
 380             Ext.EventManager.stopPropagation(browserEvent);
 381         }
 382     },
 383
 384 <span id='Ext-EventObject-method-getCharCode'>    /**
 385 </span>     * Gets the character code for the event.
 386      * @return {Number}
 387      */
 388     getCharCode: function(){
 389         return this.charCode || this.keyCode;
 390     },
 391
 392 <span id='Ext-EventObject-method-getKey'>    /**
 393 </span>     * Returns a normalized keyCode for the event.
 394      * @return {Number} The key code
 395      */
 396     getKey: function(){
 397         return this.normalizeKey(this.keyCode || this.charCode);
 398     },
 399
 400 <span id='Ext-EventObject-method-normalizeKey'>    /**
 401 </span>     * Normalize key codes across browsers
 402      * @private
 403      * @param {Number} key The key code
 404      * @return {Number} The normalized code
 405      */
 406     normalizeKey: function(key){
 407         // can't feature detect this
 408         return Ext.isWebKit ? (this.safariKeys[key] || key) : key;
 409     },
 410
 411 <span id='Ext-EventObject-method-getPageX'>    /**
 412 </span>     * Gets the x coordinate of the event.
 413      * @return {Number}
 414      * @deprecated 4.0 Replaced by {@link #getX}
 415      */
 416     getPageX: function(){
 417         return this.getX();
 418     },
 419
 420 <span id='Ext-EventObject-method-getPageY'>    /**
 421 </span>     * Gets the y coordinate of the event.
 422      * @return {Number}
 423      * @deprecated 4.0 Replaced by {@link #getY}
 424      */
 425     getPageY: function(){
 426         return this.getY();
 427     },
 428
 429 <span id='Ext-EventObject-method-getX'>    /**
 430 </span>     * Gets the x coordinate of the event.
 431      * @return {Number}
 432      */
 433     getX: function() {
 434         return this.getXY()[0];
 435     },
 436
 437 <span id='Ext-EventObject-method-getY'>    /**
 438 </span>     * Gets the y coordinate of the event.
 439      * @return {Number}
 440      */
 441     getY: function() {
 442         return this.getXY()[1];
 443     },
 444
 445 <span id='Ext-EventObject-method-getXY'>    /**
 446 </span>     * Gets the page coordinates of the event.
 447      * @return {Array} The xy values like [x, y]
 448      */
 449     getXY: function() {
 450         if (!this.xy) {
 451             // same for XY
 452             this.xy = Ext.EventManager.getPageXY(this.browserEvent);
 453         }
 454         return this.xy;
 455     },
 456
 457 <span id='Ext-EventObject-method-getTarget'>    /**
 458 </span>     * Gets the target for the event.
 459      * @param {String} selector (optional) A simple selector to filter the target or look for an ancestor of the target
 460      * @param {Number/Mixed} maxDepth (optional) The max depth to search as a number or element (defaults to 10 || document.body)
 461      * @param {Boolean} returnEl (optional) True to return a Ext.core.Element object instead of DOM node
 462      * @return {HTMLelement}
 463      */
 464     getTarget : function(selector, maxDepth, returnEl){
 465         if (selector) {
 466             return Ext.fly(this.target).findParent(selector, maxDepth, returnEl);
 467         }
 468         return returnEl ? Ext.get(this.target) : this.target;
 469     },
 470
 471 <span id='Ext-EventObject-method-getRelatedTarget'>    /**
 472 </span>     * Gets the related target.
 473      * @param {String} selector (optional) A simple selector to filter the target or look for an ancestor of the target
 474      * @param {Number/Mixed} maxDepth (optional) The max depth to search as a number or element (defaults to 10 || document.body)
 475      * @param {Boolean} returnEl (optional) True to return a Ext.core.Element object instead of DOM node
 476      * @return {HTMLElement}
 477      */
 478     getRelatedTarget : function(selector, maxDepth, returnEl){
 479         if (selector) {
 480             return Ext.fly(this.relatedTarget).findParent(selector, maxDepth, returnEl);
 481         }
 482         return returnEl ? Ext.get(this.relatedTarget) : this.relatedTarget;
 483     },
 484
 485 <span id='Ext-EventObject-method-correctWheelDelta'>    /**
 486 </span>     * Correctly scales a given wheel delta.
 487      * @param {Number} delta The delta value.
 488      */
 489     correctWheelDelta : function (delta) {
 490         var scale = this.WHEEL_SCALE,
 491             ret = Math.round(delta / scale + 0.5);
 492
 493         if (!ret &amp;&amp; delta) {
 494             ret = (delta &lt; 0) ? -1 : 1; // don't allow non-zero deltas to go to zero!
 495         }
 496
 497         return ret;
 498     },
 499
 500 <span id='Ext-EventObject-method-getWheelDeltas'>    /**
 501 </span>     * Returns the mouse wheel deltas for this event.
 502      * @return {Object} An object with &quot;x&quot; and &quot;y&quot; properties holding the mouse wheel deltas.
 503      */
 504     getWheelDeltas : function () {
 505         var me = this,
 506             event = me.browserEvent,
 507             dx = 0, dy = 0; // the deltas
 508
 509         if (Ext.isDefined(event.wheelDeltaX)) { // WebKit has both dimensions
 510             dx = event.wheelDeltaX;
 511             dy = event.wheelDeltaY;
 512         } else if (event.wheelDelta) { // old WebKit and IE
 513             dy = event.wheelDelta;
 514         } else if (event.detail) { // Gecko
 515             dy = -event.detail; // gecko is backwards
 516
 517             // Gecko sometimes returns really big values if the user changes settings to
 518             // scroll a whole page per scroll
 519             if (dy &gt; 100) {
 520                 dy = 3;
 521             } else if (dy &lt; -100) {
 522                 dy = -3;
 523             }
 524
 525             // Firefox 3.1 adds an axis field to the event to indicate direction of
 526             // scroll.  See https://developer.mozilla.org/en/Gecko-Specific_DOM_Events
 527             if (Ext.isDefined(event.axis) &amp;&amp; event.axis === event.HORIZONTAL_AXIS) {
 528                 dx = dy;
 529                 dy = 0;
 530             }
 531         }
 532
 533         return {
 534             x: me.correctWheelDelta(dx),
 535             y: me.correctWheelDelta(dy)
 536         };
 537     },
 538
 539 <span id='Ext-EventObject-method-getWheelDelta'>    /**
 540 </span>     * Normalizes mouse wheel y-delta across browsers. To get x-delta information, use
 541      * {@link #getWheelDeltas} instead.
 542      * @return {Number} The mouse wheel y-delta
 543      */
 544     getWheelDelta : function(){
 545         var deltas = this.getWheelDeltas();
 546
 547         return deltas.y;
 548     },
 549
 550 <span id='Ext-EventObject-method-within'>    /**
 551 </span>    * Returns true if the target of this event is a child of el.  Unless the allowEl parameter is set, it will return false if if the target is el.
 552     * Example usage:&lt;pre&gt;&lt;code&gt;
 553 // Handle click on any child of an element
 554 Ext.getBody().on('click', function(e){
 555     if(e.within('some-el')){
 556         alert('Clicked on a child of some-el!');
 557     }
 558 });
 559
 560 // Handle click directly on an element, ignoring clicks on child nodes
 561 Ext.getBody().on('click', function(e,t){
 562     if((t.id == 'some-el') &amp;&amp; !e.within(t, true)){
 563         alert('Clicked directly on some-el!');
 564     }
 565 });
 566 &lt;/code&gt;&lt;/pre&gt;
 567      * @param {Mixed} el The id, DOM element or Ext.core.Element to check
 568      * @param {Boolean} related (optional) true to test if the related target is within el instead of the target
 569      * @param {Boolean} allowEl {optional} true to also check if the passed element is the target or related target
 570      * @return {Boolean}
 571      */
 572     within : function(el, related, allowEl){
 573         if(el){
 574             var t = related ? this.getRelatedTarget() : this.getTarget(),
 575                 result;
 576
 577             if (t) {
 578                 result = Ext.fly(el).contains(t);
 579                 if (!result &amp;&amp; allowEl) {
 580                     result = t == Ext.getDom(el);
 581                 }
 582                 return result;
 583             }
 584         }
 585         return false;
 586     },
 587
 588 <span id='Ext-EventObject-method-isNavKeyPress'>    /**
 589 </span>     * Checks if the key pressed was a &quot;navigation&quot; key
 590      * @return {Boolean} True if the press is a navigation keypress
 591      */
 592     isNavKeyPress : function(){
 593         var me = this,
 594             k = this.normalizeKey(me.keyCode);
 595
 596        return (k &gt;= 33 &amp;&amp; k &lt;= 40) ||  // Page Up/Down, End, Home, Left, Up, Right, Down
 597        k == me.RETURN ||
 598        k == me.TAB ||
 599        k == me.ESC;
 600     },
 601
 602 <span id='Ext-EventObject-method-isSpecialKey'>    /**
 603 </span>     * Checks if the key pressed was a &quot;special&quot; key
 604      * @return {Boolean} True if the press is a special keypress
 605      */
 606     isSpecialKey : function(){
 607         var k = this.normalizeKey(this.keyCode);
 608         return (this.type == 'keypress' &amp;&amp; this.ctrlKey) ||
 609         this.isNavKeyPress() ||
 610         (k == this.BACKSPACE) || // Backspace
 611         (k &gt;= 16 &amp;&amp; k &lt;= 20) || // Shift, Ctrl, Alt, Pause, Caps Lock
 612         (k &gt;= 44 &amp;&amp; k &lt;= 46);   // Print Screen, Insert, Delete
 613     },
 614
 615 <span id='Ext-EventObject-method-getPoint'>    /**
 616 </span>     * Returns a point object that consists of the object coordinates.
 617      * @return {Ext.util.Point} point
 618      */
 619     getPoint : function(){
 620         var xy = this.getXY();
 621         return Ext.create('Ext.util.Point', xy[0], xy[1]);
 622     },
 623
 624 <span id='Ext-EventObject-method-hasModifier'>   /**
 625 </span>    * Returns true if the control, meta, shift or alt key was pressed during this event.
 626     * @return {Boolean}
 627     */
 628     hasModifier : function(){
 629         return this.ctrlKey || this.altKey || this.shiftKey || this.metaKey;
 630     },
 631
 632 <span id='Ext-EventObject-method-injectEvent'>    /**
 633 </span>     * Injects a DOM event using the data in this object and (optionally) a new target.
 634      * This is a low-level technique and not likely to be used by application code. The
 635      * currently supported event types are:
 636      * &lt;p&gt;&lt;b&gt;HTMLEvents&lt;/b&gt;&lt;/p&gt;
 637      * &lt;ul&gt;
 638      * &lt;li&gt;load&lt;/li&gt;
 639      * &lt;li&gt;unload&lt;/li&gt;
 640      * &lt;li&gt;select&lt;/li&gt;
 641      * &lt;li&gt;change&lt;/li&gt;
 642      * &lt;li&gt;submit&lt;/li&gt;
 643      * &lt;li&gt;reset&lt;/li&gt;
 644      * &lt;li&gt;resize&lt;/li&gt;
 645      * &lt;li&gt;scroll&lt;/li&gt;
 646      * &lt;/ul&gt;
 647      * &lt;p&gt;&lt;b&gt;MouseEvents&lt;/b&gt;&lt;/p&gt;
 648      * &lt;ul&gt;
 649      * &lt;li&gt;click&lt;/li&gt;
 650      * &lt;li&gt;dblclick&lt;/li&gt;
 651      * &lt;li&gt;mousedown&lt;/li&gt;
 652      * &lt;li&gt;mouseup&lt;/li&gt;
 653      * &lt;li&gt;mouseover&lt;/li&gt;
 654      * &lt;li&gt;mousemove&lt;/li&gt;
 655      * &lt;li&gt;mouseout&lt;/li&gt;
 656      * &lt;/ul&gt;
 657      * &lt;p&gt;&lt;b&gt;UIEvents&lt;/b&gt;&lt;/p&gt;
 658      * &lt;ul&gt;
 659      * &lt;li&gt;focusin&lt;/li&gt;
 660      * &lt;li&gt;focusout&lt;/li&gt;
 661      * &lt;li&gt;activate&lt;/li&gt;
 662      * &lt;li&gt;focus&lt;/li&gt;
 663      * &lt;li&gt;blur&lt;/li&gt;
 664      * &lt;/ul&gt;
 665      * @param {Element/HTMLElement} target If specified, the target for the event. This
 666      * is likely to be used when relaying a DOM event. If not specified, {@link #getTarget}
 667      * is used to determine the target.
 668      */
 669     injectEvent: function () {
 670         var API,
 671             dispatchers = {}; // keyed by event type (e.g., 'mousedown')
 672
 673         // Good reference: http://developer.yahoo.com/yui/docs/UserAction.js.html
 674
 675         // IE9 has createEvent, but this code causes major problems with htmleditor (it
 676         // blocks all mouse events and maybe more). TODO
 677
 678         if (!Ext.isIE &amp;&amp; document.createEvent) { // if (DOM compliant)
 679             API = {
 680                 createHtmlEvent: function (doc, type, bubbles, cancelable) {
 681                     var event = doc.createEvent('HTMLEvents');
 682
 683                     event.initEvent(type, bubbles, cancelable);
 684                     return event;
 685                 },
 686
 687                 createMouseEvent: function (doc, type, bubbles, cancelable, detail,
 688                                             clientX, clientY, ctrlKey, altKey, shiftKey, metaKey,
 689                                             button, relatedTarget) {
 690                     var event = doc.createEvent('MouseEvents'),
 691                         view = doc.defaultView || window;
 692
 693                     if (event.initMouseEvent) {
 694                         event.initMouseEvent(type, bubbles, cancelable, view, detail,
 695                                     clientX, clientY, clientX, clientY, ctrlKey, altKey,
 696                                     shiftKey, metaKey, button, relatedTarget);
 697                     } else { // old Safari
 698                         event = doc.createEvent('UIEvents');
 699                         event.initEvent(type, bubbles, cancelable);
 700                         event.view = view;
 701                         event.detail = detail;
 702                         event.screenX = clientX;
 703                         event.screenY = clientY;
 704                         event.clientX = clientX;
 705                         event.clientY = clientY;
 706                         event.ctrlKey = ctrlKey;
 707                         event.altKey = altKey;
 708                         event.metaKey = metaKey;
 709                         event.shiftKey = shiftKey;
 710                         event.button = button;
 711                         event.relatedTarget = relatedTarget;
 712                     }
 713
 714                     return event;
 715                 },
 716
 717                 createUIEvent: function (doc, type, bubbles, cancelable, detail) {
 718                     var event = doc.createEvent('UIEvents'),
 719                         view = doc.defaultView || window;
 720
 721                     event.initUIEvent(type, bubbles, cancelable, view, detail);
 722                     return event;
 723                 },
 724
 725                 fireEvent: function (target, type, event) {
 726                     target.dispatchEvent(event);
 727                 },
 728
 729                 fixTarget: function (target) {
 730                     // Safari3 doesn't have window.dispatchEvent()
 731                     if (target == window &amp;&amp; !target.dispatchEvent) {
 732                         return document;
 733                     }
 734
 735                     return target;
 736                 }
 737             };
 738         } else if (document.createEventObject) { // else if (IE)
 739             var crazyIEButtons = { 0: 1, 1: 4, 2: 2 };
 740
 741             API = {
 742                 createHtmlEvent: function (doc, type, bubbles, cancelable) {
 743                     var event = doc.createEventObject();
 744                     event.bubbles = bubbles;
 745                     event.cancelable = cancelable;
 746                     return event;
 747                 },
 748
 749                 createMouseEvent: function (doc, type, bubbles, cancelable, detail,
 750                                             clientX, clientY, ctrlKey, altKey, shiftKey, metaKey,
 751                                             button, relatedTarget) {
 752                     var event = doc.createEventObject();
 753                     event.bubbles = bubbles;
 754                     event.cancelable = cancelable;
 755                     event.detail = detail;
 756                     event.screenX = clientX;
 757                     event.screenY = clientY;
 758                     event.clientX = clientX;
 759                     event.clientY = clientY;
 760                     event.ctrlKey = ctrlKey;
 761                     event.altKey = altKey;
 762                     event.shiftKey = shiftKey;
 763                     event.metaKey = metaKey;
 764                     event.button = crazyIEButtons[button] || button;
 765                     event.relatedTarget = relatedTarget; // cannot assign to/fromElement
 766                     return event;
 767                 },
 768
 769                 createUIEvent: function (doc, type, bubbles, cancelable, detail) {
 770                     var event = doc.createEventObject();
 771                     event.bubbles = bubbles;
 772                     event.cancelable = cancelable;
 773                     return event;
 774                 },
 775
 776                 fireEvent: function (target, type, event) {
 777                     target.fireEvent('on' + type, event);
 778                 },
 779
 780                 fixTarget: function (target) {
 781                     if (target == document) {
 782                         // IE6,IE7 thinks window==document and doesn't have window.fireEvent()
 783                         // IE6,IE7 cannot properly call document.fireEvent()
 784                         return document.documentElement;
 785                     }
 786
 787                     return target;
 788                 }
 789             };
 790         }
 791
 792         //----------------
 793         // HTMLEvents
 794
 795         Ext.Object.each({
 796                 load:   [false, false],
 797                 unload: [false, false],
 798                 select: [true, false],
 799                 change: [true, false],
 800                 submit: [true, true],
 801                 reset:  [true, false],
 802                 resize: [true, false],
 803                 scroll: [true, false]
 804             },
 805             function (name, value) {
 806                 var bubbles = value[0], cancelable = value[1];
 807                 dispatchers[name] = function (targetEl, srcEvent) {
 808                     var e = API.createHtmlEvent(name, bubbles, cancelable);
 809                     API.fireEvent(targetEl, name, e);
 810                 };
 811             });
 812
 813         //----------------
 814         // MouseEvents
 815
 816         function createMouseEventDispatcher (type, detail) {
 817             var cancelable = (type != 'mousemove');
 818             return function (targetEl, srcEvent) {
 819                 var xy = srcEvent.getXY(),
 820                     e = API.createMouseEvent(targetEl.ownerDocument, type, true, cancelable,
 821                                 detail, xy[0], xy[1], srcEvent.ctrlKey, srcEvent.altKey,
 822                                 srcEvent.shiftKey, srcEvent.metaKey, srcEvent.button,
 823                                 srcEvent.relatedTarget);
 824                 API.fireEvent(targetEl, type, e);
 825             };
 826         }
 827
 828         Ext.each(['click', 'dblclick', 'mousedown', 'mouseup', 'mouseover', 'mousemove', 'mouseout'],
 829             function (eventName) {
 830                 dispatchers[eventName] = createMouseEventDispatcher(eventName, 1);
 831             });
 832
 833         //----------------
 834         // UIEvents
 835
 836         Ext.Object.each({
 837                 focusin:  [true, false],
 838                 focusout: [true, false],
 839                 activate: [true, true],
 840                 focus:    [false, false],
 841                 blur:     [false, false]
 842             },
 843             function (name, value) {
 844                 var bubbles = value[0], cancelable = value[1];
 845                 dispatchers[name] = function (targetEl, srcEvent) {
 846                     var e = API.createUIEvent(targetEl.ownerDocument, name, bubbles, cancelable, 1);
 847                     API.fireEvent(targetEl, name, e);
 848                 };
 849             });
 850
 851         //---------
 852         if (!API) {
 853             // not even sure what ancient browsers fall into this category...
 854
 855             dispatchers = {}; // never mind all those we just built :P
 856
 857             API = {
 858                 fixTarget: function (t) {
 859                     return t;
 860                 }
 861             };
 862         }
 863
 864         function cannotInject (target, srcEvent) {
 865             //&lt;debug&gt;
 866             // TODO log something
 867             //&lt;/debug&gt;
 868         }
 869
 870         return function (target) {
 871             var me = this,
 872                 dispatcher = dispatchers[me.type] || cannotInject,
 873                 t = target ? (target.dom || target) : me.getTarget();
 874
 875             t = API.fixTarget(t);
 876             dispatcher(t, me);
 877         };
 878     }() // call to produce method
 879
 880 }, function() {
 881
 882 Ext.EventObject = new Ext.EventObjectImpl();
 883
 884 });
 885
 886 </pre>
 887 </body>
 888 </html>