[extjs.git] / extjs / packages / core / src / lang / Function.js

/**\r
 * @class Ext.Function\r
 *\r
 * A collection of useful static methods to deal with function callbacks.\r
 * @singleton\r
 */\r
Ext.Function = (function() {\r
// @define Ext.lang.Function\r
// @define Ext.Function\r
// @require Ext\r
// @require Ext.lang.Array\r
    var lastTime = 0,\r
        animFrameId,\r
        animFrameHandlers = [],\r
        animFrameNoArgs = [],\r
        idSource = 0,\r
        animFrameMap = {},\r
        win = window,\r
        global = Ext.global,\r
        hasImmediate = !!(global.setImmediate && global.clearImmediate),\r
        requestAnimFrame = win.requestAnimationFrame || win.webkitRequestAnimationFrame ||\r
            win.mozRequestAnimationFrame || win.oRequestAnimationFrame ||\r
            function(callback) {\r
                var currTime = Ext.now(),\r
                    timeToCall = Math.max(0, 16 - (currTime - lastTime)),\r
                    id = win.setTimeout(function() {\r
                        callback(currTime + timeToCall);\r
                    }, timeToCall);\r
                lastTime = currTime + timeToCall;\r
                return id;\r
            },\r
        fireHandlers = function() {\r
            var len = animFrameHandlers.length,\r
                id, i, handler;\r
\r
            animFrameId = null;\r
            // Fire all animation frame handlers in one go\r
            for (i = 0; i < len; i++) {\r
                handler = animFrameHandlers[i];\r
                id = handler[3];\r
                \r
                // Check if this timer has been canceled; its map entry is going to be removed\r
                if (animFrameMap[id]) {\r
                    handler[0].apply(handler[1] || global, handler[2] || animFrameNoArgs);\r
                    delete animFrameMap[id];\r
                }\r
            }\r
\r
            // Clear all fired animation frame handlers, don't forget that new handlers\r
            // could have been created in user handler functions called in the loop above\r
            animFrameHandlers = animFrameHandlers.slice(len);\r
        },\r
        fireElevatedHandlers = function() {\r
            Ext.elevateFunction(fireHandlers);\r
        },\r
\r
    ExtFunction = {\r
        /**\r
         * A very commonly used method throughout the framework. It acts as a wrapper around another method\r
         * which originally accepts 2 arguments for `name` and `value`.\r
         * The wrapped function then allows "flexible" value setting of either:\r
         *\r
         * - `name` and `value` as 2 arguments\r
         * - one single object argument with multiple key - value pairs\r
         *\r
         * For example:\r
         *\r
         *     var setValue = Ext.Function.flexSetter(function(name, value) {\r
         *         this[name] = value;\r
         *     });\r
         *\r
         *     // Afterwards\r
         *     // Setting a single name - value\r
         *     setValue('name1', 'value1');\r
         *\r
         *     // Settings multiple name - value pairs\r
         *     setValue({\r
         *         name1: 'value1',\r
         *         name2: 'value2',\r
         *         name3: 'value3'\r
         *     });\r
         *\r
         * @param {Function} setter The single value setter method.\r
         * @param {String} setter.name The name of the value being set.\r
         * @param {Object} setter.value The value being set.\r
         * @return {Function}\r
         */\r
        flexSetter: function(setter) {\r
            return function(name, value) {\r
                var k, i;\r
\r
                if (name !== null) {\r
                    if (typeof name !== 'string') {\r
                        for (k in name) {\r
                            if (name.hasOwnProperty(k)) {\r
                                setter.call(this, k, name[k]);\r
                            }\r
                        }\r
\r
                        if (Ext.enumerables) {\r
                            for (i = Ext.enumerables.length; i--;) {\r
                                k = Ext.enumerables[i];\r
                                if (name.hasOwnProperty(k)) {\r
                                    setter.call(this, k, name[k]);\r
                                }\r
                            }\r
                        }\r
                    } else {\r
                        setter.call(this, name, value);\r
                    }\r
                }\r
\r
                return this;\r
            };\r
        },\r
\r
        /**\r
         * Create a new function from the provided `fn`, change `this` to the provided scope,\r
         * optionally overrides arguments for the call. Defaults to the arguments passed by\r
         * the caller.\r
         *\r
         * {@link Ext#bind Ext.bind} is alias for {@link Ext.Function#bind Ext.Function.bind}\r
         * \r
         * **NOTE:** This method is deprecated. Use the standard `bind` method of JavaScript\r
         * `Function` instead:\r
         * \r
         *      function foo () {\r
         *          ...\r
         *      }\r
         *      \r
         *      var fn = foo.bind(this);\r
         *\r
         * This method is unavailable natively on IE8 and IE/Quirks but Ext JS provides a\r
         * "polyfill" to emulate the important features of the standard `bind` method. In\r
         * particular, the polyfill only provides binding of "this" and optional arguments.\r
         * \r
         * @param {Function} fn The function to delegate.\r
         * @param {Object} scope (optional) The scope (`this` reference) in which the function is executed.\r
         * **If omitted, defaults to the default global environment object (usually the browser window).**\r
         * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)\r
         * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,\r
         * if a number the args are inserted at the specified position.\r
         * @return {Function} The new function.\r
         */\r
        bind: function(fn, scope, args, appendArgs) {\r
            if (arguments.length === 2) {\r
                return function() {\r
                    return fn.apply(scope, arguments);\r
                };\r
            }\r
\r
            var method = fn,\r
                slice = Array.prototype.slice;\r
\r
            return function() {\r
                var callArgs = args || arguments;\r
\r
                if (appendArgs === true) {\r
                    callArgs = slice.call(arguments, 0);\r
                    callArgs = callArgs.concat(args);\r
                }\r
                else if (typeof appendArgs === 'number') {\r
                    callArgs = slice.call(arguments, 0); // copy arguments first\r
                    Ext.Array.insert(callArgs, appendArgs, args);\r
                }\r
\r
                return method.apply(scope || global, callArgs);\r
            };\r
        },\r
\r
        /**\r
         * Captures the given parameters for a later call to `Ext.callback`. This binding is\r
         * most useful for resolving scopes for example to an `Ext.app.ViewController`.\r
         *\r
         * The arguments match that of `Ext.callback` except for the `args` which, if provided\r
         * to this method, are prepended to any arguments supplied by the eventual caller of\r
         * the returned function.\r
         *\r
         * @return {Function} A function that, when called, uses `Ext.callback` to call the\r
         * captured `callback`.\r
         * @since 5.0.0\r
         */\r
        bindCallback: function (callback, scope, args, delay, caller) {\r
            return function () {\r
                var a = Ext.Array.slice(arguments);\r
                return Ext.callback(callback, scope, args ? args.concat(a) : a, delay, caller);\r
            };\r
        },\r
\r
        /**\r
         * Create a new function from the provided `fn`, the arguments of which are pre-set to `args`.\r
         * New arguments passed to the newly created callback when it's invoked are appended after the pre-set ones.\r
         * This is especially useful when creating callbacks.\r
         *\r
         * For example:\r
         *\r
         *     var originalFunction = function(){\r
         *         alert(Ext.Array.from(arguments).join(' '));\r
         *     };\r
         *\r
         *     var callback = Ext.Function.pass(originalFunction, ['Hello', 'World']);\r
         *\r
         *     callback(); // alerts 'Hello World'\r
         *     callback('by Me'); // alerts 'Hello World by Me'\r
         *\r
         * {@link Ext#pass Ext.pass} is alias for {@link Ext.Function#pass Ext.Function.pass}\r
         *\r
         * @param {Function} fn The original function.\r
         * @param {Array} args The arguments to pass to new callback.\r
         * @param {Object} scope (optional) The scope (`this` reference) in which the function is executed.\r
         * @return {Function} The new callback function.\r
         */\r
        pass: function(fn, args, scope) {\r
            if (!Ext.isArray(args)) {\r
                if (Ext.isIterable(args)) {\r
                    args = Ext.Array.clone(args);\r
                } else {\r
                    args = args !== undefined ? [args] : [];\r
                }\r
            }\r
\r
            return function() {\r
                var fnArgs = args.slice();\r
                fnArgs.push.apply(fnArgs, arguments);\r
                return fn.apply(scope || this, fnArgs);\r
            };\r
        },\r
\r
        /**\r
         * Create an alias to the provided method property with name `methodName` of `object`.\r
         * Note that the execution scope will still be bound to the provided `object` itself.\r
         *\r
         * @param {Object/Function} object\r
         * @param {String} methodName\r
         * @return {Function} aliasFn\r
         */\r
        alias: function(object, methodName) {\r
            return function() {\r
                return object[methodName].apply(object, arguments);\r
            };\r
        },\r
\r
        /**\r
         * Create a "clone" of the provided method. The returned method will call the given\r
         * method passing along all arguments and the "this" pointer and return its result.\r
         *\r
         * @param {Function} method\r
         * @return {Function} cloneFn\r
         */\r
        clone: function(method) {\r
            return function() {\r
                return method.apply(this, arguments);\r
            };\r
        },\r
\r
        /**\r
         * Creates an interceptor function. The passed function is called before the original one. If it returns false,\r
         * the original one is not called. The resulting function returns the results of the original function.\r
         * The passed function is called with the parameters of the original function. Example usage:\r
         *\r
         *     var sayHi = function(name){\r
         *         alert('Hi, ' + name);\r
         *     };\r
         *\r
         *     sayHi('Fred'); // alerts "Hi, Fred"\r
         *\r
         *     // create a new function that validates input without\r
         *     // directly modifying the original function:\r
         *     var sayHiToFriend = Ext.Function.createInterceptor(sayHi, function(name){\r
         *         return name === 'Brian';\r
         *     });\r
         *\r
         *     sayHiToFriend('Fred');  // no alert\r
         *     sayHiToFriend('Brian'); // alerts "Hi, Brian"\r
         *\r
         * @param {Function} origFn The original function.\r
         * @param {Function} newFn The function to call before the original.\r
         * @param {Object} [scope] The scope (`this` reference) in which the passed function is executed.\r
         * **If omitted, defaults to the scope in which the original function is called or the browser window.**\r
         * @param {Object} [returnValue=null] The value to return if the passed function return `false`.\r
         * @return {Function} The new function.\r
         */\r
        createInterceptor: function(origFn, newFn, scope, returnValue) {\r
            if (!Ext.isFunction(newFn)) {\r
                return origFn;\r
            } else {\r
                returnValue = Ext.isDefined(returnValue) ? returnValue : null;\r
                \r
                return function() {\r
                    var me = this,\r
                        args = arguments;\r
\r
                    return (newFn.apply(scope || me || global, args) !== false) ?\r
                                origFn.apply(me || global, args) : returnValue;\r
                };\r
            }\r
        },\r
\r
        /**\r
         * Creates a delegate (callback) which, when called, executes after a specific delay.\r
         *\r
         * @param {Function} fn The function which will be called on a delay when the returned function is called.\r
         * Optionally, a replacement (or additional) argument list may be specified.\r
         * @param {Number} delay The number of milliseconds to defer execution by whenever called.\r
         * @param {Object} scope (optional) The scope (`this` reference) used by the function at execution time.\r
         * @param {Array} args (optional) Override arguments for the call. (Defaults to the arguments passed by the caller)\r
         * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,\r
         * if a number the args are inserted at the specified position.\r
         * @return {Function} A function which, when called, executes the original function after the specified delay.\r
         */\r
        createDelayed: function(fn, delay, scope, args, appendArgs) {\r
            if (scope || args) {\r
                fn = Ext.Function.bind(fn, scope, args, appendArgs);\r
            }\r
\r
            return function() {\r
                var me = this,\r
                    args = Array.prototype.slice.call(arguments);\r
\r
                setTimeout(function() {\r
                    if (Ext.elevateFunction) {\r
                        Ext.elevateFunction(fn, me, args);\r
                    } else {\r
                        fn.apply(me, args);\r
                    }\r
                }, delay);\r
            };\r
        },\r
\r
        /**\r
         * Calls this function after the number of milliseconds specified, optionally in a specific scope. Example usage:\r
         *\r
         *     var sayHi = function(name){\r
         *         alert('Hi, ' + name);\r
         *     }\r
         *\r
         *     // executes immediately:\r
         *     sayHi('Fred');\r
         *\r
         *     // executes after 2 seconds:\r
         *     Ext.Function.defer(sayHi, 2000, this, ['Fred']);\r
         *\r
         *     // this syntax is sometimes useful for deferring\r
         *     // execution of an anonymous function:\r
         *     Ext.Function.defer(function(){\r
         *         alert('Anonymous');\r
         *     }, 100);\r
         *\r
         * {@link Ext#defer Ext.defer} is alias for {@link Ext.Function#defer Ext.Function.defer}\r
         *\r
         * @param {Function} fn The function to defer.\r
         * @param {Number} millis The number of milliseconds for the `setTimeout` call\r
         * (if less than or equal to 0 the function is executed immediately).\r
         * @param {Object} scope (optional) The scope (`this` reference) in which the function is executed.\r
         * **If omitted, defaults to the browser window.**\r
         * @param {Array} [args] Overrides arguments for the call. Defaults to the arguments passed by the caller.\r
         * @param {Boolean/Number} [appendArgs=false] If `true` args are appended to call args instead of overriding,\r
         * or, if a number, then the args are inserted at the specified position.\r
         * @return {Number} The timeout id that can be used with `clearTimeout`.\r
         */\r
        defer: function(fn, millis, scope, args, appendArgs) {\r
            fn = Ext.Function.bind(fn, scope, args, appendArgs);\r
            if (millis > 0) {\r
                return setTimeout(function () {\r
                    if (Ext.elevateFunction) {\r
                        Ext.elevateFunction(fn);\r
                    } else {\r
                        fn();\r
                    }\r
                }, millis);\r
            }\r
            fn();\r
            return 0;\r
        },\r
\r
        /**\r
         * Calls this function repeatedly at a given interval, optionally in a specific scope.\r
         *\r
         * {@link Ext#defer Ext.defer} is alias for {@link Ext.Function#defer Ext.Function.defer}\r
         *\r
         * @param {Function} fn The function to defer.\r
         * @param {Number} millis The number of milliseconds for the `setInterval` call\r
         * @param {Object} scope (optional) The scope (`this` reference) in which the function is executed.\r
         * **If omitted, defaults to the browser window.**\r
         * @param {Array} [args] Overrides arguments for the call. Defaults to the arguments passed by the caller.\r
         * @param {Boolean/Number} [appendArgs=false] If `true` args are appended to call args instead of overriding,\r
         * or, if a number, then the args are inserted at the specified position.\r
         * @return {Number} The interval id that can be used with `clearInterval`.\r
         */\r
        interval: function(fn, millis, scope, args, appendArgs) {\r
            fn = Ext.Function.bind(fn, scope, args, appendArgs);\r
            return setInterval(function () {\r
                if (Ext.elevateFunction) {\r
                    Ext.elevateFunction(fn);\r
                } else {\r
                    fn();\r
                }\r
            }, millis);\r
        },\r
\r
        /**\r
         * Create a combined function call sequence of the original function + the passed function.\r
         * The resulting function returns the results of the original function.\r
         * The passed function is called with the parameters of the original function. Example usage:\r
         *\r
         *     var sayHi = function(name){\r
         *         alert('Hi, ' + name);\r
         *     };\r
         *\r
         *     sayHi('Fred'); // alerts "Hi, Fred"\r
         *\r
         *     var sayGoodbye = Ext.Function.createSequence(sayHi, function(name){\r
         *         alert('Bye, ' + name);\r
         *     });\r
         *\r
         *     sayGoodbye('Fred'); // both alerts show\r
         *\r
         * @param {Function} originalFn The original function.\r
         * @param {Function} newFn The function to sequence.\r
         * @param {Object} [scope] The scope (`this` reference) in which the passed function is executed.\r
         * If omitted, defaults to the scope in which the original function is called or the\r
         * default global environment object (usually the browser window).\r
         * @return {Function} The new function.\r
         */\r
        createSequence: function(originalFn, newFn, scope) {\r
            if (!newFn) {\r
                return originalFn;\r
            }\r
            else {\r
                return function() {\r
                    var result = originalFn.apply(this, arguments);\r
                    newFn.apply(scope || this, arguments);\r
                    return result;\r
                };\r
            }\r
        },\r
\r
        /**\r
         * Creates a delegate function, optionally with a bound scope which, when called, buffers\r
         * the execution of the passed function for the configured number of milliseconds.\r
         * If called again within that period, the impending invocation will be canceled, and the\r
         * timeout period will begin again.\r
         *\r
         * @param {Function} fn The function to invoke on a buffered timer.\r
         * @param {Number} buffer The number of milliseconds by which to buffer the invocation of the\r
         * function.\r
         * @param {Object} [scope] The scope (`this` reference) in which.\r
         * the passed function is executed. If omitted, defaults to the scope specified by the caller.\r
         * @param {Array} [args] Override arguments for the call. Defaults to the arguments\r
         * passed by the caller.\r
         * @return {Function} A function which invokes the passed function after buffering for the specified time.\r
         */\r
        createBuffered: function(fn, buffer, scope, args) {\r
            var timerId;\r
\r
            return function() {\r
                var callArgs = args || Array.prototype.slice.call(arguments, 0),\r
                    me = scope || this;\r
\r
                if (timerId) {\r
                    clearTimeout(timerId);\r
                }\r
\r
                timerId = setTimeout(function(){\r
                    if (Ext.elevateFunction) {\r
                        Ext.elevateFunction(fn, me, callArgs);\r
                    } else {\r
                        fn.apply(me, callArgs);\r
                    }\r
                }, buffer);\r
            };\r
        },\r
\r
        /**\r
        * Creates a wrapped function that, when invoked, defers execution until the next\r
        * animation frame\r
         * @private\r
         * @param {Function} fn The function to call.\r
         * @param {Object} [scope] The scope (`this` reference) in which the function is executed. Defaults to the window object.\r
         * @param {Array} [args] The argument list to pass to the function.\r
         * @param {Number} [queueStrategy=3] A bit flag that indicates how multiple calls to\r
         * the returned function within the same animation frame should be handled.\r
         *\r
         * - 1: All calls will be queued - FIFO order\r
         * - 2: Only the first call will be queued\r
         * - 3: The last call will replace all previous calls\r
         *\r
         * @return {Function}\r
         */\r
        createAnimationFrame: function(fn, scope, args, queueStrategy) {\r
            var timerId;\r
\r
            queueStrategy = queueStrategy || 3;\r
\r
            return function() {\r
                var callArgs = args || Array.prototype.slice.call(arguments, 0);\r
\r
                scope = scope || this;\r
\r
                if (queueStrategy === 3 && timerId) {\r
                    ExtFunction.cancelAnimationFrame(timerId);\r
                }\r
\r
                if ((queueStrategy & 1) || !timerId) {\r
                    timerId = ExtFunction.requestAnimationFrame(function() {\r
                        timerId = null;\r
                        fn.apply(scope, callArgs);\r
                    });\r
                }\r
            };\r
        },\r
\r
        /**\r
         * @private\r
         * Schedules the passed function to be called on the next animation frame.\r
         * @param {Function} fn The function to call.\r
         * @param {Object} [scope] The scope (`this` reference) in which the function is executed. Defaults to the window object.\r
         * @param {Mixed[]} [args] The argument list to pass to the function.\r
         *\r
         * @return {Number} Timer id for the new animation frame to use when canceling it.\r
         */\r
        requestAnimationFrame: function(fn, scope, args) {\r
            var id = ++idSource,  // Ids start at 1\r
                handler = Array.prototype.slice.call(arguments, 0);\r
\r
            handler[3] = id;\r
            animFrameMap[id] = 1; // A flag to indicate that the timer exists\r
            \r
            // We might be in fireHandlers at this moment but this new entry will not\r
            // be executed until the next frame\r
            animFrameHandlers.push(handler);\r
\r
            if (!animFrameId) {\r
                animFrameId = requestAnimFrame(Ext.elevateFunction ? fireElevatedHandlers : fireHandlers);\r
            }\r
            return id;\r
        },\r
\r
        cancelAnimationFrame: function(id) {\r
            // Don't remove any handlers from animFrameHandlers array, because\r
            // the might be in use at the moment (when cancelAnimationFrame is called).\r
            // Just remove the handler id from the map so it will not be executed\r
            delete animFrameMap[id];\r
        },\r
\r
        /**\r
         * Creates a throttled version of the passed function which, when called repeatedly and\r
         * rapidly, invokes the passed function only after a certain interval has elapsed since the\r
         * previous invocation.\r
         *\r
         * This is useful for wrapping functions which may be called repeatedly, such as\r
         * a handler of a mouse move event when the processing is expensive.\r
         *\r
         * @param {Function} fn The function to execute at a regular time interval.\r
         * @param {Number} interval The interval in milliseconds on which the passed function is executed.\r
         * @param {Object} [scope] The scope (`this` reference) in which\r
         * the passed function is executed. If omitted, defaults to the scope specified by the caller.\r
         * @return {Function} A function which invokes the passed function at the specified interval.\r
         */\r
        createThrottled: function(fn, interval, scope) {\r
            var lastCallTime = 0,\r
                elapsed,\r
                lastArgs,\r
                timer,\r
                execute = function() {\r
                    if (Ext.elevateFunction) {\r
                        Ext.elevateFunction(fn, scope, lastArgs);\r
                    } else {\r
                        fn.apply(scope, lastArgs);\r
                    }\r
                    lastCallTime = Ext.now();\r
                    timer = null;\r
                };\r
\r
            return function() {\r
                // Use scope of last call unless the creator specified a scope\r
                if (!scope) {\r
                    scope = this;\r
                }\r
                elapsed = Ext.now() - lastCallTime;\r
                lastArgs = arguments;\r
\r
                // If this is the first invocation, or the throttle interval has been reached, clear any\r
                // pending invocation, and call the target function now.\r
                if (elapsed >= interval) {\r
                    clearTimeout(timer);\r
                    execute();\r
                }\r
                // Throttle interval has not yet been reached. Only set the timer to fire if not already set.\r
                else if (!timer) {\r
                    timer = Ext.defer(execute, interval - elapsed);\r
                }\r
            };\r
        },\r
\r
        /**\r
         * Wraps the passed function in a barrier function which will call the passed function after the passed number of invocations.\r
         * @param {Number} count The number of invocations which will result in the calling of the passed function.\r
         * @param {Function} fn The function to call after the required number of invocations.\r
         * @param {Object} scope The scope (`this` reference) in which the function will be called.\r
         */    \r
        createBarrier: function(count, fn, scope) {\r
            return function() {\r
                if (!--count) {\r
                    fn.apply(scope, arguments);\r
                }\r
            };\r
        },\r
\r
        /**\r
         * Adds behavior to an existing method that is executed before the\r
         * original behavior of the function.  For example:\r
         * \r
         *     var soup = {\r
         *         contents: [],\r
         *         add: function(ingredient) {\r
         *             this.contents.push(ingredient);\r
         *         }\r
         *     };\r
         *     Ext.Function.interceptBefore(soup, "add", function(ingredient){\r
         *         if (!this.contents.length && ingredient !== "water") {\r
         *             // Always add water to start with\r
         *             this.contents.push("water");\r
         *         }\r
         *     });\r
         *     soup.add("onions");\r
         *     soup.add("salt");\r
         *     soup.contents; // will contain: water, onions, salt\r
         * \r
         * @param {Object} object The target object\r
         * @param {String} methodName Name of the method to override\r
         * @param {Function} fn Function with the new behavior.  It will\r
         * be called with the same arguments as the original method.  The\r
         * return value of this function will be the return value of the\r
         * new method.\r
         * @param {Object} [scope] The scope to execute the interceptor function. Defaults to the object.\r
         * @return {Function} The new function just created.\r
         */\r
        interceptBefore: function(object, methodName, fn, scope) {\r
            var method = object[methodName] || Ext.emptyFn;\r
\r
            return (object[methodName] = function() {\r
                var ret = fn.apply(scope || this, arguments);\r
                method.apply(this, arguments);\r
\r
                return ret;\r
            });\r
        },\r
\r
        /**\r
         * Adds behavior to an existing method that is executed after the\r
         * original behavior of the function.  For example:\r
         * \r
         *     var soup = {\r
         *         contents: [],\r
         *         add: function(ingredient) {\r
         *             this.contents.push(ingredient);\r
         *         }\r
         *     };\r
         *     Ext.Function.interceptAfter(soup, "add", function(ingredient){\r
         *         // Always add a bit of extra salt\r
         *         this.contents.push("salt");\r
         *     });\r
         *     soup.add("water");\r
         *     soup.add("onions");\r
         *     soup.contents; // will contain: water, salt, onions, salt\r
         * \r
         * @param {Object} object The target object\r
         * @param {String} methodName Name of the method to override\r
         * @param {Function} fn Function with the new behavior.  It will\r
         * be called with the same arguments as the original method.  The\r
         * return value of this function will be the return value of the\r
         * new method.\r
         * @param {Object} [scope] The scope to execute the interceptor function. Defaults to the object.\r
         * @return {Function} The new function just created.\r
         */\r
        interceptAfter: function(object, methodName, fn, scope) {\r
            var method = object[methodName] || Ext.emptyFn;\r
\r
            return (object[methodName] = function() {\r
                method.apply(this, arguments);\r
                return fn.apply(scope || this, arguments);\r
            });\r
        },\r
\r
        makeCallback: function (callback, scope) {\r
            //<debug>\r
            if (!scope[callback]) {\r
                if (scope.$className) {\r
                    Ext.raise('No method "' + callback + '" on ' + scope.$className);\r
                }\r
                Ext.raise('No method "' + callback + '"');\r
            }\r
            //</debug>\r
\r
            return function () {\r
                return scope[callback].apply(scope, arguments);\r
            };\r
        },\r
\r
        /**\r
         * Returns a wrapper function that caches the return value for previously\r
         * processed function argument(s).\r
         *\r
         * For example:\r
         *\r
         *      function factorial (value) {\r
         *          var ret = value;\r
         *\r
         *          while (--value > 1) {\r
         *              ret *= value;\r
         *          }\r
         *\r
         *          return ret;\r
         *      }\r
         *\r
         * Each call to `factorial` will loop and multiply to produce the answer. Using\r
         * this function we can wrap the above and cache its answers:\r
         *\r
         *      factorial = Ext.Function.memoize(factorial);\r
         *\r
         * The returned function operates in the same manner as before, but results are\r
         * stored in a cache to avoid calling the wrapped function when given the same\r
         * arguments.\r
         *\r
         *      var x = factorial(20);  // first time; call real factorial()\r
         *      var y = factorial(20);  // second time; return value from first call\r
         *\r
         * To support multi-argument methods, you will need to provide a `hashFn`.\r
         *\r
         *      function permutation (n, k) {\r
         *          return factorial(n) / factorial(n - k);\r
         *      }\r
         *\r
         *      permutation = Ext.Function.memoize(permutation, null, function (n, k) {\r
         *          n + '-' + k;\r
         *      });\r
         *\r
         * In this case, the `memoize` of `factorial` is sufficient optimization, but the\r
         * example is simply to illustrate how to generate a unique key for an expensive,\r
         * multi-argument method.\r
         *\r
         * **IMPORTANT**: This cache is unbounded so be cautious of memory leaks if the\r
         * `memoize`d function is kept indefinitely or is given an unbounded set of\r
         * possible arguments.\r
         *\r
         * @param {Function} fn Function to wrap.\r
         * @param {Object} scope Optional scope in which to execute the wrapped function.\r
         * @param {Function} hashFn Optional function used to compute a hash key for\r
         * storing the result, based on the arguments to the original function.\r
         * @return {Function} The caching wrapper function.\r
         * @since 6.0.0\r
         */\r
        memoize: function(fn, scope, hashFn) {\r
            var memo = {},\r
                isFunc = hashFn && Ext.isFunction(hashFn);\r
\r
            return function (value) {\r
                var key = isFunc ? hashFn.apply(scope, arguments) : value;\r
\r
                if (!(key in memo)) {\r
                    memo[key] = fn.apply(scope, arguments);\r
                }\r
\r
                return memo[key];\r
            };\r
        }\r
    }; // ExtFunction\r
\r
    /**\r
     * @member Ext\r
     * @method asap\r
     * Schedules the specified callback function to be executed on the next turn of the\r
     * event loop. Where available, this method uses the browser's `setImmediate` API. If\r
     * not available, this method substitutes `setTimeout(0)`. Though not a perfect\r
     * replacement for `setImmediate` it is sufficient for many use cases.\r
     *\r
     * For more details see [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/setImmediate).\r
     *\r
     * @param {Function} fn Callback function.\r
     * @param {Object} [scope] The scope for the callback (`this` pointer).\r
     * @param {Mixed[]} [parameters] Additional parameters to pass to `fn`.\r
     * @return {Number} A cancelation id for `{@link Ext#asapCancel}`.\r
     */\r
    Ext.asap = hasImmediate ?\r
            function (fn, scope, parameters) {\r
                if (scope != null || parameters != null) {\r
                    fn = ExtFunction.bind(fn, scope, parameters);\r
                }\r
                return setImmediate(function () {\r
                    if (Ext.elevateFunction) {\r
                        Ext.elevateFunction(fn);\r
                    } else {\r
                        fn();\r
                    }\r
                });\r
            } :\r
            function (fn, scope, parameters) {\r
                if (scope != null || parameters != null) {\r
                    fn = ExtFunction.bind(fn, scope, parameters);\r
                }\r
                return setTimeout(function () {\r
                    if (Ext.elevateFunction) {\r
                        Ext.elevateFunction(fn);\r
                    } else {\r
                        fn();\r
                    }\r
                }, 0, true);\r
            },\r
\r
    /**\r
     * @member Ext\r
     * @method asapCancel\r
     * Cancels a previously scheduled call to `{@link Ext#asap}`.\r
     *\r
     *      var asapId = Ext.asap(me.method, me);\r
     *      ...\r
     *\r
     *      if (nevermind) {\r
     *          Ext.apasCancel(asapId);\r
     *      }\r
     *\r
     * @param {Number} id The id returned by `{@link Ext#asap}`.\r
     */\r
    Ext.asapCancel = hasImmediate ?\r
        function(id) {\r
            clearImmediate(id);\r
        } : function(id) {\r
            clearTimeout(id);\r
        };\r
\r
    /**\r
     * @method\r
     * @member Ext\r
     * @inheritdoc Ext.Function#defer\r
     */\r
    Ext.defer = ExtFunction.defer;\r
\r
    /**\r
     * @method\r
     * @member Ext\r
     * @inheritdoc Ext.Function#interval\r
     */\r
    Ext.interval = ExtFunction.interval;\r
\r
    /**\r
     * @method\r
     * @member Ext\r
     * @inheritdoc Ext.Function#pass\r
     */\r
    Ext.pass = ExtFunction.pass;\r
\r
    /**\r
     * @method\r
     * @member Ext\r
     * @inheritdoc Ext.Function#bind\r
     */\r
    Ext.bind = ExtFunction.bind;\r
\r
    Ext.deferCallback = ExtFunction.requestAnimationFrame;\r
\r
    return ExtFunction;\r
})();\r