[extjs.git] / extjs / packages / core / src / Ext.js

// @tag core\r
/**\r
 * @class Ext\r
 *\r
 * The Ext namespace (global object) encapsulates all classes, singletons, and\r
 * utility methods provided by Sencha's libraries.\r
 *\r
 * Most user interface Components are at a lower level of nesting in the namespace,\r
 * but many common utility functions are provided as direct properties of the Ext namespace.\r
 *\r
 * Also many frequently used methods from other classes are provided as shortcuts\r
 * within the Ext namespace. For example {@link Ext#getCmp Ext.getCmp} aliases\r
 * {@link Ext.ComponentManager#get Ext.ComponentManager.get}.\r
 *\r
 * Many applications are initiated with {@link Ext#application Ext.application} which is\r
 * called once the DOM is ready. This ensures all scripts have been loaded, preventing\r
 * dependency issues. For example:\r
 *\r
 *      Ext.application({\r
 *          name: 'MyApp',\r
 *\r
 *          launch: function () {\r
 *              Ext.Msg.alert(this.name, 'Ready to go!');\r
 *          }\r
 *      });\r
 *\r
 * <b><a href="http://www.sencha.com/products/sencha-cmd/">Sencha Cmd</a></b> is a free tool\r
 * for helping you generate and build Ext JS (and Sencha Touch) applications. See\r
 * `{@link Ext.app.Application Application}` for more information about creating an app.\r
 *\r
 * A lower-level technique that does not use the `Ext.app.Application` architecture is\r
 * {@link Ext#onReady Ext.onReady}.\r
 *\r
 * For more information about how to use the Ext classes, see:\r
 *\r
 * - <a href="http://www.sencha.com/learn/">The Learning Center</a>\r
 * - <a href="http://www.sencha.com/learn/Ext_FAQ">The FAQ</a>\r
 * - <a href="http://www.sencha.com/forum/">The forums</a>\r
 *\r
 * @singleton\r
 */\r
var Ext = Ext || {}; // jshint ignore:line\r
// @define Ext\r
\r
(function() {\r
    var global = this,\r
        objectPrototype = Object.prototype,\r
        toString = objectPrototype.toString,\r
        enumerables = [//'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable',\r
                       'valueOf', 'toLocaleString', 'toString', 'constructor'],\r
        emptyFn = function () {},\r
        privateFn = function () {},\r
        identityFn = function(o) { return o; },\r
        // This is the "$previous" method of a hook function on an instance. When called, it\r
        // calls through the class prototype by the name of the called method.\r
        callOverrideParent = function () {\r
            var method = callOverrideParent.caller.caller; // skip callParent (our caller)\r
            return method.$owner.prototype[method.$name].apply(this, arguments);\r
        },\r
        manifest = Ext.manifest || {},\r
        i,\r
        iterableRe = /\[object\s*(?:Array|Arguments|\w*Collection|\w*List|HTML\s+document\.all\s+class)\]/,\r
        MSDateRe = /^\\?\/Date\(([-+])?(\d+)(?:[+-]\d{4})?\)\\?\/$/;\r
\r
    Ext.global = global;\r
\r
    /**\r
     * Returns the current timestamp.\r
     * @return {Number} Milliseconds since UNIX epoch.\r
     * @method now\r
     * @member Ext\r
     */\r
    Ext.now = Date.now || (Date.now = function() {\r
        return +new Date();\r
    });\r
\r
    /**\r
     * Returns the current high-resolution timestamp.\r
     * @return {Number} Milliseconds ellapsed since arbitrary epoch.\r
     * @method ticks\r
     * @member Ext\r
     * @since 6.0.1\r
     */\r
    Ext.ticks = (global.performance && global.performance.now) ? function() {\r
        return performance.now(); // jshint ignore:line\r
    } : Ext.now;\r
\r
    Ext._startTime = Ext.ticks();\r
\r
    // Mark these special fn's for easy identification:\r
    emptyFn.$nullFn = identityFn.$nullFn = emptyFn.$emptyFn = identityFn.$identityFn =\r
        privateFn.$nullFn = true;\r
    privateFn.$privacy = 'framework';\r
\r
    // These are emptyFn's in core and are redefined only in Ext JS (we use this syntax\r
    // so Cmd does not detect them):\r
    Ext['suspendLayouts'] = Ext['resumeLayouts'] = emptyFn; // jshint ignore:line\r
\r
    for (i in { toString: 1 }) {\r
        enumerables = null;\r
    }\r
\r
    /**\r
     * An array containing extra enumerables for old browsers\r
     * @property {String[]}\r
     */\r
    Ext.enumerables = enumerables;\r
\r
    /**\r
     * Copies all the properties of `config` to the specified `object`. There are two levels\r
     * of defaulting supported:\r
     * \r
     *      Ext.apply(obj, { a: 1 }, { a: 2 });\r
     *      //obj.a === 1\r
     * \r
     *      Ext.apply(obj, {  }, { a: 2 });\r
     *      //obj.a === 2\r
     * \r
     * Note that if recursive merging and cloning without referencing the original objects\r
     * or arrays is needed, use {@link Ext.Object#merge} instead.\r
     * \r
     * @param {Object} object The receiver of the properties.\r
     * @param {Object} config The primary source of the properties.\r
     * @param {Object} [defaults] An object that will also be applied for default values.\r
     * @return {Object} returns `object`.\r
     */\r
    Ext.apply = function(object, config, defaults) {\r
        if (defaults) {\r
            Ext.apply(object, defaults);\r
        }\r
\r
        if (object && config && typeof config === 'object') {\r
            var i, j, k;\r
\r
            for (i in config) {\r
                object[i] = config[i];\r
            }\r
\r
            if (enumerables) {\r
                for (j = enumerables.length; j--;) {\r
                    k = enumerables[j];\r
                    if (config.hasOwnProperty(k)) {\r
                        object[k] = config[k];\r
                    }\r
                }\r
            }\r
        }\r
\r
        return object;\r
    };\r
\r
    // Used by Ext.override\r
    function addInstanceOverrides(target, owner, overrides) {\r
        var name, value;\r
\r
        for (name in overrides) {\r
            if (overrides.hasOwnProperty(name)) {\r
                value = overrides[name];\r
\r
                if (typeof value === 'function') {\r
                    //<debug>\r
                    if (owner.$className) {\r
                        value.name = owner.$className + '#' + name;\r
                    }\r
                    //</debug>\r
\r
                    value.$name = name;\r
                    value.$owner = owner;\r
\r
                    value.$previous = target.hasOwnProperty(name) ?\r
                        target[name] // already hooked, so call previous hook\r
                        : callOverrideParent; // calls by name on prototype\r
                }\r
\r
                target[name] = value;\r
            }\r
        }\r
    }\r
\r
    Ext.buildSettings = Ext.apply({\r
        baseCSSPrefix: 'x-'\r
    }, Ext.buildSettings || {});\r
\r
    Ext.apply(Ext, {\r
        /**\r
         * @private\r
         */\r
        idSeed: 0,\r
\r
        /**\r
         * @private\r
         */\r
        idPrefix: 'ext-',\r
\r
        /**\r
         * @property {Boolean} isSecure\r
         * True if the page is running over SSL\r
         * @readonly\r
         */\r
        isSecure: /^https/i.test(window.location.protocol),\r
\r
        /**\r
         * `true` to automatically uncache orphaned Ext.Elements periodically. If set to\r
         * `false`, the application will be required to clean up orphaned Ext.Elements and\r
         * it's listeners as to not cause memory leakage.\r
         */\r
        enableGarbageCollector: false,\r
\r
        /**\r
         * True to automatically purge event listeners during garbageCollection.\r
         */\r
        enableListenerCollection: true,\r
\r
        /**\r
         * @property {String} [name='Ext']\r
         * <p>The name of the property in the global namespace (The <code>window</code> in browser environments) which refers to the current instance of Ext.</p>\r
         * <p>This is usually <code>"Ext"</code>, but if a sandboxed build of ExtJS is being used, this will be an alternative name.</p>\r
         * <p>If code is being generated for use by <code>eval</code> or to create a <code>new Function</code>, and the global instance\r
         * of Ext must be referenced, this is the name that should be built into the code.</p>\r
         */\r
        name: Ext.sandboxName || 'Ext',\r
\r
        /**\r
         * @property {Function}\r
         * A reusable empty function for use as `privates` members.\r
         *\r
         *      Ext.define('MyClass', {\r
         *          nothing: Ext.emptyFn,\r
         *\r
         *          privates: {\r
         *              privateNothing: Ext.privateFn\r
         *          }\r
         *      });\r
         *\r
         */\r
        privateFn: privateFn,\r
\r
        /**\r
         * @property {Function}\r
         * A reusable empty function.\r
         */\r
        emptyFn: emptyFn,\r
\r
        /**\r
         * @property {Function}\r
         * A reusable identity function that simply returns its first argument.\r
         */\r
        identityFn: identityFn,\r
\r
        /**\r
         * This indicate the start timestamp of current cycle.\r
         * It is only reliable during dom-event-initiated cycles and\r
         * {@link Ext.draw.Animator} initiated cycles.\r
         */\r
        frameStartTime: Ext.now(),\r
\r
        /**\r
         * This object is initialized prior to loading the framework (Ext JS or Sencha\r
         * Touch) and contains settings and other information describing the application.\r
         *\r
         * For applications built using Sencha Cmd, this is produced from the `"app.json"`\r
         * file with information extracted from all of the required packages' `"package.json"`\r
         * files. This can be set to a string when your application is using the\r
         * (microloader)[#/guide/microloader]. In this case, the string of "foo" will be\r
         * requested as `"foo.json"` and the object in that JSON file will parsed and set\r
         * as this object.\r
         *\r
         * @cfg {String/Object} manifest\r
         *\r
         * @cfg {String/Object} manifest.compatibility An object keyed by package name with\r
         * the value being to desired compatibility level as a version number. If this is\r
         * just a string, this version is assumed to apply to the framework ('ext' or\r
         * 'touch'). Setting this value to less than 5 for 'ext' will enable the compatibility\r
         * layer to assist in the application upgrade process. For details on the upgrade\r
         * process, see the (Upgrade Guide)[#/guides/upgrade_50].\r
         *\r
         * @cfg {Object} manifest.debug An object configuring the debugging characteristics\r
         * of the framework. See `Ext.debugConfig` which is set to this value.\r
         *\r
         * @cfg {Object} manifest.packages An object keyed by package name with the value\r
         * being a subset of the package's `"package.json"` descriptor.\r
         * @since 5.0.0\r
         */\r
        manifest: manifest,\r
\r
        //<debug>\r
        /**\r
         * @cfg {Object} [debugConfig]\r
         * This object is used to enable or disable debugging for classes or namespaces. The\r
         * default instance looks like this:\r
         *\r
         *      Ext.debugConfig = {\r
         *          hooks: {\r
         *              '*': true\r
         *          }\r
         *      };\r
         *\r
         * Typically applications will set this in their `"app.json"` like so:\r
         *\r
         *      {\r
         *          "debug": {\r
         *              "hooks": {\r
         *                  // Default for all namespaces:\r
         *                  '*': true,\r
         *\r
         *                  // Except for Ext namespace which is disabled\r
         *                  'Ext': false,\r
         *\r
         *                  // Except for Ext.layout namespace which is enabled\r
         *                  'Ext.layout': true\r
         *              }\r
         *          }\r
         *      }\r
         *\r
         * Alternatively, because this property is consumed very early in the load process of\r
         * the framework, this can be set in a `script` tag that is defined prior to loading\r
         * the framework itself.\r
         *\r
         * For example, to enable debugging for the `Ext.layout` namespace only:\r
         *\r
         *      var Ext = Ext || {};\r
         *      Ext.debugConfig = {\r
         *          hooks: {\r
         *              //...\r
         *          }\r
         *      };\r
         *\r
         * For any class declared, the longest matching namespace specified determines if its\r
         * `debugHooks` will be enabled. The default setting is specified by the '*' property.\r
         *\r
         * **NOTE:** This option only applies to debug builds. All debugging is disabled in\r
         * production builds.\r
         */\r
        debugConfig: Ext.debugConfig || manifest.debug || {\r
            hooks: {\r
                '*': true\r
            }\r
        },\r
        //</debug>\r
        \r
        /**\r
         * @property {Boolean} [enableAria=true] This property is provided for backward\r
         * compatibility with previous versions of Ext JS. Accessibility is always enabled\r
         * in Ext JS 6.0+\r
         * @since 6.0.0\r
         */\r
        enableAria: true,\r
        \r
        /**\r
         * @property {Boolean} [enableAriaButtons=true] Set to `false` to disable WAI-ARIA\r
         * compatibility checks for buttons.\r
         * @since 6.0.0\r
         */\r
        enableAriaButtons: true,\r
        \r
        /**\r
         * @property {Boolean} [enableAriaPanels=true] Set to `false` to disable WAI-ARIA\r
         * compatibility checks for panels.\r
         * @since 6.0.0\r
         */\r
        enableAriaPanels: true,\r
        \r
        startsWithHashRe: /^#/,\r
        \r
        /**\r
         * @property {RegExp}\r
         * @private\r
         * Regular expression used for validating identifiers.\r
         */\r
        validIdRe: /^[a-z_][a-z0-9\-_]*$/i,\r
\r
        /**\r
         * @property {String} BLANK_IMAGE_URL\r
         * URL to a 1x1 transparent gif image used by Ext to create inline icons with\r
         * CSS background images.\r
         */\r
        BLANK_IMAGE_URL: 'data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==',\r
\r
        /**\r
         * Converts an id (`'foo'`) into an id selector (`'#foo'`).  This method is used\r
         * internally by the framework whenever an id needs to be converted into a selector\r
         * and is provided as a hook for those that need to escape IDs selectors since,\r
         * as of Ext 5.0, the framework no longer escapes IDs by default.\r
         * @private\r
         * @param {String} id\r
         * @return {String}\r
         */\r
        makeIdSelector: function(id) {\r
            //<debug>\r
            if (!Ext.validIdRe.test(id)) {\r
                Ext.raise('Invalid id selector: "' + id + '"');\r
            }\r
            //</debug>\r
            return '#' + id;\r
        },\r
\r
        /**\r
        * Generates unique ids. If the object/element is passes and it already has an `id`, it is unchanged.\r
        * @param {Object} [o] The object to generate an id for.\r
        * @param {String} [prefix=ext-gen] (optional) The `id` prefix.\r
        * @return {String} The generated `id`.\r
        */\r
        id: function(o, prefix) {\r
            if (o && o.id) {\r
                return o.id;\r
            }\r
\r
            var id = (prefix || Ext.idPrefix) + (++Ext.idSeed);\r
            \r
            if (o) {\r
                o.id = id;\r
            }\r
\r
            return id;\r
        },\r
\r
        /**\r
         * A reusable function which returns the value of `getId()` called upon a single passed parameter.\r
         * Useful when creating a {@link Ext.util.MixedCollection} of objects keyed by an identifier returned from a `getId` method.\r
         */\r
        returnId: function(o) {\r
            return o.getId();\r
        },\r
\r
        /**\r
         * A reusable function which returns `true`.\r
         */\r
        returnTrue: function() {\r
            return true;\r
        },\r
\r
        /**\r
         * A zero length string which will pass a truth test. Useful for passing to methods\r
         * which use a truth test to reject <i>falsy</i> values where a string value must be cleared.\r
         */\r
        emptyString: new String(), // jshint ignore:line\r
\r
        /**\r
         * @property {String} [baseCSSPrefix='x-']\r
         * The base prefix to use for all `Ext` components. To configure this property, you should use the\r
         * Ext.buildSettings object before the framework is loaded:\r
         *\r
         *     Ext.buildSettings = {\r
         *         baseCSSPrefix : 'abc-'\r
         *     };\r
         *\r
         * or you can change it before any components are rendered:\r
         *\r
         *     Ext.baseCSSPrefix = Ext.buildSettings.baseCSSPrefix = 'abc-';\r
         *\r
         * This will change what CSS classes components will use and you should\r
         * then recompile the SASS changing the `$prefix` SASS variable to match.\r
         */\r
        baseCSSPrefix: Ext.buildSettings.baseCSSPrefix,\r
\r
        /**\r
         * @property {Object} $eventNameMap\r
         * A map of event names which contained the lower-cased versions of any mixed\r
         * case event names.\r
         * @private\r
         */\r
        $eventNameMap: {},\r
\r
        // Vendor-specific events do not work if lower-cased.  This regex specifies event\r
        // prefixes for names that should NOT be lower-cased by Ext.canonicalEventName()\r
        $vendorEventRe: /^(Moz.+|MS.+|webkit.+)/,\r
\r
        // TODO: inlinable function - SDKTOOLS-686\r
        /**\r
         * @private\r
         * @inline\r
         */\r
        canonicalEventName: function(name) {\r
            return Ext.$eventNameMap[name] || (Ext.$eventNameMap[name] =\r
                (Ext.$vendorEventRe.test(name) ? name : name.toLowerCase()));\r
        },\r
\r
        /**\r
         * Copies all the properties of config to object if they don't already exist.\r
         * @param {Object} object The receiver of the properties\r
         * @param {Object} config The source of the properties\r
         * @return {Object} returns obj\r
         */\r
        applyIf: function(object, config) {\r
            var property;\r
\r
            if (object) {\r
                for (property in config) {\r
                    if (object[property] === undefined) {\r
                        object[property] = config[property];\r
                    }\r
                }\r
            }\r
\r
            return object;\r
        },\r
\r
        /**\r
         * Destroys all of the given objects. If arrays are passed, the elements of these\r
         * are destroyed recursively.\r
         *\r
         * What it means to "destroy" an object depends on the type of object.\r
         *\r
         *  * `Array`: Each element of the array is destroyed recursively.\r
         *  * `Object`: Any object with a `destroy` method will have that method called.\r
         *\r
         * @param {Mixed...} args Any number of objects or arrays.\r
         */\r
        destroy: function() {\r
            var ln = arguments.length,\r
            i, arg;\r
\r
            for (i = 0; i < ln; i++) {\r
                arg = arguments[i];\r
                if (arg) {\r
                    if (Ext.isArray(arg)) {\r
                        this.destroy.apply(this, arg);\r
                    } else if (Ext.isFunction(arg.destroy)) {\r
                        arg.destroy();\r
                    }\r
                }\r
            }\r
            return null;\r
        },\r
\r
        /**\r
         * Destroys the specified named members of the given object using `Ext.destroy`. These\r
         * properties will be set to `null`.\r
         * @param {Object} object The object who's properties you wish to destroy.\r
         * @param {String...} args One or more names of the properties to destroy and remove from the object.\r
         */\r
        destroyMembers: function (object) {\r
            for (var ref, name, i = 1, a = arguments, len = a.length; i < len; i++) {\r
                ref = object[name = a[i]];\r
\r
                // Avoid adding the property if it does not already exist\r
                if (ref != null) {\r
                    object[name] = Ext.destroy(ref);\r
                }\r
            }\r
        },\r
\r
        /**\r
         * Overrides members of the specified `target` with the given values.\r
         *\r
         * If the `target` is a class declared using {@link Ext#define Ext.define}, the\r
         * `override` method of that class is called (see {@link Ext.Base#override}) given\r
         * the `overrides`.\r
         *\r
         * If the `target` is a function, it is assumed to be a constructor and the contents\r
         * of `overrides` are applied to its `prototype` using {@link Ext#apply Ext.apply}.\r
         *\r
         * If the `target` is an instance of a class declared using {@link Ext#define Ext.define},\r
         * the `overrides` are applied to only that instance. In this case, methods are\r
         * specially processed to allow them to use {@link Ext.Base#callParent}.\r
         *\r
         *      var panel = new Ext.Panel({ ... });\r
         *\r
         *      Ext.override(panel, {\r
         *          initComponent: function () {\r
         *              // extra processing...\r
         *\r
         *              this.callParent();\r
         *          }\r
         *      });\r
         *\r
         * If the `target` is none of these, the `overrides` are applied to the `target`\r
         * using {@link Ext#apply Ext.apply}.\r
         *\r
         * Please refer to {@link Ext#define Ext.define} and {@link Ext.Base#override} for\r
         * further details.\r
         *\r
         * @param {Object} target The target to override.\r
         * @param {Object} overrides The properties to add or replace on `target`.\r
         * @method override\r
         */\r
        override: function (target, overrides) {\r
            if (target.$isClass) {\r
                target.override(overrides);\r
            } else if (typeof target === 'function') {\r
                Ext.apply(target.prototype, overrides);\r
            } else {\r
                var owner = target.self,\r
                    privates;\r
\r
                if (owner && owner.$isClass) { // if (instance of Ext.define'd class)\r
                    privates = overrides.privates;\r
                    if (privates) {\r
                        overrides = Ext.apply({}, overrides);\r
                        delete overrides.privates;\r
                        addInstanceOverrides(target, owner, privates);\r
                    }\r
\r
                    addInstanceOverrides(target, owner, overrides);\r
                } else {\r
                    Ext.apply(target, overrides);\r
                }\r
            }\r
\r
            return target;\r
        },\r
\r
        /**\r
         * Returns the given value itself if it's not empty, as described in {@link Ext#isEmpty}; returns the default\r
         * value (second argument) otherwise.\r
         *\r
         * @param {Object} value The value to test.\r
         * @param {Object} defaultValue The value to return if the original value is empty.\r
         * @param {Boolean} [allowBlank=false] `true` to allow zero length strings to qualify as non-empty.\r
         * @return {Object} value, if non-empty, else defaultValue.\r
         */\r
        valueFrom: function(value, defaultValue, allowBlank){\r
            return Ext.isEmpty(value, allowBlank) ? defaultValue : value;\r
        },\r
\r
        /**\r
         * Returns true if the passed value is empty, false otherwise. The value is deemed to be empty if it is either:\r
         *\r
         * - `null`\r
         * - `undefined`\r
         * - a zero-length array\r
         * - a zero-length string (Unless the `allowEmptyString` parameter is set to `true`)\r
         *\r
         * @param {Object} value The value to test.\r
         * @param {Boolean} [allowEmptyString=false] `true` to allow empty strings.\r
         * @return {Boolean}\r
         */\r
        isEmpty: function(value, allowEmptyString) {\r
            return (value == null) || (!allowEmptyString ? value === '' : false) || (Ext.isArray(value) && value.length === 0);\r
        },\r
\r
        /**\r
         * Returns `true` if the passed value is a JavaScript Array, `false` otherwise.\r
         *\r
         * @param {Object} target The target to test.\r
         * @return {Boolean}\r
         * @method\r
         */\r
        isArray: ('isArray' in Array) ? Array.isArray : function(value) {\r
            return toString.call(value) === '[object Array]';\r
        },\r
\r
        /**\r
         * Returns `true` if the passed value is a JavaScript Date object, `false` otherwise.\r
         * @param {Object} object The object to test.\r
         * @return {Boolean}\r
         */\r
        isDate: function(value) {\r
            return toString.call(value) === '[object Date]';\r
        },\r
\r
        /**\r
         * Returns 'true' if the passed value is a String that matches the MS Date JSON\r
         * encoding format.\r
         * @param {String} value The string to test.\r
         * @return {Boolean}\r
         */\r
        isMSDate: function(value) {\r
            if (!Ext.isString(value)) {\r
                return false;\r
            }\r
            return MSDateRe.test(value);\r
        },\r
\r
        /**\r
         * Returns `true` if the passed value is a JavaScript Object, `false` otherwise.\r
         * @param {Object} value The value to test.\r
         * @return {Boolean}\r
         * @method\r
         */\r
        isObject: (toString.call(null) === '[object Object]') ?\r
        function(value) {\r
            // check ownerDocument here as well to exclude DOM nodes\r
            return value !== null && value !== undefined && toString.call(value) === '[object Object]' && value.ownerDocument === undefined;\r
        } :\r
        function(value) {\r
            return toString.call(value) === '[object Object]';\r
        },\r
\r
        /**\r
         * @private\r
         */\r
        isSimpleObject: function(value) {\r
            return value instanceof Object && value.constructor === Object;\r
        },\r
\r
        /**\r
         * Returns `true` if the passed value is a JavaScript 'primitive', a string, number\r
         * or boolean.\r
         * @param {Object} value The value to test.\r
         * @return {Boolean}\r
         */\r
        isPrimitive: function(value) {\r
            var type = typeof value;\r
\r
            return type === 'string' || type === 'number' || type === 'boolean';\r
        },\r
\r
        /**\r
         * Returns `true` if the passed value is a JavaScript Function, `false` otherwise.\r
         * @param {Object} value The value to test.\r
         * @return {Boolean}\r
         * @method\r
         */\r
        isFunction:\r
        // Safari 3.x and 4.x returns 'function' for typeof <NodeList>, hence we need to fall back to using\r
        // Object.prototype.toString (slower)\r
        (typeof document !== 'undefined' && typeof document.getElementsByTagName('body') === 'function') ? function(value) {\r
            return !!value && toString.call(value) === '[object Function]';\r
        } : function(value) {\r
            return !!value && typeof value === 'function';\r
        },\r
\r
        /**\r
         * Returns `true` if the passed value is a number. Returns `false` for non-finite numbers.\r
         * @param {Object} value The value to test.\r
         * @return {Boolean}\r
         */\r
        isNumber: function(value) {\r
            return typeof value === 'number' && isFinite(value);\r
        },\r
\r
        /**\r
         * Validates that a value is numeric.\r
         * @param {Object} value Examples: 1, '1', '2.34'\r
         * @return {Boolean} True if numeric, false otherwise\r
         */\r
        isNumeric: function(value) {\r
            return !isNaN(parseFloat(value)) && isFinite(value);\r
        },\r
\r
        /**\r
         * Returns `true `if the passed value is a string.\r
         * @param {Object} value The value to test.\r
         * @return {Boolean}\r
         */\r
        isString: function(value) {\r
            return typeof value === 'string';\r
        },\r
\r
        /**\r
         * Returns `true` if the passed value is a boolean.\r
         *\r
         * @param {Object} value The value to test.\r
         * @return {Boolean}\r
         */\r
        isBoolean: function(value) {\r
            return typeof value === 'boolean';\r
        },\r
\r
        /**\r
         * Returns `true` if the passed value is an HTMLElement\r
         * @param {Object} value The value to test.\r
         * @return {Boolean}\r
         */\r
        isElement: function(value) {\r
            return value ? value.nodeType === 1 : false;\r
        },\r
\r
        /**\r
         * Returns `true` if the passed value is a TextNode\r
         * @param {Object} value The value to test.\r
         * @return {Boolean}\r
         */\r
        isTextNode: function(value) {\r
            return value ? value.nodeName === "#text" : false;\r
        },\r
\r
        /**\r
         * Returns `true` if the passed value is defined.\r
         * @param {Object} value The value to test.\r
         * @return {Boolean}\r
         */\r
        isDefined: function(value) {\r
            return typeof value !== 'undefined';\r
        },\r
\r
        /**\r
         * Returns `true` if the passed value is iterable, that is, if elements of it are addressable using array\r
         * notation with numeric indices, `false` otherwise.\r
         *\r
         * Arrays and function `arguments` objects are iterable. Also HTML collections such as `NodeList` and `HTMLCollection'\r
         * are iterable.\r
         *\r
         * @param {Object} value The value to test\r
         * @return {Boolean}\r
         */\r
        isIterable: function(value) {\r
            // To be iterable, the object must have a numeric length property and must not be a string or function.\r
            if (!value || typeof value.length !== 'number' || typeof value === 'string' || Ext.isFunction(value)) {\r
                return false;\r
            }\r
\r
            // Certain "standard" collections in IE (such as document.images) do not offer the correct\r
            // Javascript Object interface; specifically, they lack the propertyIsEnumerable method.\r
            // And the item property while it does exist is not typeof "function"\r
            if (!value.propertyIsEnumerable) {\r
                return !!value.item;\r
            }\r
\r
            // If it is a regular, interrogatable JS object (not an IE ActiveX object), then...\r
            // If it has its own property called "length", but not enumerable, it's iterable\r
            if (value.hasOwnProperty('length') && !value.propertyIsEnumerable('length')) {\r
                return true;\r
            }\r
\r
            // Test against whitelist which includes known iterable collection types\r
            return iterableRe.test(toString.call(value));\r
        },\r
\r
        /**\r
         * This method returns `true` if debug is enabled for the specified class. This is\r
         * done by checking the `Ext.debugConfig.hooks` config for the closest match to the\r
         * given `className`.\r
         * @param {String} className The name of the class.\r
         * @return {Boolean} `true` if debug is enabled for the specified class.\r
         */\r
        isDebugEnabled:\r
            //<debug>\r
            function (className, defaultEnabled) {\r
                var debugConfig = Ext.debugConfig.hooks;\r
\r
                if (debugConfig.hasOwnProperty(className)) {\r
                    return debugConfig[className];\r
                }\r
\r
                var enabled = debugConfig['*'],\r
                    prefixLength = 0;\r
\r
                if (defaultEnabled !== undefined) {\r
                    enabled = defaultEnabled;\r
                }\r
                if (!className) {\r
                    return enabled;\r
                }\r
\r
                for (var prefix in debugConfig) {\r
                    var value = debugConfig[prefix];\r
\r
                    // if prefix=='Ext' match 'Ext.foo.Bar' but not 'Ext4.foo.Bar'\r
                    if (className.charAt(prefix.length) === '.') {\r
                        if (className.substring(0, prefix.length) === prefix) {\r
                            if (prefixLength < prefix.length) {\r
                                prefixLength = prefix.length;\r
                                enabled = value;\r
                            }\r
                        }\r
                    }\r
                }\r
\r
                return enabled;\r
            } ||\r
            //</debug>\r
            emptyFn,\r
\r
        /**\r
         * Clone simple variables including array, {}-like objects, DOM nodes and Date without keeping the old reference.\r
         * A reference for the object itself is returned if it's not a direct descendant of Object. For model cloning,\r
         * see {@link Ext.data.Model#copy Model.copy}.\r
         *\r
         * @param {Object} item The variable to clone\r
         * @return {Object} clone\r
         */\r
        clone: function(item) {\r
            if (item === null || item === undefined) {\r
                return item;\r
            }\r
\r
            // DOM nodes\r
            // TODO proxy this to Ext.Element.clone to handle automatic id attribute changing\r
            // recursively\r
            if (item.nodeType && item.cloneNode) {\r
                return item.cloneNode(true);\r
            }\r
\r
            var type = toString.call(item),\r
                i, j, k, clone, key;\r
\r
            // Date\r
            if (type === '[object Date]') {\r
                return new Date(item.getTime());\r
            }\r
\r
            // Array\r
            if (type === '[object Array]') {\r
                i = item.length;\r
\r
                clone = [];\r
\r
                while (i--) {\r
                    clone[i] = Ext.clone(item[i]);\r
                }\r
            }\r
            // Object\r
            else if (type === '[object Object]' && item.constructor === Object) {\r
                clone = {};\r
\r
                for (key in item) {\r
                    clone[key] = Ext.clone(item[key]);\r
                }\r
\r
                if (enumerables) {\r
                    for (j = enumerables.length; j--;) {\r
                        k = enumerables[j];\r
                        if (item.hasOwnProperty(k)) {\r
                            clone[k] = item[k];\r
                        }\r
                    }\r
                }\r
            }\r
\r
            return clone || item;\r
        },\r
\r
        /**\r
         * @private\r
         * Generate a unique reference of Ext in the global scope, useful for sandboxing\r
         */\r
        getUniqueGlobalNamespace: function() {\r
            var uniqueGlobalNamespace = this.uniqueGlobalNamespace,\r
                i;\r
\r
            if (uniqueGlobalNamespace === undefined) {\r
                i = 0;\r
\r
                do {\r
                    uniqueGlobalNamespace = 'ExtBox' + (++i);\r
                } while (global[uniqueGlobalNamespace] !== undefined);\r
\r
                global[uniqueGlobalNamespace] = Ext;\r
                this.uniqueGlobalNamespace = uniqueGlobalNamespace;\r
            }\r
\r
            return uniqueGlobalNamespace;\r
        },\r
\r
        /**\r
         * @private\r
         */\r
        functionFactoryCache: {},\r
\r
        cacheableFunctionFactory: function() {\r
            var me = this,\r
                args = Array.prototype.slice.call(arguments),\r
                cache = me.functionFactoryCache,\r
                idx, fn, ln;\r
\r
             if (Ext.isSandboxed) {\r
                ln = args.length;\r
                if (ln > 0) {\r
                    ln--;\r
                    args[ln] = 'var Ext=window.' + Ext.name + ';' + args[ln];\r
                }\r
            }\r
            idx = args.join('');\r
            fn = cache[idx];\r
            if (!fn) {\r
                fn = Function.prototype.constructor.apply(Function.prototype, args);\r
\r
                cache[idx] = fn;\r
            }\r
            return fn;\r
        },\r
\r
        functionFactory: function() {\r
            var args = Array.prototype.slice.call(arguments),\r
                ln;\r
\r
            if (Ext.isSandboxed) {\r
                ln = args.length;\r
                if (ln > 0) {\r
                    ln--;\r
                    args[ln] = 'var Ext=window.' + Ext.name + ';' + args[ln];\r
                }\r
            }\r
\r
            return Function.prototype.constructor.apply(Function.prototype, args);\r
        },\r
\r
        /**\r
         * @private\r
         */\r
        Logger: {\r
        //<feature logger>\r
            log: function(message, priority) {\r
                if (message && global.console) {\r
                    if (!priority || !(priority in global.console)) {\r
                        priority = 'log';\r
                    }\r
                    message = '[' + priority.toUpperCase() + '] ' + message;\r
                    global.console[priority](message);\r
                }\r
            },\r
            verbose: function(message) {\r
                this.log(message, 'verbose');\r
            },\r
            info: function(message) {\r
                this.log(message, 'info');\r
            },\r
            warn: function(message) {\r
                this.log(message, 'warn');\r
            },\r
            error: function(message) {\r
                throw new Error(message);\r
            },\r
            deprecate: function(message) {\r
                this.log(message, 'warn');\r
            }\r
        } || {\r
        //</feature>\r
            verbose: emptyFn,\r
            log: emptyFn,\r
            info: emptyFn,\r
            warn: emptyFn,\r
            error: function(message) {\r
                throw new Error(message);\r
            },\r
            deprecate: emptyFn\r
        },\r
\r
        /**\r
         * @private\r
         */\r
        getElementById: function(id) {\r
            return document.getElementById(id);\r
        },\r
\r
        /**\r
         * @member Ext\r
         * @private\r
         */\r
        splitAndUnescape: (function() {\r
            var cache = {};\r
    \r
            return function(origin, delimiter) {\r
                if (!origin) {\r
                    return [];\r
                }\r
                else if (!delimiter) {\r
                    return [origin];\r
                }\r
    \r
                var replaceRe = cache[delimiter] || (cache[delimiter] = new RegExp('\\\\' + delimiter, 'g')),\r
                    result = [],\r
                    parts, part;\r
    \r
                parts = origin.split(delimiter);\r
    \r
                while ((part = parts.shift()) !== undefined) {\r
                    // If any of the parts ends with the delimiter that means\r
                    // the delimiter was escaped and the split was invalid. Roll back.\r
                    while (part.charAt(part.length - 1) === '\\' && parts.length > 0) {\r
                        part = part + delimiter + parts.shift();\r
                    }\r
    \r
                    // Now that we have split the parts, unescape the delimiter char\r
                    part = part.replace(replaceRe, delimiter);\r
    \r
                    result.push(part);\r
                }\r
    \r
                return result;\r
            };\r
        })()\r
    }); // Ext.apply(Ext\r
\r
    Ext.returnTrue.$nullFn = Ext.returnId.$nullFn = true;\r
}());\r