docs/source/Function.html

   1 <html>
   2 <head>
   3   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   4   <title>The source code</title>
   5     <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
   6     <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
   7 </head>
   8 <body  onload="prettyPrint();">
   9     <pre class="prettyprint lang-js">/*!
  10  * Ext JS Library 3.3.0
  11  * Copyright(c) 2006-2010 Ext JS, Inc.
  12  * licensing@extjs.com
  13  * http://www.extjs.com/license
  14  */
  15 <div id="cls-Ext.util.Functions"></div>/**
  16  * @class Ext.util.Functions
  17  * @singleton
  18  */
  19 Ext.util.Functions = {
  20     <div id="method-Ext.util.Functions-createInterceptor"></div>/**
  21      * Creates an interceptor function. The passed function is called before the original one. If it returns false,
  22      * the original one is not called. The resulting function returns the results of the original function.
  23      * The passed function is called with the parameters of the original function. Example usage:
  24      * <pre><code>
  25 var sayHi = function(name){
  26     alert('Hi, ' + name);
  27 }
  28
  29 sayHi('Fred'); // alerts "Hi, Fred"
  30
  31 // create a new function that validates input without
  32 // directly modifying the original function:
  33 var sayHiToFriend = Ext.createInterceptor(sayHi, function(name){
  34     return name == 'Brian';
  35 });
  36
  37 sayHiToFriend('Fred');  // no alert
  38 sayHiToFriend('Brian'); // alerts "Hi, Brian"
  39        </code></pre>
  40      * @param {Function} origFn The original function.
  41      * @param {Function} newFn The function to call before the original
  42      * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the passed function is executed.
  43      * <b>If omitted, defaults to the scope in which the original function is called or the browser window.</b>
  44      * @return {Function} The new function
  45      */
  46     createInterceptor: function(origFn, newFn, scope) {
  47         var method = origFn;
  48         if (!Ext.isFunction(newFn)) {
  49             return origFn;
  50         }
  51         else {
  52             return function() {
  53                 var me = this,
  54                     args = arguments;
  55                 newFn.target = me;
  56                 newFn.method = origFn;
  57                 return (newFn.apply(scope || me || window, args) !== false) ?
  58                         origFn.apply(me || window, args) :
  59                         null;
  60             };
  61         }
  62     },
  63
  64     <div id="method-Ext.util.Functions-createDelegate"></div>/**
  65      * Creates a delegate (callback) that sets the scope to obj.
  66      * Call directly on any function. Example: <code>Ext.createDelegate(this.myFunction, this, [arg1, arg2])</code>
  67      * Will create a function that is automatically scoped to obj so that the <tt>this</tt> variable inside the
  68      * callback points to obj. Example usage:
  69      * <pre><code>
  70 var sayHi = function(name){
  71     // Note this use of "this.text" here.  This function expects to
  72     // execute within a scope that contains a text property.  In this
  73     // example, the "this" variable is pointing to the btn object that
  74     // was passed in createDelegate below.
  75     alert('Hi, ' + name + '. You clicked the "' + this.text + '" button.');
  76 }
  77
  78 var btn = new Ext.Button({
  79     text: 'Say Hi',
  80     renderTo: Ext.getBody()
  81 });
  82
  83 // This callback will execute in the scope of the
  84 // button instance. Clicking the button alerts
  85 // "Hi, Fred. You clicked the "Say Hi" button."
  86 btn.on('click', Ext.createDelegate(sayHi, btn, ['Fred']));
  87        </code></pre>
  88      * @param {Function} fn The function to delegate.
  89      * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the function is executed.
  90      * <b>If omitted, defaults to the browser window.</b>
  91      * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
  92      * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
  93      * if a number the args are inserted at the specified position
  94      * @return {Function} The new function
  95      */
  96     createDelegate: function(fn, obj, args, appendArgs) {
  97         if (!Ext.isFunction(fn)) {
  98             return fn;
  99         }
 100         return function() {
 101             var callArgs = args || arguments;
 102             if (appendArgs === true) {
 103                 callArgs = Array.prototype.slice.call(arguments, 0);
 104                 callArgs = callArgs.concat(args);
 105             }
 106             else if (Ext.isNumber(appendArgs)) {
 107                 callArgs = Array.prototype.slice.call(arguments, 0);
 108                 // copy arguments first
 109                 var applyArgs = [appendArgs, 0].concat(args);
 110                 // create method call params
 111                 Array.prototype.splice.apply(callArgs, applyArgs);
 112                 // splice them in
 113             }
 114             return fn.apply(obj || window, callArgs);
 115         };
 116     },
 117
 118     <div id="method-Ext.util.Functions-defer"></div>/**
 119      * Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
 120      * <pre><code>
 121 var sayHi = function(name){
 122     alert('Hi, ' + name);
 123 }
 124
 125 // executes immediately:
 126 sayHi('Fred');
 127
 128 // executes after 2 seconds:
 129 Ext.defer(sayHi, 2000, this, ['Fred']);
 130
 131 // this syntax is sometimes useful for deferring
 132 // execution of an anonymous function:
 133 Ext.defer(function(){
 134     alert('Anonymous');
 135 }, 100);
 136        </code></pre>
 137      * @param {Function} fn The function to defer.
 138      * @param {Number} millis The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)
 139      * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the function is executed.
 140      * <b>If omitted, defaults to the browser window.</b>
 141      * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
 142      * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
 143      * if a number the args are inserted at the specified position
 144      * @return {Number} The timeout id that can be used with clearTimeout
 145      */
 146     defer: function(fn, millis, obj, args, appendArgs) {
 147         fn = Ext.util.Functions.createDelegate(fn, obj, args, appendArgs);
 148         if (millis > 0) {
 149             return setTimeout(fn, millis);
 150         }
 151         fn();
 152         return 0;
 153     },
 154
 155
 156     <div id="method-Ext.util.Functions-createSequence"></div>/**
 157      * Create a combined function call sequence of the original function + the passed function.
 158      * The resulting function returns the results of the original function.
 159      * The passed fcn is called with the parameters of the original function. Example usage:
 160      *
 161
 162 var sayHi = function(name){
 163     alert('Hi, ' + name);
 164 }
 165
 166 sayHi('Fred'); // alerts "Hi, Fred"
 167
 168 var sayGoodbye = Ext.createSequence(sayHi, function(name){
 169     alert('Bye, ' + name);
 170 });
 171
 172 sayGoodbye('Fred'); // both alerts show
 173
 174      * @param {Function} origFn The original function.
 175      * @param {Function} newFn The function to sequence
 176      * @param {Object} scope (optional) The scope (this reference) in which the passed function is executed.
 177      * If omitted, defaults to the scope in which the original function is called or the browser window.
 178      * @return {Function} The new function
 179      */
 180     createSequence: function(origFn, newFn, scope) {
 181         if (!Ext.isFunction(newFn)) {
 182             return origFn;
 183         }
 184         else {
 185             return function() {
 186                 var retval = origFn.apply(this || window, arguments);
 187                 newFn.apply(scope || this || window, arguments);
 188                 return retval;
 189             };
 190         }
 191     }
 192 };
 193
 194 /**
 195  * Shorthand for {@link Ext.util.Functions#defer}
 196  * @param {Function} fn The function to defer.
 197  * @param {Number} millis The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)
 198  * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the function is executed.
 199  * <b>If omitted, defaults to the browser window.</b>
 200  * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
 201  * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
 202  * if a number the args are inserted at the specified position
 203  * @return {Number} The timeout id that can be used with clearTimeout
 204  * @member Ext
 205  * @method defer
 206  */
 207
 208 Ext.defer = Ext.util.Functions.defer;
 209
 210 /**
 211  * Shorthand for {@link Ext.util.Functions#createInterceptor}
 212  * @param {Function} origFn The original function.
 213  * @param {Function} newFn The function to call before the original
 214  * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the passed function is executed.
 215  * <b>If omitted, defaults to the scope in which the original function is called or the browser window.</b>
 216  * @return {Function} The new function
 217  * @member Ext
 218  * @method defer
 219  */
 220
 221 Ext.createInterceptor = Ext.util.Functions.createInterceptor;
 222
 223 /**
 224  * Shorthand for {@link Ext.util.Functions#createSequence}
 225  * @param {Function} origFn The original function.
 226  * @param {Function} newFn The function to sequence
 227  * @param {Object} scope (optional) The scope (this reference) in which the passed function is executed.
 228  * If omitted, defaults to the scope in which the original function is called or the browser window.
 229  * @return {Function} The new function
 230  * @member Ext
 231  * @method defer
 232  */
 233
 234 Ext.createSequence = Ext.util.Functions.createSequence;
 235
 236 <div id="method-Ext-defer"></div>/**
 237  * Shorthand for {@link Ext.util.Functions#createDelegate}
 238  * @param {Function} fn The function to delegate.
 239  * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the function is executed.
 240  * <b>If omitted, defaults to the browser window.</b>
 241  * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
 242  * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
 243  * if a number the args are inserted at the specified position
 244  * @return {Function} The new function
 245  * @member Ext
 246  * @method defer
 247  */
 248 Ext.createDelegate = Ext.util.Functions.createDelegate;
 249 </pre>
 250 </body>
 251 </html>