Upgrade to ExtJS 4.0.2 - Released 06/09/2011
[extjs.git] / 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>