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

/*\r
 * This file contains miscellaneous utility methods that depends on various helper classes\r
 * like `Ext.Array` and `Ext.Date`. Historically these methods were defined in Ext.js or\r
 * Ext-more.js but that creates circular dependencies so they were consolidated here.\r
 */\r
Ext.apply(Ext, {\r
// @define Ext.Util\r
// @require Ext\r
// @require Ext.lang.*\r
\r
    // shortcut for the special named scopes for listener scope resolution\r
    _namedScopes: {\r
        'this': { isThis: 1 },\r
        controller: { isController: 1 },\r
        // these two are private, used to indicate that listeners were declared on the\r
        // class body with either an unspecified scope, or scope:'controller'\r
        self: { isSelf: 1 },\r
        'self.controller': { isSelf: 1, isController: 1 }\r
    },\r
\r
    escapeId: (function(){\r
        var validIdRe = /^[a-zA-Z_][a-zA-Z0-9_\-]*$/i,\r
            escapeRx = /([\W]{1})/g,\r
            leadingNumRx = /^(\d)/g,\r
            escapeFn = function(match, capture){\r
                return "\\" + capture;\r
            },\r
            numEscapeFn = function(match, capture){\r
                return '\\00' + capture.charCodeAt(0).toString(16) + ' ';\r
            };\r
\r
        return function(id) {\r
            return validIdRe.test(id) ? id :\r
                // replace the number portion last to keep the trailing ' '\r
                // from being escaped\r
                id.replace(escapeRx, escapeFn).replace(leadingNumRx, numEscapeFn);\r
        };\r
    }()),\r
\r
    /**\r
     * @method callback\r
     * @member Ext\r
     * Execute a callback function in a particular scope. If `callback` argument is a\r
     * function reference, that is called. If it is a string, the string is assumed to\r
     * be the name of a method on the given `scope`. If no function is passed the call\r
     * is ignored.\r
     *\r
     * For example, these calls are equivalent:\r
     *\r
     *      var myFunc = this.myFunc;\r
     *\r
     *      Ext.callback('myFunc', this, [arg1, arg2]);\r
     *      Ext.callback(myFunc, this, [arg1, arg2]);\r
     *\r
     *      Ext.isFunction(myFunc) && this.myFunc(arg1, arg2);\r
     *\r
     * @param {Function/String} callback The callback function to execute or the name of\r
     * the callback method on the provided `scope`.\r
     * @param {Object} [scope] The scope in which `callback` should be invoked. If `callback`\r
     * is a string this object provides the method by that name. If this is `null` then\r
     * the `caller` is used to resolve the scope to a `ViewController` or the proper\r
     * `defaultListenerScope`.\r
     * @param {Array} [args] The arguments to pass to the function.\r
     * @param {Number} [delay] Pass a number to delay the call by a number of milliseconds.\r
     * @param {Object} [caller] The object calling the callback. This is used to resolve\r
     * named methods when no explicit `scope` is provided.\r
     * @param {Object} [defaultScope=caller] The default scope to return if none is found.\r
     * @return The value returned by the callback or `undefined` (if there is a `delay`\r
     * or if the `callback` is not a function).\r
     */\r
    callback: function (callback, scope, args, delay, caller, defaultScope) {\r
        if (!callback) {\r
            return;\r
        }\r
\r
        var namedScope = (scope in Ext._namedScopes);\r
        \r
        if (callback.charAt) { // if (isString(fn))\r
            if ((!scope || namedScope) && caller) {\r
                scope = caller.resolveListenerScope(namedScope ? scope : defaultScope);\r
            }\r
            //<debug>\r
            if (!scope || !Ext.isObject(scope)) {\r
                Ext.raise('Named method "' + callback + '" requires a scope object');\r
            }\r
            if (!Ext.isFunction(scope[callback])) {\r
                Ext.raise('No method named "' + callback + '" on ' +\r
                                (scope.$className || 'scope object'));\r
            }\r
            //</debug>\r
\r
            callback = scope[callback];\r
        } else if (namedScope) {\r
            scope = defaultScope || caller;\r
        } else if (!scope) {\r
            scope = caller;\r
        }\r
        \r
        var ret;\r
\r
        if (callback && Ext.isFunction(callback)) {\r
            scope = scope || Ext.global;\r
            if (delay) {\r
                Ext.defer(callback, delay, scope, args);\r
            } else if (Ext.elevateFunction) {\r
                ret = Ext.elevateFunction(callback, scope, args);\r
            } else if (args) {\r
                ret = callback.apply(scope, args);\r
            } else {\r
                ret = callback.call(scope);\r
            }\r
        }\r
\r
        return ret;\r
    },\r
\r
    /**\r
     * @method coerce\r
     * @member Ext\r
     * Coerces the first value if possible so that it is comparable to the second value.\r
     *\r
     * Coercion only works between the basic atomic data types String, Boolean, Number, Date, null and undefined.\r
     *\r
     * Numbers and numeric strings are coerced to Dates using the value as the millisecond era value.\r
     *\r
     * Strings are coerced to Dates by parsing using the {@link Ext.Date#defaultFormat defaultFormat}.\r
     * \r
     * For example\r
     *\r
     *     Ext.coerce('false', true);\r
     *     \r
     * returns the boolean value `false` because the second parameter is of type `Boolean`.\r
     * \r
     * @param {Mixed} from The value to coerce\r
     * @param {Mixed} to The value it must be compared against\r
     * @return The coerced value.\r
     */\r
    coerce: function(from, to) {\r
        var fromType = Ext.typeOf(from),\r
            toType = Ext.typeOf(to),\r
            isString = typeof from === 'string';\r
\r
        if (fromType !== toType) {\r
            switch (toType) {\r
                case 'string':\r
                    return String(from);\r
                case 'number':\r
                    return Number(from);\r
                case 'boolean':\r
                    return isString && (!from || from === 'false') ? false : Boolean(from);\r
                case 'null':\r
                    return isString && (!from || from === 'null') ? null : from;\r
                case 'undefined':\r
                    return isString && (!from || from === 'undefined') ? undefined : from;\r
                case 'date':\r
                    return isString && isNaN(from) ? Ext.Date.parse(from, Ext.Date.defaultFormat) : Date(Number(from));\r
            }\r
        }\r
        return from;\r
    },\r
\r
    /**\r
     * @method copyTo\r
     * @member Ext\r
     * Copies a set of named properties fom the source object to the destination object.\r
     *\r
     * Example:\r
     *\r
     *     var foo = { a: 1, b: 2, c: 3 };\r
     *\r
     *     var bar = Ext.copyTo({}, foo, 'a,c');\r
     *     // bar = { a: 1, c: 3 };\r
     *\r
     * Important note: To borrow class prototype methods, use {@link Ext.Base#borrow} instead.\r
     *\r
     * @param {Object} dest The destination object.\r
     * @param {Object} source The source object.\r
     * @param {String/String[]} names Either an Array of property names, or a comma-delimited list\r
     * of property names to copy.\r
     * @param {Boolean} [usePrototypeKeys=false] Pass `true` to copy keys off of the\r
     * prototype as well as the instance.\r
     * @return {Object} The `dest` object.\r
     * @deprecated 6.0.1 Use {@link Ext#copy Ext.copy} instead. This old method\r
     * would copy the named preoperties even if they did not exist in the source which\r
     * could produce `undefined` values in the destination.\r
     */\r
    copyTo: function (dest, source, names, usePrototypeKeys) {\r
        if (typeof names === 'string') {\r
            names = names.split(Ext.propertyNameSplitRe);\r
        }\r
\r
        for (var name, i = 0, n = names ? names.length : 0; i < n; i++) {\r
            name = names[i];\r
\r
            if (usePrototypeKeys || source.hasOwnProperty(name)) {\r
                dest[name] = source[name];\r
            }\r
        }\r
\r
        return dest;\r
    },\r
    /**\r
     * @method copy\r
     * @member Ext\r
     * Copies a set of named properties fom the source object to the destination object.\r
     *\r
     * Example:\r
     *\r
     *     var foo = { a: 1, b: 2, c: 3 };\r
     *\r
     *     var bar = Ext.copy({}, foo, 'a,c');\r
     *     // bar = { a: 1, c: 3 };\r
     *\r
     * Important note: To borrow class prototype methods, use {@link Ext.Base#borrow} instead.\r
     *\r
     * @param {Object} dest The destination object.\r
     * @param {Object} source The source object.\r
     * @param {String/String[]} names Either an Array of property names, or a comma-delimited list\r
     * of property names to copy.\r
     * @param {Boolean} [usePrototypeKeys=false] Pass `true` to copy keys off of the\r
     * prototype as well as the instance.\r
     * @return {Object} The `dest` object.\r
     */\r
    copy: function (dest, source, names, usePrototypeKeys) {\r
        if (typeof names === 'string') {\r
            names = names.split(Ext.propertyNameSplitRe);\r
        }\r
\r
        for (var name, i = 0, n = names ? names.length : 0; i < n; i++) {\r
            name = names[i];\r
\r
            // Only copy a property if the source actually *has* that property.\r
            // If we are including prototype properties, then ensure that a property of\r
            // that name can be found *somewhere* in the prototype chain (otherwise we'd be copying undefined in which may break things)\r
            if (source.hasOwnProperty(name) || (usePrototypeKeys && name in source)) {\r
                dest[name] = source[name];\r
            }\r
        }\r
\r
        return dest;\r
    },\r
\r
    propertyNameSplitRe: /[,;\s]+/,\r
\r
    /**\r
     * @method copyToIf\r
     * @member Ext\r
     * Copies a set of named properties fom the source object to the destination object\r
     * if the destination object does not already have them.\r
     *\r
     * Example:\r
     *\r
     *     var foo = { a: 1, b: 2, c: 3 };\r
     *\r
     *     var bar = Ext.copyToIf({ a:42 }, foo, 'a,c');\r
     *     // bar = { a: 42, c: 3 };\r
     *\r
     * @param {Object} destination The destination object.\r
     * @param {Object} source The source object.\r
     * @param {String/String[]} names Either an Array of property names, or a single string\r
     * with a list of property names separated by ",", ";" or spaces.\r
     * @return {Object} The `dest` object.\r
     * @deprecated 6.0.1 Use {@link Ext#copyIf Ext.copyIf} instead. This old method\r
     * would copy the named preoperties even if they did not exist in the source which\r
     * could produce `undefined` values in the destination.\r
     */\r
    copyToIf: function (destination, source, names) {\r
        if (typeof names === 'string') {\r
            names = names.split(Ext.propertyNameSplitRe);\r
        }\r
\r
        for (var name, i = 0, n = names ? names.length : 0; i < n; i++) {\r
            name = names[i];\r
\r
            if (destination[name] === undefined) {\r
                destination[name] = source[name];\r
            }\r
        }\r
\r
        return destination;\r
    },\r
\r
    /**\r
     * @method copyIf\r
     * @member Ext\r
     * Copies a set of named properties fom the source object to the destination object\r
     * if the destination object does not already have them.\r
     *\r
     * Example:\r
     *\r
     *     var foo = { a: 1, b: 2, c: 3 };\r
     *\r
     *     var bar = Ext.copyIf({ a:42 }, foo, 'a,c');\r
     *     // bar = { a: 42, c: 3 };\r
     *\r
     * @param {Object} destination The destination object.\r
     * @param {Object} source The source object.\r
     * @param {String/String[]} names Either an Array of property names, or a single string\r
     * with a list of property names separated by ",", ";" or spaces.\r
     * @return {Object} The `dest` object.\r
     */\r
    copyIf: function (destination, source, names) {\r
        if (typeof names === 'string') {\r
            names = names.split(Ext.propertyNameSplitRe);\r
        }\r
\r
        for (var name, i = 0, n = names ? names.length : 0; i < n; i++) {\r
            name = names[i];\r
\r
            // Only copy a property if the destination has no property by that name\r
            if (!(name in destination) && (name in source)) {\r
                destination[name] = source[name];\r
            }\r
        }\r
\r
        return destination;\r
    },\r
\r
    /**\r
     * @method extend\r
     * @member Ext\r
     * This method deprecated. Use {@link Ext#define Ext.define} instead.\r
     * @param {Function} superclass\r
     * @param {Object} overrides\r
     * @return {Function} The subclass constructor from the <tt>overrides</tt> parameter, or a generated one if not provided.\r
     * @deprecated 4.0.0 Use {@link Ext#define Ext.define} instead\r
     */\r
    extend: (function() {\r
        // inline overrides\r
        var objectConstructor = Object.prototype.constructor,\r
            inlineOverrides = function(o) {\r
            for (var m in o) {\r
                if (!o.hasOwnProperty(m)) {\r
                    continue;\r
                }\r
                this[m] = o[m];\r
            }\r
        };\r
\r
        return function(subclass, superclass, overrides) {\r
            // First we check if the user passed in just the superClass with overrides\r
            if (Ext.isObject(superclass)) {\r
                overrides = superclass;\r
                superclass = subclass;\r
                subclass = overrides.constructor !== objectConstructor ? overrides.constructor : function() {\r
                    superclass.apply(this, arguments);\r
                };\r
            }\r
\r
            //<debug>\r
            if (!superclass) {\r
                Ext.raise({\r
                    sourceClass: 'Ext',\r
                    sourceMethod: 'extend',\r
                    msg: 'Attempting to extend from a class which has not been loaded on the page.'\r
                });\r
            }\r
            //</debug>\r
\r
            // We create a new temporary class\r
            var F = function() {},\r
                subclassProto, superclassProto = superclass.prototype;\r
\r
            F.prototype = superclassProto;\r
            subclassProto = subclass.prototype = new F();\r
            subclassProto.constructor = subclass;\r
            subclass.superclass = superclassProto;\r
\r
            if (superclassProto.constructor === objectConstructor) {\r
                superclassProto.constructor = superclass;\r
            }\r
\r
            subclass.override = function(overrides) {\r
                Ext.override(subclass, overrides);\r
            };\r
\r
            subclassProto.override = inlineOverrides;\r
            subclassProto.proto = subclassProto;\r
\r
            subclass.override(overrides);\r
            subclass.extend = function(o) {\r
                return Ext.extend(subclass, o);\r
            };\r
\r
            return subclass;\r
        };\r
    }()),\r
\r
    /**\r
     * @method iterate\r
     * @member Ext\r
     * Iterates either an array or an object. This method delegates to\r
     * {@link Ext.Array#each Ext.Array.each} if the given value is iterable, and {@link Ext.Object#each Ext.Object.each} otherwise.\r
     *\r
     * @param {Object/Array} object The object or array to be iterated.\r
     * @param {Function} fn The function to be called for each iteration. See and {@link Ext.Array#each Ext.Array.each} and\r
     * {@link Ext.Object#each Ext.Object.each} for detailed lists of arguments passed to this function depending on the given object\r
     * type that is being iterated.\r
     * @param {Object} [scope] The scope (`this` reference) in which the specified function is executed.\r
     * Defaults to the object being iterated itself.\r
     */\r
    iterate: function(object, fn, scope) {\r
        if (Ext.isEmpty(object)) {\r
            return;\r
        }\r
\r
        if (scope === undefined) {\r
            scope = object;\r
        }\r
\r
        if (Ext.isIterable(object)) {\r
            Ext.Array.each.call(Ext.Array, object, fn, scope);\r
        }\r
        else {\r
            Ext.Object.each.call(Ext.Object, object, fn, scope);\r
        }\r
    },\r
\r
    _resourcePoolRe: /^[<]([^<>@:]*)(?:[@]([^<>@:]+))?[>](.+)$/,\r
\r
    /**\r
     * Resolves a resource URL that may contain a resource pool identifier token at the\r
     * front. The tokens are formatted as HTML tags "&lt;poolName@packageName&gt;" followed\r
     * by a normal relative path. This token is only processed if present at the first\r
     * character of the given string.\r
     *\r
     * These tokens are parsed and the pieces are then passed to the\r
     * {@link Ext#getResourcePath} method.\r
     *\r
     * For example:\r
     *\r
     *      [{\r
     *          xtype: 'image',\r
     *          src: '<shared>images/foo.png'\r
     *      },{\r
     *          xtype: 'image',\r
     *          src: '<@package>images/foo.png'\r
     *      },{\r
     *          xtype: 'image',\r
     *          src: '<shared@package>images/foo.png'\r
     *      }]\r
     *\r
     * In the above example, "shared" is the name of a Sencha Cmd resource pool and\r
     * "package" is the name of a Sencha Cmd package.\r
     *\r
     * @param {String} url The URL that may contain a resource pool token at the front.\r
     * @return {String}\r
     * @since 6.0.1\r
     */\r
    resolveResource: function (url) {\r
        var ret = url,\r
            m;\r
\r
        if (url && url.charAt(0) === '<') {\r
            m = Ext._resourcePoolRe.exec(url);\r
            if (m) {\r
                ret = Ext.getResourcePath(m[3], m[1], m[2]);\r
            }\r
        }\r
\r
        return ret;\r
    },\r
\r
    /**\r
     *\r
     * @member Ext\r
     * @method urlEncode\r
     * @inheritdoc Ext.Object#toQueryString\r
     * @deprecated 4.0.0 Use {@link Ext.Object#toQueryString} instead\r
     */\r
    urlEncode: function () {\r
        var args = Ext.Array.from(arguments),\r
            prefix = '';\r
\r
        // Support for the old `pre` argument\r
        if (Ext.isString(args[1])) {\r
            prefix = args[1] + '&';\r
            args[1] = false;\r
        }\r
\r
        return prefix + Ext.Object.toQueryString.apply(Ext.Object, args);\r
    },\r
\r
    /**\r
     * Alias for {@link Ext.Object#fromQueryString}.\r
     *\r
     * @member Ext\r
     * @method urlDecode\r
     * @inheritdoc Ext.Object#fromQueryString\r
     * @deprecated 4.0.0 Use {@link Ext.Object#fromQueryString} instead\r
     */\r
    urlDecode: function() {\r
        return Ext.Object.fromQueryString.apply(Ext.Object, arguments);\r
    },\r
\r
    /**\r
     * @method getScrollbarSize\r
     * @member Ext\r
     * Returns the size of the browser scrollbars. This can differ depending on\r
     * operating system settings, such as the theme or font size.\r
     * @param {Boolean} [force] true to force a recalculation of the value.\r
     * @return {Object} An object containing scrollbar sizes.\r
     * @return {Number} return.width The width of the vertical scrollbar.\r
     * @return {Number} return.height The height of the horizontal scrollbar.\r
     */\r
    getScrollbarSize: function (force) {\r
        //<debug>\r
        if (!Ext.isDomReady) {\r
            Ext.raise("getScrollbarSize called before DomReady");\r
        }\r
        //</debug>\r
\r
        var scrollbarSize = Ext._scrollbarSize;\r
\r
        if (force || !scrollbarSize) {\r
            var db = document.body,\r
                div = document.createElement('div');\r
\r
            div.style.width = div.style.height = '100px';\r
            div.style.overflow = 'scroll';\r
            div.style.position = 'absolute';\r
\r
            db.appendChild(div); // now we can measure the div...\r
\r
            // at least in iE9 the div is not 100px - the scrollbar size is removed!\r
            Ext._scrollbarSize = scrollbarSize = {\r
                width: div.offsetWidth - div.clientWidth,\r
                height: div.offsetHeight - div.clientHeight\r
            };\r
\r
            db.removeChild(div);\r
        }\r
\r
        return scrollbarSize;\r
    },\r
\r
    /**\r
     * @method typeOf\r
     * @member Ext\r
     * Returns the type of the given variable in string format. List of possible values are:\r
     *\r
     * - `undefined`: If the given value is `undefined`\r
     * - `null`: If the given value is `null`\r
     * - `string`: If the given value is a string\r
     * - `number`: If the given value is a number\r
     * - `boolean`: If the given value is a boolean value\r
     * - `date`: If the given value is a `Date` object\r
     * - `function`: If the given value is a function reference\r
     * - `object`: If the given value is an object\r
     * - `array`: If the given value is an array\r
     * - `regexp`: If the given value is a regular expression\r
     * - `element`: If the given value is a DOM Element\r
     * - `textnode`: If the given value is a DOM text node and contains something other than whitespace\r
     * - `whitespace`: If the given value is a DOM text node and contains only whitespace\r
     *\r
     * @param {Object} value\r
     * @return {String}\r
     */\r
    typeOf: (function () {\r
        var nonWhitespaceRe = /\S/,\r
            toString = Object.prototype.toString,\r
            typeofTypes = {\r
                number: 1,\r
                string: 1,\r
                'boolean': 1,\r
                'undefined': 1\r
            },\r
            toStringTypes = {\r
                '[object Array]'  : 'array',\r
                '[object Date]'   : 'date',\r
                '[object Boolean]': 'boolean',\r
                '[object Number]' : 'number',\r
                '[object RegExp]' : 'regexp'\r
            };\r
\r
        return function(value) {\r
            if (value === null) {\r
                return 'null';\r
            }\r
\r
            var type = typeof value,\r
                ret, typeToString;\r
\r
            if (typeofTypes[type]) {\r
                return type;\r
            }\r
\r
            ret = toStringTypes[typeToString = toString.call(value)];\r
            if (ret) {\r
                return ret;\r
            }\r
\r
            if (type === 'function') {\r
                return 'function';\r
            }\r
\r
            if (type === 'object') {\r
                if (value.nodeType !== undefined) {\r
                    if (value.nodeType === 3) {\r
                        return nonWhitespaceRe.test(value.nodeValue) ? 'textnode' : 'whitespace';\r
                    }\r
                    else {\r
                        return 'element';\r
                    }\r
                }\r
\r
                return 'object';\r
            }\r
\r
            //<debug>\r
            Ext.raise({\r
                sourceClass: 'Ext',\r
                sourceMethod: 'typeOf',\r
                msg: 'Failed to determine the type of "' + value + '".'\r
            });\r
            //</debug>\r
\r
            return typeToString;\r
        };\r
    }()),\r
\r
    /**\r
     * A global factory method to instantiate a class from a config object. For example,\r
     * these two calls are equivalent:\r
     *\r
     *     Ext.factory({ text: 'My Button' }, 'Ext.Button');\r
     *     Ext.create('Ext.Button', { text: 'My Button' });\r
     *\r
     * If an existing instance is also specified, it will be updated with the supplied config object. This is useful\r
     * if you need to either create or update an object, depending on if an instance already exists. For example:\r
     *\r
     *     var button;\r
     *     button = Ext.factory({ text: 'New Button' }, 'Ext.Button', button);     // Button created\r
     *     button = Ext.factory({ text: 'Updated Button' }, 'Ext.Button', button); // Button updated\r
     *\r
     * @param {Object} config  The config object to instantiate or update an instance with.\r
     * @param {String} [classReference]  The class to instantiate from (if there is a default).\r
     * @param {Object} [instance]  The instance to update.\r
     * @param [aliasNamespace]\r
     * @member Ext\r
     */\r
    factory: function(config, classReference, instance, aliasNamespace) {\r
        var manager = Ext.ClassManager,\r
            newInstance;\r
\r
        // If config is falsy or a valid instance, destroy the current instance\r
        // (if it exists) and replace with the new one\r
        if (!config || config.isInstance) {\r
            if (instance && instance !== config) {\r
                instance.destroy();\r
            }\r
\r
            return config;\r
        }\r
\r
        if (aliasNamespace) {\r
             // If config is a string value, treat it as an alias\r
            if (typeof config === 'string') {\r
                return manager.instantiateByAlias(aliasNamespace + '.' + config);\r
            }\r
            // Same if 'type' is given in config\r
            else if (Ext.isObject(config) && 'type' in config) {\r
                return manager.instantiateByAlias(aliasNamespace + '.' + config.type, config);\r
            }\r
        }\r
\r
        if (config === true) {\r
            //<debug>\r
            if (!instance && !classReference) {\r
                Ext.raise('[Ext.factory] Cannot determine type of class to create');\r
            }\r
            //</debug>\r
            return instance || Ext.create(classReference);\r
        }\r
\r
        //<debug>\r
        if (!Ext.isObject(config)) {\r
            Ext.raise("Invalid config, must be a valid config object");\r
        }\r
        //</debug>\r
\r
        if ('xtype' in config) {\r
            newInstance = manager.instantiateByAlias('widget.' + config.xtype, config);\r
        }\r
        else if ('xclass' in config) {\r
            newInstance = Ext.create(config.xclass, config);\r
        }\r
\r
        if (newInstance) {\r
            if (instance) {\r
                instance.destroy();\r
            }\r
\r
            return newInstance;\r
        }\r
\r
        if (instance) {\r
            return instance.setConfig(config);\r
        }\r
\r
        return Ext.create(classReference, config);\r
    },\r
\r
    /**\r
     * @method log\r
     * @member Ext\r
     * Logs a message. If a console is present it will be used. On Opera, the method\r
     * "opera.postError" is called. In other cases, the message is logged to an array\r
     * "Ext.log.out". An attached debugger can watch this array and view the log. The\r
     * log buffer is limited to a maximum of "Ext.log.max" entries (defaults to 250).\r
     *\r
     * If additional parameters are passed, they are joined and appended to the message.\r
     * A technique for tracing entry and exit of a function is this:\r
     *\r
     *     function foo () {\r
     *         Ext.log({ indent: 1 }, '>> foo');\r
     *\r
     *         // log statements in here or methods called from here will be indented\r
     *         // by one step\r
     *\r
     *         Ext.log({ outdent: 1 }, '<< foo');\r
     *     }\r
     *\r
     * This method does nothing in a release build.\r
     *\r
     * @param {String/Object} [options] The message to log or an options object with any\r
     * of the following properties:\r
     *\r
     *  - `msg`: The message to log (required).\r
     *  - `level`: One of: "error", "warn", "info" or "log" (the default is "log").\r
     *  - `dump`: An object to dump to the log as part of the message.\r
     *  - `stack`: True to include a stack trace in the log.\r
     *  - `indent`: Cause subsequent log statements to be indented one step.\r
     *  - `outdent`: Cause this and following statements to be one step less indented.\r
     *\r
     * @param {String...} [message] The message to log (required unless specified in\r
     * options object).\r
     */\r
    log:\r
    //<debug>\r
        (function () {\r
            /*\r
             * Iterate through an object to dump its content into a string.\r
             * For example:\r
             *     {\r
             *         style: {\r
             *             lineWidth: 1\r
             *         },\r
             *         label: {},\r
             *         marker: {\r
             *             strokeStyle: "#555",\r
             *             radius: 3,\r
             *             size: 3\r
             *         },\r
             *         subStyle: {\r
             *             fillStyle: [\r
             *                 0: "#133987",\r
             *                 1: "#1c55ca",\r
             *                 2: "#4d7fe6"\r
             *             ]\r
             *         },\r
             *         markerSubStyle: {}\r
             *     } \r
             *\r
             * @param {Object} object The object to iterate\r
             * @param {Number} [level] Current level of identation (and recursion). Default is 0.\r
             * @param {Number} [maxLevel] Maximum level of recursion. Default is 3.\r
             * @param {Boolean} [withFunctions] Include functions in the output.\r
             * @return {String} The string with the contents of the object\r
             */\r
            var primitiveRe = /string|number|boolean/;\r
            function dumpObject (object, level, maxLevel, withFunctions) {\r
                var member, type, value, name, prefix, suffix,\r
                    members = [];\r
\r
                if (Ext.isArray(object)) {\r
                    prefix = '[';\r
                    suffix = ']';\r
                } else if (Ext.isObject(object)) {\r
                    prefix = '{';\r
                    suffix = '}';\r
                }\r
                if (!maxLevel) {\r
                    maxLevel = 3;\r
                }\r
                if (level > maxLevel) {\r
                    return prefix+'...'+suffix;\r
                }\r
\r
                level = level || 1;\r
                var spacer = (new Array(level)).join('    ');\r
\r
                // Cannot use Ext.encode since it can recurse endlessly\r
                for (name in object) {\r
                    if (object.hasOwnProperty(name)) {\r
                        value = object[name];\r
\r
                        type = typeof value;\r
                        if (type === 'function') {\r
                            if (!withFunctions) {\r
                                continue;\r
                            }\r
                            member = type;\r
                        } else if (type === 'undefined') {\r
                            member = type;\r
                        } else if (value === null || primitiveRe.test(type) || Ext.isDate(value)) {\r
                            member = Ext.encode(value);\r
                        } else if (Ext.isArray(value)) {\r
                            member = dumpObject(value, level+1, maxLevel, withFunctions);\r
                        } else if (Ext.isObject(value)) {\r
                            member = dumpObject(value, level+1, maxLevel, withFunctions);\r
                        } else {\r
                            member = type;\r
                        }\r
                        members.push(spacer + name + ': ' + member);    // or Ext.encode(name)\r
                    }\r
                }\r
                if (members.length) {\r
                    return prefix + '\n    '+ members.join(',\n    ') + '\n'+spacer+suffix;\r
                }\r
                return prefix+suffix;\r
            }\r
\r
            function log (message) {\r
                var options, dump,\r
                    con = Ext.global.console,\r
                    level = 'log',\r
                    indent = log.indent || 0,\r
                    prefix, stack, fn, out, max;\r
\r
                log.indent = indent;\r
\r
                if (typeof message !== 'string') {\r
                    options = message;\r
                    message = options.msg || '';\r
                    level = options.level || level;\r
                    dump = options.dump;\r
                    stack = options.stack;\r
                    prefix = options.prefix;\r
                    fn = options.fn;\r
\r
                    if (options.indent) {\r
                        ++log.indent;\r
                    } else if (options.outdent) {\r
                        log.indent = indent = Math.max(indent - 1, 0);\r
                    }\r
\r
                    if (dump && !(con && con.dir)) {\r
                        message += dumpObject(dump);\r
                        dump = null;\r
                    }\r
                }\r
\r
                if (arguments.length > 1) {\r
                    message += Array.prototype.slice.call(arguments, 1).join('');\r
                }\r
\r
                if (prefix) {\r
                    message = prefix + ' - ' + message;\r
                }\r
\r
                message = indent ? Ext.String.repeat(' ', log.indentSize * indent) + message : message;\r
                // w/o console, all messages are equal, so munge the level into the message:\r
                if (level !== 'log') {\r
                    message = '[' + level.charAt(0).toUpperCase() + '] ' + message;\r
                }\r
\r
                if (fn) {\r
                    message += '\nCaller: ' + fn.toString();\r
                }\r
\r
                // Not obvious, but 'console' comes and goes when Firebug is turned on/off, so\r
                // an early test may fail either direction if Firebug is toggled.\r
                //\r
                if (con) { // if (Firebug-like console)\r
                    if (con[level]) {\r
                        con[level](message);\r
                    } else {\r
                        con.log(message);\r
                    }\r
\r
                    if (dump) {\r
                        con.dir(dump);\r
                    }\r
\r
                    if (stack && con.trace) {\r
                        // Firebug's console.error() includes a trace already...\r
                        if (!con.firebug || level !== 'error') {\r
                            con.trace();\r
                        }\r
                    }\r
                } else if (Ext.isOpera) {\r
                    opera.postError(message); // jshint ignore:line\r
                } else {\r
                    out = log.out;\r
                    max = log.max;\r
\r
                    if (out.length >= max) {\r
                        // this formula allows out.max to change (via debugger), where the\r
                        // more obvious "max/4" would not quite be the same\r
                        Ext.Array.erase(out, 0, out.length - 3 * Math.floor(max / 4)); // keep newest 75%\r
                    }\r
\r
                    out.push(message);\r
                }\r
\r
                // Mostly informational, but the Ext.Error notifier uses them:\r
                ++log.count;\r
                ++log.counters[level];\r
            }\r
\r
            function logx (level, args) {\r
                if (typeof args[0] === 'string') {\r
                    args.unshift({});\r
                }\r
                args[0].level = level;\r
                log.apply(this, args);\r
            }\r
\r
            log.error = function () {\r
                logx('error', Array.prototype.slice.call(arguments));\r
            };\r
            log.info = function () {\r
                logx('info', Array.prototype.slice.call(arguments));\r
            };\r
            log.warn = function () {\r
                logx('warn', Array.prototype.slice.call(arguments));\r
            };\r
\r
            log.count = 0;\r
            log.counters = { error: 0, warn: 0, info: 0, log: 0 };\r
            log.indentSize = 2;\r
            log.out = [];\r
            log.max = 750;\r
\r
            return log;\r
        }()) ||\r
    //</debug>\r
        (function () {\r
            var nullLog = function () {};\r
            nullLog.info = nullLog.warn = nullLog.error = Ext.emptyFn;\r
            return nullLog;\r
        }())\r
});\r