开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Java编程 > JavaScript > 查看源码
EventManager.js
资源名称：ext-3.1.0.zip　[点击查看]
上传用户：dawnssy
上传日期：2022-08-06
资源大小：9345k
文件大小：30k
源码类别：

JavaScript

开发平台：

JavaScript

EventManager.js：源码内容
  1. /*!  * Ext JS Library 3.1.0  * Copyright(c) 2006-2009 Ext JS, LLC  * licensing@extjs.com  * http://www.extjs.com/license  */ /**
  2.  * @class Ext.EventManager
  3.  * Registers event handlers that want to receive a normalized EventObject instead of the standard browser event and provides
  4.  * several useful events directly.
  5.  * See {@link Ext.EventObject} for more details on normalized event objects.
  6.  * @singleton
  7.  */
  8. Ext.EventManager = function(){
  9.     var docReadyEvent,
  10.         docReadyProcId,
  11.         docReadyState = false,
  12.         E = Ext.lib.Event,
  13.         D = Ext.lib.Dom,
  14.         DOC = document,
  15.         WINDOW = window,
  16.         IEDEFERED = "ie-deferred-loader",
  17.         DOMCONTENTLOADED = "DOMContentLoaded",
  18.         propRe = /^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate)$/,
  19.         /*
  20.          * This cache is used to hold special js objects, the document and window, that don't have an id. We need to keep
  21.          * a reference to them so we can look them up at a later point.
  22.          */
  23.         specialElCache = [];
  25.      function getId(el){
  26.         var id = false,
  27.             i = 0,
  28.             len = specialElCache.length,
  29.             id = false,
  30.             skip = false,
  31.             o;
  32.         if(el){
  33.             if(el.getElementById || el.navigator){
  34.                 // look up the id
  35.                 for(; i < len; ++i){
  36.                     o = specialElCache[i];
  37.                     if(o.el === el){
  38.                         id = o.id;
  39.                         break;
  40.                     }
  41.                 }
  42.                 if(!id){
  43.                     // for browsers that support it, ensure that give the el the same id
  44.                     id = Ext.id(el);
  45.                     specialElCache.push({
  46.                         id: id,
  47.                         el: el
  48.                     });
  49.                     skip = true;
  50.                 }
  51.             }else{
  52.                 id = Ext.id(el);
  53.             }
  54.             if(!Ext.elCache[id]){
  55.                 Ext.Element.addToCache(new Ext.Element(el), id);
  56.                 if(skip){
  57.                     Ext.elCache[id].skipGC = true;
  58.                 }
  59.             }
  60.         }
  61.         return id;
  62.      };
  64.     /// There is some jquery work around stuff here that isn't needed in Ext Core.
  65.     function addListener(el, ename, fn, wrap, scope){
  66.         el = Ext.getDom(el);
  67.         var id = getId(el),
  68.             es = Ext.elCache[id].events,
  69.             wfn;
  71.         wfn = E.on(el, ename, wrap);
  72.         es[ename] = es[ename] || [];
  73.         es[ename].push([fn, wrap, scope, wfn]);
  75.         // this is a workaround for jQuery and should somehow be removed from Ext Core in the future
  76.         // without breaking ExtJS.
  77.         if(ename == "mousewheel" && el.addEventListener){ // workaround for jQuery
  78.             var args = ["DOMMouseScroll", wrap, false];
  79.             el.addEventListener.apply(el, args);
  80.             Ext.EventManager.addListener(WINDOW, 'unload', function(){
  81.                 el.removeEventListener.apply(el, args);
  82.             });
  83.         }
  84.         if(ename == "mousedown" && el == document){ // fix stopped mousedowns on the document
  85.             Ext.EventManager.stoppedMouseDownEvent.addListener(wrap);
  86.         }
  87.     };
  89.     function fireDocReady(){
  90.         if(!docReadyState){
  91.             Ext.isReady = docReadyState = true;
  92.             if(docReadyProcId){
  93.                 clearInterval(docReadyProcId);
  94.             }
  95.             if(Ext.isGecko || Ext.isOpera) {
  96.                 DOC.removeEventListener(DOMCONTENTLOADED, fireDocReady, false);
  97.             }
  98.             if(Ext.isIE){
  99.                 var defer = DOC.getElementById(IEDEFERED);
  100.                 if(defer){
  101.                     defer.onreadystatechange = null;
  102.                     defer.parentNode.removeChild(defer);
  103.                 }
  104.             }
  105.             if(docReadyEvent){
  106.                 docReadyEvent.fire();
  107.                 docReadyEvent.listeners = []; // clearListeners no longer compatible.  Force single: true?
  108.             }
  109.         }
  110.     };
  112.     function initDocReady(){
  113.         var COMPLETE = "complete";
  115.         docReadyEvent = new Ext.util.Event();
  116.         if (Ext.isGecko || Ext.isOpera) {
  117.             DOC.addEventListener(DOMCONTENTLOADED, fireDocReady, false);
  118.         } else if (Ext.isIE){
  119.             DOC.write("<s"+'cript id=' + IEDEFERED + ' defer="defer" src="/'+'/:"></s'+"cript>");
  120.             DOC.getElementById(IEDEFERED).onreadystatechange = function(){
  121.                 if(this.readyState == COMPLETE){
  122.                     fireDocReady();
  123.                 }
  124.             };
  125.         } else if (Ext.isWebKit){
  126.             docReadyProcId = setInterval(function(){
  127.                 if(DOC.readyState == COMPLETE) {
  128.                     fireDocReady();
  129.                  }
  130.             }, 10);
  131.         }
  132.         // no matter what, make sure it fires on load
  133.         E.on(WINDOW, "load", fireDocReady);
  134.     };
  136.     function createTargeted(h, o){
  137.         return function(){
  138.             var args = Ext.toArray(arguments);
  139.             if(o.target == Ext.EventObject.setEvent(args[0]).target){
  140.                 h.apply(this, args);
  141.             }
  142.         };
  143.     };
  145.     function createBuffered(h, o, fn){
  146.         fn.task = new Ext.util.DelayedTask(h);
  147.         var w = function(e){
  148.             // create new event object impl so new events don't wipe out properties
  149.             fn.task.delay(o.buffer, h, null, [new Ext.EventObjectImpl(e)]);
  150.         };
  151.         return w;
  152.     };
  154.     function createSingle(h, el, ename, fn, scope){
  155.         return function(e){
  156.             Ext.EventManager.removeListener(el, ename, fn, scope);
  157.             h(e);
  158.         };
  159.     };
  161.     function createDelayed(h, o, fn){
  162.         return function(e){
  163.             var task = new Ext.util.DelayedTask(h);
  164.             if(!fn.tasks) {
  165.                 fn.tasks = [];
  166.             }
  167.             fn.tasks.push(task);
  168.             task.delay(o.delay || 10, h, null, [new Ext.EventObjectImpl(e)]);
  169.         };
  170.     };
  172.     function listen(element, ename, opt, fn, scope){
  173.         var o = !Ext.isObject(opt) ? {} : opt,
  174.             el = Ext.getDom(element);
  176.         fn = fn || o.fn;
  177.         scope = scope || o.scope;
  179.         if(!el){
  180.             throw "Error listening for "" + ename + '". Element "' + element + '" doesn't exist.';
  181.         }
  182.         function h(e){
  183.             // prevent errors while unload occurring
  184.             if(!Ext){// !window[xname]){  ==> can't we do this?
  185.                 return;
  186.             }
  187.             e = Ext.EventObject.setEvent(e);
  188.             var t;
  189.             if (o.delegate) {
  190.                 if(!(t = e.getTarget(o.delegate, el))){
  191.                     return;
  192.                 }
  193.             } else {
  194.                 t = e.target;
  195.             }
  196.             if (o.stopEvent) {
  197.                 e.stopEvent();
  198.             }
  199.             if (o.preventDefault) {
  200.                e.preventDefault();
  201.             }
  202.             if (o.stopPropagation) {
  203.                 e.stopPropagation();
  204.             }
  205.             if (o.normalized) {
  206.                 e = e.browserEvent;
  207.             }
  209.             fn.call(scope || el, e, t, o);
  210.         };
  211.         if(o.target){
  212.             h = createTargeted(h, o);
  213.         }
  214.         if(o.delay){
  215.             h = createDelayed(h, o, fn);
  216.         }
  217.         if(o.single){
  218.             h = createSingle(h, el, ename, fn, scope);
  219.         }
  220.         if(o.buffer){
  221.             h = createBuffered(h, o, fn);
  222.         }
  224.         addListener(el, ename, fn, h, scope);
  225.         return h;
  226.     };
  228.     var pub = {
  229.         /**
  230.          * Appends an event handler to an element.  The shorthand version {@link #on} is equivalent.  Typically you will
  231.          * use {@link Ext.Element#addListener} directly on an Element in favor of calling this version.
  232.          * @param {String/HTMLElement} el The html element or id to assign the event handler to.
  233.          * @param {String} eventName The name of the event to listen for.
  234.          * @param {Function} handler The handler function the event invokes. This function is passed
  235.          * the following parameters:<ul>
  236.          * <li>evt : EventObject<div class="sub-desc">The {@link Ext.EventObject EventObject} describing the event.</div></li>
  237.          * <li>t : Element<div class="sub-desc">The {@link Ext.Element Element} which was the target of the event.
  238.          * Note that this may be filtered by using the <tt>delegate</tt> option.</div></li>
  239.          * <li>o : Object<div class="sub-desc">The options object from the addListener call.</div></li>
  240.          * </ul>
  241.          * @param {Object} scope (optional) The scope (<b><code>this</code></b> reference) in which the handler function is executed. <b>Defaults to the Element</b>.
  242.          * @param {Object} options (optional) An object containing handler configuration properties.
  243.          * This may contain any of the following properties:<ul>
  244.          * <li>scope : Object<div class="sub-desc">The scope (<b><code>this</code></b> reference) in which the handler function is executed. <b>Defaults to the Element</b>.</div></li>
  245.          * <li>delegate : String<div class="sub-desc">A simple selector to filter the target or look for a descendant of the target</div></li>
  246.          * <li>stopEvent : Boolean<div class="sub-desc">True to stop the event. That is stop propagation, and prevent the default action.</div></li>
  247.          * <li>preventDefault : Boolean<div class="sub-desc">True to prevent the default action</div></li>
  248.          * <li>stopPropagation : Boolean<div class="sub-desc">True to prevent event propagation</div></li>
  249.          * <li>normalized : Boolean<div class="sub-desc">False to pass a browser event to the handler function instead of an Ext.EventObject</div></li>
  250.          * <li>delay : Number<div class="sub-desc">The number of milliseconds to delay the invocation of the handler after te event fires.</div></li>
  251.          * <li>single : Boolean<div class="sub-desc">True to add a handler to handle just the next firing of the event, and then remove itself.</div></li>
  252.          * <li>buffer : Number<div class="sub-desc">Causes the handler to be scheduled to run in an {@link Ext.util.DelayedTask} delayed
  253.          * by the specified number of milliseconds. If the event fires again within that time, the original
  254.          * handler is <em>not</em> invoked, but the new handler is scheduled in its place.</div></li>
  255.          * <li>target : Element<div class="sub-desc">Only call the handler if the event was fired on the target Element, <i>not</i> if the event was bubbled up from a child node.</div></li>
  256.          * </ul><br>
  257.          * <p>See {@link Ext.Element#addListener} for examples of how to use these options.</p>
  258.          */
  259.         addListener : function(element, eventName, fn, scope, options){
  260.             if(Ext.isObject(eventName)){
  261.                 var o = eventName, e, val;
  262.                 for(e in o){
  263.                     val = o[e];
  264.                     if(!propRe.test(e)){
  265.                         if(Ext.isFunction(val)){
  266.                             // shared options
  267.                             listen(element, e, o, val, o.scope);
  268.                         }else{
  269.                             // individual options
  270.                             listen(element, e, val);
  271.                         }
  272.                     }
  273.                 }
  274.             } else {
  275.                 listen(element, eventName, options, fn, scope);
  276.             }
  277.         },
  279.         /**
  280.          * Removes an event handler from an element.  The shorthand version {@link #un} is equivalent.  Typically
  281.          * you will use {@link Ext.Element#removeListener} directly on an Element in favor of calling this version.
  282.          * @param {String/HTMLElement} el The id or html element from which to remove the listener.
  283.          * @param {String} eventName The name of the event.
  284.          * @param {Function} fn The handler function to remove. <b>This must be a reference to the function passed into the {@link #addListener} call.</b>
  285.          * @param {Object} scope If a scope (<b><code>this</code></b> reference) was specified when the listener was added,
  286.          * then this must refer to the same object.
  287.          */
  288.         removeListener : function(el, eventName, fn, scope){
  289.             el = Ext.getDom(el);
  290.             var id = getId(el),
  291.                 f = el && (Ext.elCache[id].events)[eventName] || [],
  292.                 wrap, i, l, k, wf;
  294.             for (i = 0, len = f.length; i < len; i++) {
  295.                 if (Ext.isArray(f[i]) && f[i][0] == fn && (!scope || f[i][2] == scope)) {
  296.                     if(fn.task) {
  297.                         fn.task.cancel();
  298.                         delete fn.task;
  299.                     }
  300.                     k = fn.tasks && fn.tasks.length;
  301.                     if(k) {
  302.                         while(k--) {
  303.                             fn.tasks[k].cancel();
  304.                         }
  305.                         delete fn.tasks;
  306.                     }
  307.                     wf = wrap = f[i][1];
  308.                     if (E.extAdapter) {
  309.                         wf = f[i][3];
  310.                     }
  311.                     E.un(el, eventName, wf);
  312.                     f.splice(i,1);
  313.                     if (f.length === 0) {
  314.                         delete Ext.elCache[id].events[eventName];
  315.                     }
  316.                     for (k in Ext.elCache[id].events) {
  317.                         return false;
  318.                     }
  319.                     Ext.elCache[id].events = {};
  320.                     return false;
  321.                 }
  322.             }
  324.             // jQuery workaround that should be removed from Ext Core
  325.             if(eventName == "mousewheel" && el.addEventListener && wrap){
  326.                 el.removeEventListener("DOMMouseScroll", wrap, false);
  327.             }
  329.             if(eventName == "mousedown" && el == DOC && wrap){ // fix stopped mousedowns on the document
  330.                 Ext.EventManager.stoppedMouseDownEvent.removeListener(wrap);
  331.             }
  332.         },
  334.         /**
  335.          * Removes all event handers from an element.  Typically you will use {@link Ext.Element#removeAllListeners}
  336.          * directly on an Element in favor of calling this version.
  337.          * @param {String/HTMLElement} el The id or html element from which to remove all event handlers.
  338.          */
  339.         removeAll : function(el){
  340.             el = Ext.getDom(el);
  341.             var id = getId(el),
  342.                 ec = Ext.elCache[id] || {},
  343.                 es = ec.events || {},
  344.                 f, i, len, ename, fn, k;
  346.             for(ename in es){
  347.                 if(es.hasOwnProperty(ename)){
  348.                     f = es[ename];
  349.                     for (i = 0, len = f.length; i < len; i++) {
  350.                         fn = f[i][0];
  351.                         if(fn.task) {
  352.                             fn.task.cancel();
  353.                             delete fn.task;
  354.                         }
  355.                         if(fn.tasks && (k = fn.tasks.length)) {
  356.                             while(k--) {
  357.                                 fn.tasks[k].cancel();
  358.                             }
  359.                             delete fn.tasks;
  360.                         }
  361.                         E.un(el, ename, E.extAdapter ? f[i][3] : f[i][1]);
  362.                     }
  363.                 }
  364.             }
  365.             if (Ext.elCache[id]) {
  366.                 Ext.elCache[id].events = {};
  367.             }
  368.         },
  370.         getListeners : function(el, eventName) {
  371.             el = Ext.getDom(el);
  372.             var id = getId(el),
  373.                 ec = Ext.elCache[id] || {},
  374.                 es = ec.events || {},
  375.                 results = [];
  376.             if (es && es[eventName]) {
  377.                 return es[eventName];
  378.             } else {
  379.                 return null;
  380.             }
  381.         },
  383.         purgeElement : function(el, recurse, eventName) {
  384.             el = Ext.getDom(el);
  385.             var id = getId(el),
  386.                 ec = Ext.elCache[id] || {},
  387.                 es = ec.events || {},
  388.                 i, f, len;
  389.             if (eventName) {
  390.                 if (es && es.hasOwnProperty(eventName)) {
  391.                     f = es[eventName];
  392.                     for (i = 0, len = f.length; i < len; i++) {
  393.                         Ext.EventManager.removeListener(el, eventName, f[i][0]);
  394.                     }
  395.                 }
  396.             } else {
  397.                 Ext.EventManager.removeAll(el);
  398.             }
  399.             if (recurse && el && el.childNodes) {
  400.                 for (i = 0, len = el.childNodes.length; i < len; i++) {
  401.                     Ext.EventManager.purgeElement(el.childNodes[i], recurse, eventName);
  402.                 }
  403.             }
  404.         },
  406.         _unload : function() {
  407.             var el;
  408.             for (el in Ext.elCache) {
  409.                 Ext.EventManager.removeAll(el);
  410.             }
  411.         },
  412.         /**
  413.          * Adds a listener to be notified when the document is ready (before onload and before images are loaded). Can be
  414.          * accessed shorthanded as Ext.onReady().
  415.          * @param {Function} fn The method the event invokes.
  416.          * @param {Object} scope (optional) The scope (<code>this</code> reference) in which the handler function executes. Defaults to the browser window.
  417.          * @param {boolean} options (optional) Options object as passed to {@link Ext.Element#addListener}. It is recommended that the options
  418.          * <code>{single: true}</code> be used so that the handler is removed on first invocation.
  419.          */
  420.         onDocumentReady : function(fn, scope, options){
  421.             if(docReadyState){ // if it already fired
  422.                 docReadyEvent.addListener(fn, scope, options);
  423.                 docReadyEvent.fire();
  424.                 docReadyEvent.listeners = []; // clearListeners no longer compatible.  Force single: true?
  425.             } else {
  426.                 if(!docReadyEvent) initDocReady();
  427.                 options = options || {};
  428.                 options.delay = options.delay || 1;
  429.                 docReadyEvent.addListener(fn, scope, options);
  430.             }
  431.         }
  432.     };
  433.      /**
  434.      * Appends an event handler to an element.  Shorthand for {@link #addListener}.
  435.      * @param {String/HTMLElement} el The html element or id to assign the event handler to
  436.      * @param {String} eventName The name of the event to listen for.
  437.      * @param {Function} handler The handler function the event invokes.
  438.      * @param {Object} scope (optional) (<code>this</code> reference) in which the handler function executes. <b>Defaults to the Element</b>.
  439.      * @param {Object} options (optional) An object containing standard {@link #addListener} options
  440.      * @member Ext.EventManager
  441.      * @method on
  442.      */
  443.     pub.on = pub.addListener;
  444.     /**
  445.      * Removes an event handler from an element.  Shorthand for {@link #removeListener}.
  446.      * @param {String/HTMLElement} el The id or html element from which to remove the listener.
  447.      * @param {String} eventName The name of the event.
  448.      * @param {Function} fn The handler function to remove. <b>This must be a reference to the function passed into the {@link #on} call.</b>
  449.      * @param {Object} scope If a scope (<b><code>this</code></b> reference) was specified when the listener was added,
  450.      * then this must refer to the same object.
  451.      * @member Ext.EventManager
  452.      * @method un
  453.      */
  454.     pub.un = pub.removeListener;
  456.     pub.stoppedMouseDownEvent = new Ext.util.Event();
  457.     return pub;
  458. }();
  459. /**
  460.   * Adds a listener to be notified when the document is ready (before onload and before images are loaded). Shorthand of {@link Ext.EventManager#onDocumentReady}.
  461.   * @param {Function} fn The method the event invokes.
  462.   * @param {Object} scope (optional) The scope (<code>this</code> reference) in which the handler function executes. Defaults to the browser window.
  463.   * @param {boolean} options (optional) Options object as passed to {@link Ext.Element#addListener}. It is recommended that the options
  464.   * <code>{single: true}</code> be used so that the handler is removed on first invocation.
  465.   * @member Ext
  466.   * @method onReady
  467.  */
  468. Ext.onReady = Ext.EventManager.onDocumentReady;
  471. //Initialize doc classes
  472. (function(){
  474.     var initExtCss = function(){
  475.         // find the body element
  476.         var bd = document.body || document.getElementsByTagName('body')[0];
  477.         if(!bd){ return false; }
  478.         var cls = [' ',
  479.                 Ext.isIE ? "ext-ie " + (Ext.isIE6 ? 'ext-ie6' : (Ext.isIE7 ? 'ext-ie7' : 'ext-ie8'))
  480.                 : Ext.isGecko ? "ext-gecko " + (Ext.isGecko2 ? 'ext-gecko2' : 'ext-gecko3')
  481.                 : Ext.isOpera ? "ext-opera"
  482.                 : Ext.isWebKit ? "ext-webkit" : ""];
  484.         if(Ext.isSafari){
  485.             cls.push("ext-safari " + (Ext.isSafari2 ? 'ext-safari2' : (Ext.isSafari3 ? 'ext-safari3' : 'ext-safari4')));
  486.         }else if(Ext.isChrome){
  487.             cls.push("ext-chrome");
  488.         }
  490.         if(Ext.isMac){
  491.             cls.push("ext-mac");
  492.         }
  493.         if(Ext.isLinux){
  494.             cls.push("ext-linux");
  495.         }
  497.         if(Ext.isStrict || Ext.isBorderBox){ // add to the parent to allow for selectors like ".ext-strict .ext-ie"
  498.             var p = bd.parentNode;
  499.             if(p){
  500.                 p.className += Ext.isStrict ? ' ext-strict' : ' ext-border-box';
  501.             }
  502.         }
  503.         bd.className += cls.join(' ');
  504.         return true;
  505.     }
  507.     if(!initExtCss()){
  508.         Ext.onReady(initExtCss);
  509.     }
  510. })();
  513. /**
  514.  * @class Ext.EventObject
  515.  * Just as {@link Ext.Element} wraps around a native DOM node, Ext.EventObject
  516.  * wraps the browser's native event-object normalizing cross-browser differences,
  517.  * such as which mouse button is clicked, keys pressed, mechanisms to stop
  518.  * event-propagation along with a method to prevent default actions from taking place.
  519.  * <p>For example:</p>
  520.  * <pre><code>
  521. function handleClick(e, t){ // e is not a standard event object, it is a Ext.EventObject
  522.     e.preventDefault();
  523.     var target = e.getTarget(); // same as t (the target HTMLElement)
  524.     ...
  525. }
  526. var myDiv = {@link Ext#get Ext.get}("myDiv");  // get reference to an {@link Ext.Element}
  527. myDiv.on(         // 'on' is shorthand for addListener
  528.     "click",      // perform an action on click of myDiv
  529.     handleClick   // reference to the action handler
  530. );
  531. // other methods to do the same:
  532. Ext.EventManager.on("myDiv", 'click', handleClick);
  533. Ext.EventManager.addListener("myDiv", 'click', handleClick);
  534.  </code></pre>
  535.  * @singleton
  536.  */
  537. Ext.EventObject = function(){
  538.     var E = Ext.lib.Event,
  539.         // safari keypress events for special keys return bad keycodes
  540.         safariKeys = {
  541.             3 : 13, // enter
  542.             63234 : 37, // left
  543.             63235 : 39, // right
  544.             63232 : 38, // up
  545.             63233 : 40, // down
  546.             63276 : 33, // page up
  547.             63277 : 34, // page down
  548.             63272 : 46, // delete
  549.             63273 : 36, // home
  550.             63275 : 35  // end
  551.         },
  552.         // normalize button clicks
  553.         btnMap = Ext.isIE ? {1:0,4:1,2:2} :
  554.                 (Ext.isWebKit ? {1:0,2:1,3:2} : {0:0,1:1,2:2});
  556.     Ext.EventObjectImpl = function(e){
  557.         if(e){
  558.             this.setEvent(e.browserEvent || e);
  559.         }
  560.     };
  562.     Ext.EventObjectImpl.prototype = {
  563.            /** @private */
  564.         setEvent : function(e){
  565.             var me = this;
  566.             if(e == me || (e && e.browserEvent)){ // already wrapped
  567.                 return e;
  568.             }
  569.             me.browserEvent = e;
  570.             if(e){
  571.                 // normalize buttons
  572.                 me.button = e.button ? btnMap[e.button] : (e.which ? e.which - 1 : -1);
  573.                 if(e.type == 'click' && me.button == -1){
  574.                     me.button = 0;
  575.                 }
  576.                 me.type = e.type;
  577.                 me.shiftKey = e.shiftKey;
  578.                 // mac metaKey behaves like ctrlKey
  579.                 me.ctrlKey = e.ctrlKey || e.metaKey || false;
  580.                 me.altKey = e.altKey;
  581.                 // in getKey these will be normalized for the mac
  582.                 me.keyCode = e.keyCode;
  583.                 me.charCode = e.charCode;
  584.                 // cache the target for the delayed and or buffered events
  585.                 me.target = E.getTarget(e);
  586.                 // same for XY
  587.                 me.xy = E.getXY(e);
  588.             }else{
  589.                 me.button = -1;
  590.                 me.shiftKey = false;
  591.                 me.ctrlKey = false;
  592.                 me.altKey = false;
  593.                 me.keyCode = 0;
  594.                 me.charCode = 0;
  595.                 me.target = null;
  596.                 me.xy = [0, 0];
  597.             }
  598.             return me;
  599.         },
  601.         /**
  602.          * Stop the event (preventDefault and stopPropagation)
  603.          */
  604.         stopEvent : function(){
  605.             var me = this;
  606.             if(me.browserEvent){
  607.                 if(me.browserEvent.type == 'mousedown'){
  608.                     Ext.EventManager.stoppedMouseDownEvent.fire(me);
  609.                 }
  610.                 E.stopEvent(me.browserEvent);
  611.             }
  612.         },
  614.         /**
  615.          * Prevents the browsers default handling of the event.
  616.          */
  617.         preventDefault : function(){
  618.             if(this.browserEvent){
  619.                 E.preventDefault(this.browserEvent);
  620.             }
  621.         },
  623.         /**
  624.          * Cancels bubbling of the event.
  625.          */
  626.         stopPropagation : function(){
  627.             var me = this;
  628.             if(me.browserEvent){
  629.                 if(me.browserEvent.type == 'mousedown'){
  630.                     Ext.EventManager.stoppedMouseDownEvent.fire(me);
  631.                 }
  632.                 E.stopPropagation(me.browserEvent);
  633.             }
  634.         },
  636.         /**
  637.          * Gets the character code for the event.
  638.          * @return {Number}
  639.          */
  640.         getCharCode : function(){
  641.             return this.charCode || this.keyCode;
  642.         },
  644.         /**
  645.          * Returns a normalized keyCode for the event.
  646.          * @return {Number} The key code
  647.          */
  648.         getKey : function(){
  649.             return this.normalizeKey(this.keyCode || this.charCode)
  650.         },
  652.         // private
  653.         normalizeKey: function(k){
  654.             return Ext.isSafari ? (safariKeys[k] || k) : k;
  655.         },
  657.         /**
  658.          * Gets the x coordinate of the event.
  659.          * @return {Number}
  660.          */
  661.         getPageX : function(){
  662.             return this.xy[0];
  663.         },
  665.         /**
  666.          * Gets the y coordinate of the event.
  667.          * @return {Number}
  668.          */
  669.         getPageY : function(){
  670.             return this.xy[1];
  671.         },
  673.         /**
  674.          * Gets the page coordinates of the event.
  675.          * @return {Array} The xy values like [x, y]
  676.          */
  677.         getXY : function(){
  678.             return this.xy;
  679.         },
  681.         /**
  682.          * Gets the target for the event.
  683.          * @param {String} selector (optional) A simple selector to filter the target or look for an ancestor of the target
  684.          * @param {Number/Mixed} maxDepth (optional) The max depth to
  685.                 search as a number or element (defaults to 10 || document.body)
  686.          * @param {Boolean} returnEl (optional) True to return a Ext.Element object instead of DOM node
  687.          * @return {HTMLelement}
  688.          */
  689.         getTarget : function(selector, maxDepth, returnEl){
  690.             return selector ? Ext.fly(this.target).findParent(selector, maxDepth, returnEl) : (returnEl ? Ext.get(this.target) : this.target);
  691.         },
  693.         /**
  694.          * Gets the related target.
  695.          * @return {HTMLElement}
  696.          */
  697.         getRelatedTarget : function(){
  698.             return this.browserEvent ? E.getRelatedTarget(this.browserEvent) : null;
  699.         },
  701.         /**
  702.          * Normalizes mouse wheel delta across browsers
  703.          * @return {Number} The delta
  704.          */
  705.         getWheelDelta : function(){
  706.             var e = this.browserEvent;
  707.             var delta = 0;
  708.             if(e.wheelDelta){ /* IE/Opera. */
  709.                 delta = e.wheelDelta/120;
  710.             }else if(e.detail){ /* Mozilla case. */
  711.                 delta = -e.detail/3;
  712.             }
  713.             return delta;
  714.         },
  716.         /**
  717.         * 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.
  718.         * Example usage:<pre><code>
  719.         // Handle click on any child of an element
  720.         Ext.getBody().on('click', function(e){
  721.             if(e.within('some-el')){
  722.                 alert('Clicked on a child of some-el!');
  723.             }
  724.         });
  726.         // Handle click directly on an element, ignoring clicks on child nodes
  727.         Ext.getBody().on('click', function(e,t){
  728.             if((t.id == 'some-el') && !e.within(t, true)){
  729.                 alert('Clicked directly on some-el!');
  730.             }
  731.         });
  732.         </code></pre>
  733.          * @param {Mixed} el The id, DOM element or Ext.Element to check
  734.          * @param {Boolean} related (optional) true to test if the related target is within el instead of the target
  735.          * @param {Boolean} allowEl {optional} true to also check if the passed element is the target or related target
  736.          * @return {Boolean}
  737.          */
  738.         within : function(el, related, allowEl){
  739.             if(el){
  740.                 var t = this[related ? "getRelatedTarget" : "getTarget"]();
  741.                 return t && ((allowEl ? (t == Ext.getDom(el)) : false) || Ext.fly(el).contains(t));
  742.             }
  743.             return false;
  744.         }
  745.      };
  747.     return new Ext.EventObjectImpl();
  748. }();