+
+Ext.Function = {
+
+<span id='Ext-Function-method-flexSetter'> /**
+</span> * A very commonly used method throughout the framework. It acts as a wrapper around another method
+ * which originally accepts 2 arguments for <code>name</code> and <code>value</code>.
+ * The wrapped function then allows "flexible" value setting of either:
+ *
+ * <ul>
+ * <li><code>name</code> and <code>value</code> as 2 arguments</li>
+ * <li>one single object argument with multiple key - value pairs</li>
+ * </ul>
+ *
+ * For example:
+ * <pre><code>
+var setValue = Ext.Function.flexSetter(function(name, value) {
+ this[name] = value;
+});
+
+// Afterwards
+// Setting a single name - value
+setValue('name1', 'value1');
+
+// Settings multiple name - value pairs
+setValue({
+ name1: 'value1',
+ name2: 'value2',
+ name3: 'value3'
+});
+ * </code></pre>
+ * @param {Function} setter
+ * @returns {Function} flexSetter
+ */
+ flexSetter: function(fn) {
+ return function(a, b) {
+ var k, i;
+
+ if (a === null) {
+ return this;
+ }
+
+ if (typeof a !== 'string') {
+ for (k in a) {
+ if (a.hasOwnProperty(k)) {
+ fn.call(this, k, a[k]);
+ }
+ }
+
+ if (Ext.enumerables) {
+ for (i = Ext.enumerables.length; i--;) {
+ k = Ext.enumerables[i];
+ if (a.hasOwnProperty(k)) {
+ fn.call(this, k, a[k]);
+ }
+ }
+ }
+ } else {
+ fn.call(this, a, b);
+ }
+
+ return this;
+ };
+ },
+
+<span id='Ext-Function-method-bind'> /**
+</span> * Create a new function from the provided <code>fn</code>, change <code>this</code> to the provided scope, optionally
+ * overrides arguments for the call. (Defaults to the arguments passed by the caller)
+ *
+ * @param {Function} fn The function to delegate.
+ * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the function is executed.
+ * <b>If omitted, defaults to the browser window.</b>
+ * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
+ * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
+ * if a number the args are inserted at the specified position
+ * @return {Function} The new function
+ */
+ bind: function(fn, scope, args, appendArgs) {
+ var method = fn,
+ applyArgs;
+
+ return function() {
+ var callArgs = args || arguments;
+
+ if (appendArgs === true) {
+ callArgs = Array.prototype.slice.call(arguments, 0);
+ callArgs = callArgs.concat(args);
+ }
+ else if (Ext.isNumber(appendArgs)) {
+ callArgs = Array.prototype.slice.call(arguments, 0); // copy arguments first
+ applyArgs = [appendArgs, 0].concat(args); // create method call params
+ Array.prototype.splice.apply(callArgs, applyArgs); // splice them in
+ }
+
+ return method.apply(scope || window, callArgs);
+ };
+ },
+
+<span id='Ext-Function-method-pass'> /**
+</span> * Create a new function from the provided <code>fn</code>, the arguments of which are pre-set to `args`.
+ * New arguments passed to the newly created callback when it's invoked are appended after the pre-set ones.
+ * This is especially useful when creating callbacks.
+ * For example:
+ *
+ var originalFunction = function(){
+ alert(Ext.Array.from(arguments).join(' '));
+ };
+
+ var callback = Ext.Function.pass(originalFunction, ['Hello', 'World']);
+
+ callback(); // alerts 'Hello World'
+ callback('by Me'); // alerts 'Hello World by Me'
+
+ * @param {Function} fn The original function
+ * @param {Array} args The arguments to pass to new callback
+ * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the function is executed.
+ * @return {Function} The new callback function
+ */
+ pass: function(fn, args, scope) {
+ if (args) {
+ args = Ext.Array.from(args);
+ }
+
+ return function() {
+ return fn.apply(scope, args.concat(Ext.Array.toArray(arguments)));
+ };
+ },
+
+<span id='Ext-Function-method-alias'> /**
+</span> * Create an alias to the provided method property with name <code>methodName</code> of <code>object</code>.
+ * Note that the execution scope will still be bound to the provided <code>object</code> itself.
+ *
+ * @param {Object/Function} object
+ * @param {String} methodName
+ * @return {Function} aliasFn
+ */
+ alias: function(object, methodName) {
+ return function() {
+ return object[methodName].apply(object, arguments);
+ };
+ },
+
+<span id='Ext-Function-method-createInterceptor'> /**
+</span> * Creates an interceptor function. The passed function is called before the original one. If it returns false,