    /**
     * @class Ext.EventManager
     * Registers event handlers that want to receive a normalized EventObject instead of the standard browser event and provides
     * several useful events directly.
     * See {@link Ext.EventObject} for more details on normalized event objects.
     * @singleton
     */
    Ext.EventManager = {

        // --------------------- onReady ---------------------

        /**
         * Check if we have bound our global onReady listener
         * @private
         */
        hasBoundOnReady: false,

        /**
         * Check if fireDocReady has been called
         * @private
         */
        hasFiredReady: false,

        /**
         * Timer for the document ready event in old IE versions
         * @private
         */
        readyTimeout: null,

        /**
         * Checks if we have bound an onreadystatechange event
         * @private
         */
        hasOnReadyStateChange: false,

        /**
         * Holds references to any onReady functions
         * @private
         */
        readyEvent: new Ext.util.Event(),

        /**
         * Check the ready state for old IE versions
         * @private
         * @return {Boolean} True if the document is ready
         */
        checkReadyState: function(){
            var me = Ext.EventManager;

            if(window.attachEvent){
                // See here for reference: http://javascript.nwbox.com/IEContentLoaded/
                if (window != top) {
                    return false;
                }
                try{
                    document.documentElement.doScroll('left');
                }catch(e){
                    return false;
                }
                me.fireDocReady();
                return true;
            }
            if (document.readyState == 'complete') {
                me.fireDocReady();
                return true;
            }
            me.readyTimeout = setTimeout(arguments.callee, 2);
            return false;
        },

        /**
         * Binds the appropriate browser event for checking if the DOM has loaded.
         * @private
         */
        bindReadyEvent: function(){
            var me = Ext.EventManager;
            if (me.hasBoundOnReady) {
                return;
            }

            if (document.addEventListener) {
                document.addEventListener('DOMContentLoaded', me.fireDocReady, false);
                // fallback, load will ~always~ fire
                window.addEventListener('load', me.fireDocReady, false);
            } else {
                // check if the document is ready, this will also kick off the scroll checking timer
                if (!me.checkReadyState()) {
                    document.attachEvent('onreadystatechange', me.checkReadyState);
                    me.hasOnReadyStateChange = true;
                }
                // fallback, onload will ~always~ fire
                window.attachEvent('onload', me.fireDocReady, false);
            }
            me.hasBoundOnReady = true;
        },

        /**
         * We know the document is loaded, so trigger any onReady events.
         * @private
         */
        fireDocReady: function(){
            var me = Ext.EventManager;

            // only unbind these events once
            if (!me.hasFiredReady) {
                me.hasFiredReady = true;

                if (document.addEventListener) {
                    document.removeEventListener('DOMContentLoaded', me.fireDocReady, false);
                    window.removeEventListener('load', me.fireDocReady, false);
                } else {
                    if (me.readyTimeout !== null) {
                        clearTimeout(me.readyTimeout);
                    }
                    if (me.hasOnReadyStateChange) {
                        document.detachEvent('onreadystatechange', me.checkReadyState);
                    }
                    window.detachEvent('onload', me.fireDocReady);
                }
                Ext.supports.init();
            }
            if (!Ext.isReady) {
                Ext.isReady = true;
                me.onWindowUnload();
                me.readyEvent.fire();
            }
        },

        /**
         * Adds a listener to be notified when the document is ready (before onload and before images are loaded). Can be
         * accessed shorthanded as Ext.onReady().
         * @param {Function} fn The method the event invokes.
         * @param {Object} scope (optional) The scope (<code>this</code> reference) in which the handler function executes. Defaults to the browser window.
         * @param {boolean} options (optional) Options object as passed to {@link Ext.core.Element#addListener}.
         */
        onDocumentReady: function(fn, scope, options){
            options = options || {};
            var me = Ext.EventManager,
                readyEvent = me.readyEvent;

            // force single to be true so our event is only ever fired once.
            options.single = true;

            // Document already loaded, let's just fire it
            if (Ext.isReady) {
                readyEvent.addListener(fn, scope, options);
                readyEvent.fire();
            } else {
                options.delay = options.delay || 1;
                readyEvent.addListener(fn, scope, options);
                me.bindReadyEvent();
            }
        },

        // --------------------- event binding ---------------------

        /**
         * Contains a list of all document mouse downs, so we can ensure they fire even when stopEvent is called.
         * @private
         */
        stoppedMouseDownEvent: new Ext.util.Event(),

        /**
         * Options to parse for the 4th argument to addListener.
         * @private
         */
        propRe: /^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate|freezeEvent)$/,

        /**
         * Get the id of the element. If one has not been assigned, automatically assign it.
         * @param {Mixed} element The element to get the id for.
         * @return {String} id
         */
        getId : function(element) {
            var skipGarbageCollection = false,
                id;

            element = Ext.getDom(element);

            if (element === document || element === window) {
                id = element === document ? Ext.documentId : Ext.windowId;
            }
            else {
                id = Ext.id(element);
            }
            // skip garbage collection for special elements (window, document, iframes)
            if (element && (element.getElementById || element.navigator)) {
                skipGarbageCollection = true;
            }

            if (!Ext.cache[id]){
                Ext.core.Element.addToCache(new Ext.core.Element(element), id);
                if (skipGarbageCollection) {
                    Ext.cache[id].skipGarbageCollection = true;
                }
            }
            return id;
        },

        /**
         * Convert a "config style" listener into a set of flat arguments so they can be passed to addListener
         * @private
         * @param {Object} element The element the event is for
         * @param {Object} event The event configuration
         * @param {Object} isRemove True if a removal should be performed, otherwise an add will be done.
         */
        prepareListenerConfig: function(element, config, isRemove){
            var me = this,
                propRe = me.propRe,
                key, value, args;

            // loop over all the keys in the object
            for (key in config) {
                if (config.hasOwnProperty(key)) {
                    // if the key is something else then an event option
                    if (!propRe.test(key)) {
                        value = config[key];
                        // if the value is a function it must be something like click: function(){}, scope: this
                        // which means that there might be multiple event listeners with shared options
                        if (Ext.isFunction(value)) {
                            // shared options
                            args = [element, key, value, config.scope, config];
                        } else {
                            // if its not a function, it must be an object like click: {fn: function(){}, scope: this}
                            args = [element, key, value.fn, value.scope, value];
                        }

                        if (isRemove === true) {
                            me.removeListener.apply(this, args);
                        } else {
                            me.addListener.apply(me, args);
                        }
                    }
                }
            }
        },

        /**
         * Normalize cross browser event differences
         * @private
         * @param {Object} eventName The event name
         * @param {Object} fn The function to execute
         * @return {Object} The new event name/function
         */
        normalizeEvent: function(eventName, fn){
            if (/mouseenter|mouseleave/.test(eventName) && !Ext.supports.MouseEnterLeave) {
                if (fn) {
                    fn = Ext.Function.createInterceptor(fn, this.contains, this);
                }
                eventName = eventName == 'mouseenter' ? 'mouseover' : 'mouseout';
            } else if (eventName == 'mousewheel' && !Ext.supports.MouseWheel && !Ext.isOpera){
                eventName = 'DOMMouseScroll';
            }
            return {
                eventName: eventName,
                fn: fn
            };
        },

        /**
         * Checks whether the event's relatedTarget is contained inside (or <b>is</b>) the element.
         * @private
         * @param {Object} event
         */
        contains: function(event){
            var parent = event.browserEvent.currentTarget,
                child = this.getRelatedTarget(event);

            if (parent && parent.firstChild) {
                while (child) {
                    if (child === parent) {
                        return false;
                    }
                    child = child.parentNode;
                    if (child && (child.nodeType != 1)) {
                        child = null;
                    }
                }
            }
            return true;
        },

        /**
        * Appends an event handler to an element.  The shorthand version {@link #on} is equivalent.  Typically you will
        * use {@link Ext.core.Element#addListener} directly on an Element in favor of calling this version.
        * @param {String/HTMLElement} el The html element or id to assign the event handler to.
        * @param {String} eventName The name of the event to listen for.
        * @param {Function} handler The handler function the event invokes. This function is passed
        * the following parameters:<ul>
        * <li>evt : EventObject<div class="sub-desc">The {@link Ext.EventObject EventObject} describing the event.</div></li>
        * <li>t : Element<div class="sub-desc">The {@link Ext.core.Element Element} which was the target of the event.
        * Note that this may be filtered by using the <tt>delegate</tt> option.</div></li>
        * <li>o : Object<div class="sub-desc">The options object from the addListener call.</div></li>
        * </ul>
        * @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>.
        * @param {Object} options (optional) An object containing handler configuration properties.
        * This may contain any of the following properties:<ul>
        * <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>
        * <li>delegate : String<div class="sub-desc">A simple selector to filter the target or look for a descendant of the target</div></li>
        * <li>stopEvent : Boolean<div class="sub-desc">True to stop the event. That is stop propagation, and prevent the default action.</div></li>
        * <li>preventDefault : Boolean<div class="sub-desc">True to prevent the default action</div></li>
        * <li>stopPropagation : Boolean<div class="sub-desc">True to prevent event propagation</div></li>
        * <li>normalized : Boolean<div class="sub-desc">False to pass a browser event to the handler function instead of an Ext.EventObject</div></li>
        * <li>delay : Number<div class="sub-desc">The number of milliseconds to delay the invocation of the handler after te event fires.</div></li>
        * <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>
        * <li>buffer : Number<div class="sub-desc">Causes the handler to be scheduled to run in an {@link Ext.util.DelayedTask} delayed
        * by the specified number of milliseconds. If the event fires again within that time, the original
        * handler is <em>not</em> invoked, but the new handler is scheduled in its place.</div></li>
        * <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>
        * </ul><br>
        * <p>See {@link Ext.core.Element#addListener} for examples of how to use these options.</p>
        */
        addListener: function(element, eventName, fn, scope, options){
            // Check if we've been passed a "config style" event.
            if (Ext.isObject(eventName)) {
                this.prepareListenerConfig(element, eventName);
                return;
            }

            var dom = Ext.getDom(element),
                bind,
                wrap;

            //<debug>
            if (!dom){
                Ext.Error.raise({
                    sourceClass: 'Ext.EventManager',
                    sourceMethod: 'addListener',
                    targetElement: element,
                    eventName: eventName,
                    msg: 'Error adding "' + eventName + '\" listener for nonexistent element "' + element + '"'
                });
            }
            if (!fn) {
                Ext.Error.raise({
                    sourceClass: 'Ext.EventManager',
                    sourceMethod: 'addListener',
                    targetElement: element,
                    eventName: eventName,
                    msg: 'Error adding "' + eventName + '\" listener. The handler function is undefined.'
                });
            }
            //</debug>

            // create the wrapper function
            options = options || {};

            bind = this.normalizeEvent(eventName, fn);
            wrap = this.createListenerWrap(dom, eventName, bind.fn, scope, options);

            if (dom.attachEvent) {
                dom.attachEvent('on' + bind.eventName, wrap);
            } else {
                dom.addEventListener(bind.eventName, wrap, options.capture || false);
            }

            if (dom == document && eventName == 'mousedown') {
                this.stoppedMouseDownEvent.addListener(wrap);
            }

            // add all required data into the event cache
            this.getEventListenerCache(dom, eventName).push({
                fn: fn,
                wrap: wrap,
                scope: scope
            });
        },

        /**
        * Removes an event handler from an element.  The shorthand version {@link #un} is equivalent.  Typically
        * you will use {@link Ext.core.Element#removeListener} directly on an Element in favor of calling this version.
        * @param {String/HTMLElement} el The id or html element from which to remove the listener.
        * @param {String} eventName The name of the event.
        * @param {Function} fn The handler function to remove. <b>This must be a reference to the function passed into the {@link #addListener} call.</b>
        * @param {Object} scope If a scope (<b><code>this</code></b> reference) was specified when the listener was added,
        * then this must refer to the same object.
        */
        removeListener : function(element, eventName, fn, scope) {
            // handle our listener config object syntax
            if (Ext.isObject(eventName)) {
                this.prepareListenerConfig(element, eventName, true);
                return;
            }

            var dom = Ext.getDom(element),
                cache = this.getEventListenerCache(dom, eventName),
                bindName = this.normalizeEvent(eventName).eventName,
                i = cache.length, j,
                listener, wrap, tasks;

            while (i--) {
                listener = cache[i];

                if (listener && (!fn || listener.fn == fn) && (!scope || listener.scope === scope)) {
                    wrap = listener.wrap;

                    // clear buffered calls
                    if (wrap.task) {
                        clearTimeout(wrap.task);
                        delete wrap.task;
                    }

                    // clear delayed calls
                    j = wrap.tasks && wrap.tasks.length;
                    if (j) {
                        while (j--) {
                            clearTimeout(wrap.tasks[j]);
                        }
                        delete wrap.tasks;
                    }

                    if (dom.detachEvent) {
                        dom.detachEvent('on' + bindName, wrap);
                    } else {
                        dom.removeEventListener(bindName, wrap, false);
                    }

                    if (wrap && dom == document && eventName == 'mousedown') {
                        this.stoppedMouseDownEvent.removeListener(wrap);
                    }

                    // remove listener from cache
                    cache.splice(i, 1);
                }
            }
        },

        /**
        * Removes all event handers from an element.  Typically you will use {@link Ext.core.Element#removeAllListeners}
        * directly on an Element in favor of calling this version.
        * @param {String/HTMLElement} el The id or html element from which to remove all event handlers.
        */
        removeAll : function(element){
            var dom = Ext.getDom(element),
                cache, ev;
            if (!dom) {
                return;
            }
            cache = this.getElementEventCache(dom);

            for (ev in cache) {
                if (cache.hasOwnProperty(ev)) {
                    this.removeListener(dom, ev);
                }
            }
            Ext.cache[dom.id].events = {};
        },

        /**
         * Recursively removes all previous added listeners from an element and its children. Typically you will use {@link Ext.core.Element#purgeAllListeners}
         * directly on an Element in favor of calling this version.
         * @param {String/HTMLElement} el The id or html element from which to remove all event handlers.
         * @param {String} eventName (optional) The name of the event.
         */
        purgeElement : function(element, eventName) {
            var dom = Ext.getDom(element),
                i = 0, len;

            if(eventName) {
                this.removeListener(dom, eventName);
            }
            else {
                this.removeAll(dom);
            }

            if(dom && dom.childNodes) {
                for(len = element.childNodes.length; i < len; i++) {
                    this.purgeElement(element.childNodes[i], eventName);
                }
            }
        },

        /**
         * Create the wrapper function for the event
         * @private
         * @param {HTMLElement} dom The dom element
         * @param {String} ename The event name
         * @param {Function} fn The function to execute
         * @param {Object} scope The scope to execute callback in
         * @param {Object} o The options
         */
        createListenerWrap : function(dom, ename, fn, scope, options) {
            options = !Ext.isObject(options) ? {} : options;

            var f = ['if(!Ext) {return;}'],
                gen;

            if(options.buffer || options.delay || options.freezeEvent) {
                f.push('e = new Ext.EventObjectImpl(e, ' + (options.freezeEvent ? 'true' : 'false' ) + ');');
            } else {
                f.push('e = Ext.EventObject.setEvent(e);');
            }

            if (options.delegate) {
                f.push('var t = e.getTarget("' + options.delegate + '", this);');
                f.push('if(!t) {return;}');
            } else {
                f.push('var t = e.target;');
            }

            if (options.target) {
                f.push('if(e.target !== options.target) {return;}');
            }

            if(options.stopEvent) {
                f.push('e.stopEvent();');
            } else {
                if(options.preventDefault) {
                    f.push('e.preventDefault();');
                }
                if(options.stopPropagation) {
                    f.push('e.stopPropagation();');
                }
            }

            if(options.normalized === false) {
                f.push('e = e.browserEvent;');
            }

            if(options.buffer) {
                f.push('(wrap.task && clearTimeout(wrap.task));');
                f.push('wrap.task = setTimeout(function(){');
            }

            if(options.delay) {
                f.push('wrap.tasks = wrap.tasks || [];');
                f.push('wrap.tasks.push(setTimeout(function(){');
            }

            // finally call the actual handler fn
            f.push('fn.call(scope || dom, e, t, options);');

            if(options.single) {
                f.push('Ext.EventManager.removeListener(dom, ename, fn, scope);');
            }

            if(options.delay) {
                f.push('}, ' + options.delay + '));');
            }

            if(options.buffer) {
                f.push('}, ' + options.buffer + ');');
            }

            gen = Ext.functionFactory('e', 'options', 'fn', 'scope', 'ename', 'dom', 'wrap', 'args', f.join('\n'));

            return function wrap(e, args) {
                gen.call(dom, e, options, fn, scope, ename, dom, wrap, args);
            };
        },

        /**
         * Get the event cache for a particular element for a particular event
         * @private
         * @param {HTMLElement} element The element
         * @param {Object} eventName The event name
         * @return {Array} The events for the element
         */
        getEventListenerCache : function(element, eventName) {
            var eventCache = this.getElementEventCache(element);
            return eventCache[eventName] || (eventCache[eventName] = []);
        },

        /**
         * Gets the event cache for the object
         * @private
         * @param {HTMLElement} element The element
         * @return {Object} The event cache for the object
         */
        getElementEventCache : function(element) {
            var elementCache = Ext.cache[this.getId(element)];
            return elementCache.events || (elementCache.events = {});
        },

        // --------------------- utility methods ---------------------
        mouseLeaveRe: /(mouseout|mouseleave)/,
        mouseEnterRe: /(mouseover|mouseenter)/,

        /**
         * Stop the event (preventDefault and stopPropagation)
         * @param {Event} The event to stop
         */
        stopEvent: function(event) {
            this.stopPropagation(event);
            this.preventDefault(event);
        },

        /**
         * Cancels bubbling of the event.
         * @param {Event} The event to stop bubbling.
         */
        stopPropagation: function(event) {
            event = event.browserEvent || event;
            if (event.stopPropagation) {
                event.stopPropagation();
            } else {
                event.cancelBubble = true;
            }
        },

        /**
         * Prevents the browsers default handling of the event.
         * @param {Event} The event to prevent the default
         */
        preventDefault: function(event) {
            event = event.browserEvent || event;
            if (event.preventDefault) {
                event.preventDefault();
            } else {
                event.returnValue = false;
                // Some keys events require setting the keyCode to -1 to be prevented
                try {
                  // all ctrl + X and F1 -> F12
                  if (event.ctrlKey || event.keyCode > 111 && event.keyCode < 124) {
                      event.keyCode = -1;
                  }
                } catch (e) {
                    // see this outdated document http://support.microsoft.com/kb/934364/en-us for more info
                }
            }
        },

        /**
         * Gets the related target from the event.
         * @param {Object} event The event
         * @return {HTMLElement} The related target.
         */
        getRelatedTarget: function(event) {
            event = event.browserEvent || event;
            var target = event.relatedTarget;
            if (!target) {
                if (this.mouseLeaveRe.test(event.type)) {
                    target = event.toElement;
                } else if (this.mouseEnterRe.test(event.type)) {
                    target = event.fromElement;
                }
            }
            return this.resolveTextNode(target);
        },

        /**
         * Gets the x coordinate from the event
         * @param {Object} event The event
         * @return {Number} The x coordinate
         */
        getPageX: function(event) {
            return this.getXY(event)[0];
        },

        /**
         * Gets the y coordinate from the event
         * @param {Object} event The event
         * @return {Number} The y coordinate
         */
        getPageY: function(event) {
            return this.getXY(event)[1];
        },

        /**
         * Gets the x & ycoordinate from the event
         * @param {Object} event The event
         * @return {Array} The x/y coordinate
         */
        getPageXY: function(event) {
            event = event.browserEvent || event;
            var x = event.pageX,
                y = event.pageY,
                doc = document.documentElement,
                body = document.body;

            // pageX/pageY not available (undefined, not null), use clientX/clientY instead
            if (!x && x !== 0) {
                x = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
                y = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);
            }
            return [x, y];
        },

        /**
         * Gets the target of the event.
         * @param {Object} event The event
         * @return {HTMLElement} target
         */
        getTarget: function(event) {
            event = event.browserEvent || event;
            return this.resolveTextNode(event.target || event.srcElement);
        },

        /**
         * Resolve any text nodes accounting for browser differences.
         * @private
         * @param {HTMLElement} node The node
         * @return {HTMLElement} The resolved node
         */
        // technically no need to browser sniff this, however it makes no sense to check this every time, for every event, whether the string is equal.
        resolveTextNode: Ext.isGecko ?
            function(node) {
                if (!node) {
                    return;
                }
                // work around firefox bug, https://bugzilla.mozilla.org/show_bug.cgi?id=101197
                var s = HTMLElement.prototype.toString.call(node);
                if (s == '[xpconnect wrapped native prototype]' || s == '[object XULElement]') {
                    return;
                }
                    return node.nodeType == 3 ? node.parentNode: node;
                }: function(node) {
                    return node && node.nodeType == 3 ? node.parentNode: node;
                },

        // --------------------- custom event binding ---------------------

        // Keep track of the current width/height
        curWidth: 0,
        curHeight: 0,

        /**
         * Adds a listener to be notified when the browser window is resized and provides resize event buffering (100 milliseconds),
         * passes new viewport width and height to handlers.
         * @param {Function} fn      The handler function the window resize event invokes.
         * @param {Object}   scope   The scope (<code>this</code> reference) in which the handler function executes. Defaults to the browser window.
         * @param {boolean}  options Options object as passed to {@link Ext.core.Element#addListener}
         */
        onWindowResize: function(fn, scope, options){
            var resize = this.resizeEvent;
            if(!resize){
                this.resizeEvent = resize = new Ext.util.Event();
                this.on(window, 'resize', this.fireResize, this, {buffer: 100});
            }
            resize.addListener(fn, scope, options);
        },

        /**
         * Fire the resize event.
         * @private
         */
        fireResize: function(){
            var me = this,
                w = Ext.core.Element.getViewWidth(),
                h = Ext.core.Element.getViewHeight();

             //whacky problem in IE where the resize event will sometimes fire even though the w/h are the same.
             if(me.curHeight != h || me.curWidth != w){
                 me.curHeight = h;
                 me.curWidth = w;
                 me.resizeEvent.fire(w, h);
             }
        },

        /**
         * Removes the passed window resize listener.
         * @param {Function} fn        The method the event invokes
         * @param {Object}   scope    The scope of handler
         */
        removeResizeListener: function(fn, scope){
            if (this.resizeEvent) {
                this.resizeEvent.removeListener(fn, scope);
            }
        },

        onWindowUnload: function() {
            var unload = this.unloadEvent;
            if (!unload) {
                this.unloadEvent = unload = new Ext.util.Event();
                this.addListener(window, 'unload', this.fireUnload, this);
            }
        },

        /**
         * Fires the unload event for items bound with onWindowUnload
         * @private
         */
        fireUnload: function() {
            // wrap in a try catch, could have some problems during unload
            try {
                this.removeUnloadListener();
                // Work around FF3 remembering the last scroll position when refreshing the grid and then losing grid view
                if (Ext.isGecko3) {
                    var gridviews = Ext.ComponentQuery.query('gridview'),
                        i = 0,
                        ln = gridviews.length;
                    for (; i < ln; i++) {
                        gridviews[i].scrollToTop();
                    }
                }
                // Purge all elements in the cache
                var el,
                    cache = Ext.cache;
                for (el in cache) {
                    if (cache.hasOwnProperty(el)) {
                        Ext.EventManager.removeAll(el);
                    }
                }
            } catch(e) {
            }
        },

        /**
         * Removes the passed window unload listener.
         * @param {Function} fn        The method the event invokes
         * @param {Object}   scope    The scope of handler
         */
        removeUnloadListener: function(){
            if (this.unloadEvent) {
                this.removeListener(window, 'unload', this.fireUnload);
            }
        },

        /**
         * note 1: IE fires ONLY the keydown event on specialkey autorepeat
         * note 2: Safari < 3.1, Gecko (Mac/Linux) & Opera fire only the keypress event on specialkey autorepeat
         * (research done by @Jan Wolter at http://unixpapa.com/js/key.html)
         * @private
         */
        useKeyDown: Ext.isWebKit ?
                       parseInt(navigator.userAgent.match(/AppleWebKit\/(\d+)/)[1], 10) >= 525 :
                       !((Ext.isGecko && !Ext.isWindows) || Ext.isOpera),

        /**
         * Indicates which event to use for getting key presses.
         * @return {String} The appropriate event name.
         */
        getKeyEvent: function(){
            return this.useKeyDown ? 'keydown' : 'keypress';
        }
    };

    /**
     * Alias for {@link Ext.Loader#onReady Ext.Loader.onReady} with withDomReady set to true
     * @member Ext
     * @method onReady
     */
    Ext.onReady = function(fn, scope, options) {
        Ext.Loader.onReady(fn, scope, true, options);
    };

    /**
     * Alias for {@link Ext.EventManager#onDocumentReady Ext.EventManager.onDocumentReady}
     * @member Ext
     * @method onDocumentReady
     */
    Ext.onDocumentReady = Ext.EventManager.onDocumentReady;

    /**
     * Alias for {@link Ext.EventManager#addListener Ext.EventManager.addListener}
     * @member Ext.EventManager
     * @method on
     */
    Ext.EventManager.on = Ext.EventManager.addListener;

    /**
     * Alias for {@link Ext.EventManager#removeListener Ext.EventManager.removeListener}
     * @member Ext.EventManager
     * @method un
     */
    Ext.EventManager.un = Ext.EventManager.removeListener;

    (function(){
        var initExtCss = function() {
            // find the body element
            var bd = document.body || document.getElementsByTagName('body')[0],
                baseCSSPrefix = Ext.baseCSSPrefix,
                cls = [],
                htmlCls = [],
                html;

            if (!bd) {
                return false;
            }

            html = bd.parentNode;

            //Let's keep this human readable!
            if (Ext.isIE) {
                cls.push(baseCSSPrefix + 'ie');
            }
            if (Ext.isIE6) {
                cls.push(baseCSSPrefix + 'ie6');
            }
            if (Ext.isIE7) {
                cls.push(baseCSSPrefix + 'ie7');
            }
            if (Ext.isIE8) {
                cls.push(baseCSSPrefix + 'ie8');
            }
            if (Ext.isIE9) {
                cls.push(baseCSSPrefix + 'ie9');
            }
            if (Ext.isGecko) {
                cls.push(baseCSSPrefix + 'gecko');
            }
            if (Ext.isGecko3) {
                cls.push(baseCSSPrefix + 'gecko3');
            }
            if (Ext.isGecko4) {
                cls.push(baseCSSPrefix + 'gecko4');
            }
            if (Ext.isOpera) {
                cls.push(baseCSSPrefix + 'opera');
            }
            if (Ext.isWebKit) {
                cls.push(baseCSSPrefix + 'webkit');
            }
            if (Ext.isSafari) {
                cls.push(baseCSSPrefix + 'safari');
            }
            if (Ext.isSafari2) {
                cls.push(baseCSSPrefix + 'safari2');
            }
            if (Ext.isSafari3) {
                cls.push(baseCSSPrefix + 'safari3');
            }
            if (Ext.isSafari4) {
                cls.push(baseCSSPrefix + 'safari4');
            }
            if (Ext.isChrome) {
                cls.push(baseCSSPrefix + 'chrome');
            }
            if (Ext.isMac) {
                cls.push(baseCSSPrefix + 'mac');
            }
            if (Ext.isLinux) {
                cls.push(baseCSSPrefix + 'linux');
            }
            if (!Ext.supports.CSS3BorderRadius) {
                cls.push(baseCSSPrefix + 'nbr');
            }
            if (!Ext.supports.CSS3LinearGradient) {
                cls.push(baseCSSPrefix + 'nlg');
            }
            if (!Ext.scopeResetCSS) {
                cls.push(baseCSSPrefix + 'reset');
            }

            // add to the parent to allow for selectors x-strict x-border-box, also set the isBorderBox property correctly
            if (html) {
                if (Ext.isStrict && (Ext.isIE6 || Ext.isIE7)) {
                    Ext.isBorderBox = false;
                }
                else {
                    Ext.isBorderBox = true;
                }

                htmlCls.push(baseCSSPrefix + (Ext.isBorderBox ? 'border-box' : 'strict'));
                if (!Ext.isStrict) {
                    htmlCls.push(baseCSSPrefix + 'quirks');
                    if (Ext.isIE && !Ext.isStrict) {
                        Ext.isIEQuirks = true;
                    }
                }
                Ext.fly(html, '_internal').addCls(htmlCls);
            }

            Ext.fly(bd, '_internal').addCls(cls);
            return true;
        };

        Ext.onReady(initExtCss);
    })();