    /** * An `{@link Ext.mixin.Observable Observable}` through which Ext fires global events. *  * Ext.on() and Ext.un() are shorthand for {@link #addListener} and {@link #removeListener} * on this Observable.  For example, to listen for the idle event: *  *     Ext.on('idle', function() { *         // do something *     }); */Ext.define('Ext.GlobalEvents', {    extend: 'Ext.mixin.Observable',    alternateClassName: 'Ext.globalEvents', // for compat with Ext JS 4.2 and earlier         requires: [        'Ext.dom.Element'    ],     observableType: 'global',     singleton: true,     /**     * @private     */    resizeBuffer: 100,     /**     * @event added     * Fires when a Component is added to a Container.     * @param {Ext.Component} component     */     /**     * @event beforeresponsiveupdate     * Fires before {@link Ext.mixin.Responsive} perform any updates in response to     * dynamic changes. This is prior to refreshing `responsiveFormulas`.     * @param {Object} context The context object used by `responsiveConfig` expressions.     * @since 5.0.1     */     /**     * @event beginresponsiveupdate     * Fires when {@link Ext.mixin.Responsive} is about to perform updates in response to     * dynamic changes. At this point all `responsiveFormulas` have been refreshed.     * @param {Object} context The context object used by `responsiveConfig` expressions.     * @since 5.0.1     */     /**     * @event responsiveupdate     * Fires after {@link Ext.mixin.Responsive} has performed updates in response to     * dynamic changes.     * @param {Object} context The context object used by `responsiveConfig` expressions.     * @since 5.0.1     */     /**     * @event collapse     * Fires when a Component is collapsed (e.g., a panel).     * @param {Ext.Component} component     */     /**     * @event expand     * Fires when a Component is expanded (e.g., a panel).     * @param {Ext.Component} component     */     /**     * @event hide     * Fires when a Component is hidden.     * @param {Ext.Component} component     */     /**     * @event idle     * Fires when an event handler finishes its run, just before returning to     * browser control.     *      * This includes DOM event handlers, Ajax (including JSONP) event handlers,     * and {@link Ext.util.TaskRunner TaskRunners}     *      * When called at the tail of a DOM event, the event object is passed as the     * sole parameter.     *      * This can be useful for performing cleanup, or update tasks which need to     * happen only after all code in an event handler has been run, but which     * should not be executed in a timer due to the intervening browser     * reflow/repaint which would take place.     */     /**     * @event removed     * Fires when a Component is removed from a Container.     * @param {Ext.Component} component     */     /**     * @event resize     * Fires when the browser window is resized.  To avoid running resize handlers     * too often resulting in sluggish window resizing, resize events use a buffer     * of 100 milliseconds.     * @param {Number} width The new width     * @param {Number} height The new height     */     /**     * @event show     * Fires when a Component is shown.     * @param {Ext.Component} component     */        /**     * @event beforebindnotify     * Fires before a scheduled set of bindings are fired. This allows interested parties     * to react and do any required work.     * @param {Ext.util.Scheduler} scheduler The scheduler triggering the bindings.     *      * @private     * @since 5.1.0     */        /**     * @event mousedown     * A mousedown listener on the document that is immune to stopPropagation()     * used in cases where we need to know if a mousedown event occurred on the     * document regardless of whether some other handler tried to stop it.  An     * example where this is useful is a menu that needs to be hidden whenever     * there is a mousedown event on the document.     * @param {Ext.event.Event} e The event object     */     /**     * @property {Object} idleEventMask      * This object holds event names for events that should not trigger an `idle` event     * following their dispatch.     * @private     * @since 5.0.0     */    idleEventMask: {        mousemove: 1,        touchmove: 1,        pointermove: 1,        MSPointerMove: 1,        unload: 1    },     constructor: function() {        var me = this;         me.callParent();         Ext.onInternalReady(function() {            // using a closure here instead of attaching the event directly to the             // attachListeners method gives us a chance to override the method             me.attachListeners();        });    },     attachListeners: function() {        Ext.get(window).on('resize', this.fireResize, this, {            buffer: this.resizeBuffer        });        Ext.getDoc().on('mousedown', this.fireMouseDown, this);    },     fireMouseDown: function(e) {        this.fireEvent('mousedown', e);    },     fireResize: function() {        var me = this,            Element = Ext.Element,            w = Element.getViewportWidth(),            h = Element.getViewportHeight();          // In IE 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.fireEvent('resize', w, h);         }    } }, function(GlobalEvents) {    /**     * @member Ext     * @method on     * Shorthand for {@link Ext.GlobalEvents#addListener}.     * @inheritdoc Ext.mixin.Observable#addListener     */    Ext.on = function() {        return GlobalEvents.addListener.apply(GlobalEvents, arguments);    };     /**     * @member Ext     * @method un     * Shorthand for {@link Ext.GlobalEvents#removeListener}.     * @inheritdoc Ext.mixin.Observable#removeListener     */    Ext.un = function() {        return GlobalEvents.removeListener.apply(GlobalEvents, arguments);    };     /**     * @member Ext     * @method fireEvent     * Shorthand for {@link Ext.GlobalEvents#fireEvent}.     * @inheritdoc Ext.mixin.Observable#fireEvent     *     * @since 6.2.0     */    Ext.fireEvent = function() {        return GlobalEvents.fireEvent.apply(GlobalEvents, arguments);    };});