ext-base-debug-w-comments.js
上传用户:dawnssy
上传日期:2022-08-06
资源大小:9345k
文件大小:121k
源码类别:

JavaScript

开发平台:

JavaScript

  1. /*!  * Ext JS Library 3.1.0  * Copyright(c) 2006-2009 Ext JS, LLC  * licensing@extjs.com  * http://www.extjs.com/license  */ // for old browsers window.undefined = window.undefined; /**  * @class Ext  * Ext core utilities and functions.  * @singleton  */ Ext = {     /**      * The version of the framework      * @type String      */     version : '3.1.0' }; /**  * Copies all the properties of config to obj.  * @param {Object} obj The receiver of the properties  * @param {Object} config The source of the properties  * @param {Object} defaults A different object that will also be applied for default values  * @return {Object} returns obj  * @member Ext apply  */ Ext.apply = function(o, c, defaults){     // no "this" reference for friendly out of scope calls     if(defaults){         Ext.apply(o, defaults);     }     if(o && c && typeof c == 'object'){         for(var p in c){             o[p] = c[p];         }     }     return o; }; (function(){     var idSeed = 0,         toString = Object.prototype.toString,         ua = navigator.userAgent.toLowerCase(),         check = function(r){             return r.test(ua);         },         DOC = document,         isStrict = DOC.compatMode == "CSS1Compat",         isOpera = check(/opera/),         isChrome = check(/chrome/),         isWebKit = check(/webkit/),         isSafari = !isChrome && check(/safari/),         isSafari2 = isSafari && check(/applewebkit/4/), // unique to Safari 2         isSafari3 = isSafari && check(/version/3/),         isSafari4 = isSafari && check(/version/4/),         isIE = !isOpera && check(/msie/),         isIE7 = isIE && check(/msie 7/),         isIE8 = isIE && check(/msie 8/),         isIE6 = isIE && !isIE7 && !isIE8,         isGecko = !isWebKit && check(/gecko/),         isGecko2 = isGecko && check(/rv:1.8/),         isGecko3 = isGecko && check(/rv:1.9/),         isBorderBox = isIE && !isStrict,         isWindows = check(/windows|win32/),         isMac = check(/macintosh|mac os x/),         isAir = check(/adobeair/),         isLinux = check(/linux/),         isSecure = /^https/i.test(window.location.protocol);     // remove css image flicker     if(isIE6){         try{             DOC.execCommand("BackgroundImageCache", false, true);         }catch(e){}     }     Ext.apply(Ext, {         /**          * URL to a blank file used by Ext when in secure mode for iframe src and onReady src to prevent          * the IE insecure content warning (<tt>'about:blank'</tt>, except for IE in secure mode, which is <tt>'javascript:""'</tt>).          * @type String          */         SSL_SECURE_URL : isSecure && isIE ? 'javascript:""' : 'about:blank',         /**          * True if the browser is in strict (standards-compliant) mode, as opposed to quirks mode          * @type Boolean          */         isStrict : isStrict,         /**          * True if the page is running over SSL          * @type Boolean          */         isSecure : isSecure,         /**          * True when the document is fully initialized and ready for action          * @type Boolean          */         isReady : false,         /**          * True if the {@link Ext.Fx} Class is available          * @type Boolean          * @property enableFx          */         /**          * True to automatically uncache orphaned Ext.Elements periodically (defaults to true)          * @type Boolean          */         enableGarbageCollector : true,         /**          * True to automatically purge event listeners during garbageCollection (defaults to false).          * @type Boolean          */         enableListenerCollection : false,         /**          * EXPERIMENTAL - True to cascade listener removal to child elements when an element is removed.          * Currently not optimized for performance.          * @type Boolean          */         enableNestedListenerRemoval : false,         /**          * Indicates whether to use native browser parsing for JSON methods.          * This option is ignored if the browser does not support native JSON methods.          * <b>Note: Native JSON methods will not work with objects that have functions.          * Also, property names must be quoted, otherwise the data will not parse.</b> (Defaults to false)          * @type Boolean          */         USE_NATIVE_JSON : false,         /**          * Copies all the properties of config to obj if they don't already exist.          * @param {Object} obj The receiver of the properties          * @param {Object} config The source of the properties          * @return {Object} returns obj          */         applyIf : function(o, c){             if(o){                 for(var p in c){                     if(!Ext.isDefined(o[p])){                         o[p] = c[p];                     }                 }             }             return o;         },         /**          * Generates unique ids. If the element already has an id, it is unchanged          * @param {Mixed} el (optional) The element to generate an id for          * @param {String} prefix (optional) Id prefix (defaults "ext-gen")          * @return {String} The generated Id.          */         id : function(el, prefix){             return (el = Ext.getDom(el) || {}).id = el.id || (prefix || "ext-gen") + (++idSeed);         },         /**          * <p>Extends one class to create a subclass and optionally overrides members with the passed literal. This method          * also adds the function "override()" to the subclass that can be used to override members of the class.</p>          * For example, to create a subclass of Ext GridPanel:          * <pre><code> MyGridPanel = Ext.extend(Ext.grid.GridPanel, {     constructor: function(config) { //      Create configuration for this Grid.         var store = new Ext.data.Store({...});         var colModel = new Ext.grid.ColumnModel({...}); //      Create a new config object containing our computed properties //      *plus* whatever was in the config parameter.         config = Ext.apply({             store: store,             colModel: colModel         }, config);         MyGridPanel.superclass.constructor.call(this, config); //      Your postprocessing here     },     yourMethod: function() {         // etc.     } }); </code></pre>          *          * <p>This function also supports a 3-argument call in which the subclass's constructor is          * passed as an argument. In this form, the parameters are as follows:</p>          * <div class="mdetail-params"><ul>          * <li><code>subclass</code> : Function <div class="sub-desc">The subclass constructor.</div></li>          * <li><code>superclass</code> : Function <div class="sub-desc">The constructor of class being extended</div></li>          * <li><code>overrides</code> : Object <div class="sub-desc">A literal with members which are copied into the subclass's          * prototype, and are therefore shared among all instances of the new class.</div></li>          * </ul></div>          *          * @param {Function} superclass The constructor of class being extended.          * @param {Object} overrides <p>A literal with members which are copied into the subclass's          * prototype, and are therefore shared between all instances of the new class.</p>          * <p>This may contain a special member named <tt><b>constructor</b></tt>. This is used          * to define the constructor of the new class, and is returned. If this property is          * <i>not</i> specified, a constructor is generated and returned which just calls the          * superclass's constructor passing on its parameters.</p>          * <p><b>It is essential that you call the superclass constructor in any provided constructor. See example code.</b></p>          * @return {Function} The subclass constructor from the <code>overrides</code> parameter, or a generated one if not provided.          */         extend : function(){             // inline overrides             var io = function(o){                 for(var m in o){                     this[m] = o[m];                 }             };             var oc = Object.prototype.constructor;             return function(sb, sp, overrides){                 if(Ext.isObject(sp)){                     overrides = sp;                     sp = sb;                     sb = overrides.constructor != oc ? overrides.constructor : function(){sp.apply(this, arguments);};                 }                 var F = function(){},                     sbp,                     spp = sp.prototype;                 F.prototype = spp;                 sbp = sb.prototype = new F();                 sbp.constructor=sb;                 sb.superclass=spp;                 if(spp.constructor == oc){                     spp.constructor=sp;                 }                 sb.override = function(o){                     Ext.override(sb, o);                 };                 sbp.superclass = sbp.supr = (function(){                     return spp;                 });                 sbp.override = io;                 Ext.override(sb, overrides);                 sb.extend = function(o){return Ext.extend(sb, o);};                 return sb;             };         }(),         /**          * Adds a list of functions to the prototype of an existing class, overwriting any existing methods with the same name.          * Usage:<pre><code> Ext.override(MyClass, {     newMethod1: function(){         // etc.     },     newMethod2: function(foo){         // etc.     } }); </code></pre>          * @param {Object} origclass The class to override          * @param {Object} overrides The list of functions to add to origClass.  This should be specified as an object literal          * containing one or more methods.          * @method override          */         override : function(origclass, overrides){             if(overrides){                 var p = origclass.prototype;                 Ext.apply(p, overrides);                 if(Ext.isIE && overrides.hasOwnProperty('toString')){                     p.toString = overrides.toString;                 }             }         },         /**          * Creates namespaces to be used for scoping variables and classes so that they are not global.          * Specifying the last node of a namespace implicitly creates all other nodes. Usage:          * <pre><code> Ext.namespace('Company', 'Company.data'); Ext.namespace('Company.data'); // equivalent and preferable to above syntax Company.Widget = function() { ... } Company.data.CustomStore = function(config) { ... } </code></pre>          * @param {String} namespace1          * @param {String} namespace2          * @param {String} etc          * @return {Object} The namespace object. (If multiple arguments are passed, this will be the last namespace created)          * @method namespace          */         namespace : function(){             var o, d;             Ext.each(arguments, function(v) {                 d = v.split(".");                 o = window[d[0]] = window[d[0]] || {};                 Ext.each(d.slice(1), function(v2){                     o = o[v2] = o[v2] || {};                 });             });             return o;         },         /**          * Takes an object and converts it to an encoded URL. e.g. Ext.urlEncode({foo: 1, bar: 2}); would return "foo=1&bar=2".  Optionally, property values can be arrays, instead of keys and the resulting string that's returned will contain a name/value pair for each array value.          * @param {Object} o          * @param {String} pre (optional) A prefix to add to the url encoded string          * @return {String}          */         urlEncode : function(o, pre){             var empty,                 buf = [],                 e = encodeURIComponent;             Ext.iterate(o, function(key, item){                 empty = Ext.isEmpty(item);                 Ext.each(empty ? key : item, function(val){                     buf.push('&', e(key), '=', (!Ext.isEmpty(val) && (val != key || !empty)) ? (Ext.isDate(val) ? Ext.encode(val).replace(/"/g, '') : e(val)) : '');                 });             });             if(!pre){                 buf.shift();                 pre = '';             }             return pre + buf.join('');         },         /**          * Takes an encoded URL and and converts it to an object. Example: <pre><code> Ext.urlDecode("foo=1&bar=2"); // returns {foo: "1", bar: "2"} Ext.urlDecode("foo=1&bar=2&bar=3&bar=4", false); // returns {foo: "1", bar: ["2", "3", "4"]} </code></pre>          * @param {String} string          * @param {Boolean} overwrite (optional) Items of the same name will overwrite previous values instead of creating an an array (Defaults to false).          * @return {Object} A literal with members          */         urlDecode : function(string, overwrite){             if(Ext.isEmpty(string)){                 return {};             }             var obj = {},                 pairs = string.split('&'),                 d = decodeURIComponent,                 name,                 value;             Ext.each(pairs, function(pair) {                 pair = pair.split('=');                 name = d(pair[0]);                 value = d(pair[1]);                 obj[name] = overwrite || !obj[name] ? value :                             [].concat(obj[name]).concat(value);             });             return obj;         },         /**          * Appends content to the query string of a URL, handling logic for whether to place          * a question mark or ampersand.          * @param {String} url The URL to append to.          * @param {String} s The content to append to the URL.          * @return (String) The resulting URL          */         urlAppend : function(url, s){             if(!Ext.isEmpty(s)){                 return url + (url.indexOf('?') === -1 ? '?' : '&') + s;             }             return url;         },         /**          * Converts any iterable (numeric indices and a length property) into a true array          * Don't use this on strings. IE doesn't support "abc"[0] which this implementation depends on.          * For strings, use this instead: "abc".match(/./g) => [a,b,c];          * @param {Iterable} the iterable object to be turned into a true Array.          * @return (Array) array          */          toArray : function(){              return isIE ?                  function(a, i, j, res){                      res = [];                      for(var x = 0, len = a.length; x < len; x++) {                          res.push(a[x]);                      }                      return res.slice(i || 0, j || res.length);                  } :                  function(a, i, j){                      return Array.prototype.slice.call(a, i || 0, j || a.length);                  }          }(),         isIterable : function(v){             //check for array or arguments             if(Ext.isArray(v) || v.callee){                 return true;             }             //check for node list type             if(/NodeList|HTMLCollection/.test(toString.call(v))){                 return true;             }             //NodeList has an item and length property             //IXMLDOMNodeList has nextNode method, needs to be checked first.             return ((v.nextNode || v.item) && Ext.isNumber(v.length));         },         /**          * Iterates an array calling the supplied function.          * @param {Array/NodeList/Mixed} array The array to be iterated. If this          * argument is not really an array, the supplied function is called once.          * @param {Function} fn The function to be called with each item. If the          * supplied function returns false, iteration stops and this method returns          * the current <code>index</code>. This function is called with          * the following arguments:          * <div class="mdetail-params"><ul>          * <li><code>item</code> : <i>Mixed</i>          * <div class="sub-desc">The item at the current <code>index</code>          * in the passed <code>array</code></div></li>          * <li><code>index</code> : <i>Number</i>          * <div class="sub-desc">The current index within the array</div></li>          * <li><code>allItems</code> : <i>Array</i>          * <div class="sub-desc">The <code>array</code> passed as the first          * argument to <code>Ext.each</code>.</div></li>          * </ul></div>          * @param {Object} scope The scope (<code>this</code> reference) in which the specified function is executed.          * Defaults to the <code>item</code> at the current <code>index</code>          * within the passed <code>array</code>.          * @return See description for the fn parameter.          */         each : function(array, fn, scope){             if(Ext.isEmpty(array, true)){                 return;             }             if(!Ext.isIterable(array) || Ext.isPrimitive(array)){                 array = [array];             }             for(var i = 0, len = array.length; i < len; i++){                 if(fn.call(scope || array[i], array[i], i, array) === false){                     return i;                 };             }         },         /**          * Iterates either the elements in an array, or each of the properties in an object.          * <b>Note</b>: If you are only iterating arrays, it is better to call {@link #each}.          * @param {Object/Array} object The object or array to be iterated          * @param {Function} fn The function to be called for each iteration.          * The iteration will stop if the supplied function returns false, or          * all array elements / object properties have been covered. The signature          * varies depending on the type of object being interated:          * <div class="mdetail-params"><ul>          * <li>Arrays : <tt>(Object item, Number index, Array allItems)</tt>          * <div class="sub-desc">          * When iterating an array, the supplied function is called with each item.</div></li>          * <li>Objects : <tt>(String key, Object value, Object)</tt>          * <div class="sub-desc">          * When iterating an object, the supplied function is called with each key-value pair in          * the object, and the iterated object</div></li>          * </ul></div>          * @param {Object} scope The scope (<code>this</code> reference) in which the specified function is executed. Defaults to          * the <code>object</code> being iterated.          */         iterate : function(obj, fn, scope){             if(Ext.isEmpty(obj)){                 return;             }             if(Ext.isIterable(obj)){                 Ext.each(obj, fn, scope);                 return;             }else if(Ext.isObject(obj)){                 for(var prop in obj){                     if(obj.hasOwnProperty(prop)){                         if(fn.call(scope || obj, prop, obj[prop], obj) === false){                             return;                         };                     }                 }             }         },         /**          * Return the dom node for the passed String (id), dom node, or Ext.Element.          * Here are some examples:          * <pre><code> // gets dom node based on id var elDom = Ext.getDom('elId'); // gets dom node based on the dom node var elDom1 = Ext.getDom(elDom); // If we don&#39;t know if we are working with an // Ext.Element or a dom node use Ext.getDom function(el){     var dom = Ext.getDom(el);     // do something with the dom node }          * </code></pre>          * <b>Note</b>: the dom node to be found actually needs to exist (be rendered, etc)          * when this method is called to be successful.          * @param {Mixed} el          * @return HTMLElement          */         getDom : function(el){             if(!el || !DOC){                 return null;             }             return el.dom ? el.dom : (Ext.isString(el) ? DOC.getElementById(el) : el);         },         /**          * Returns the current document body as an {@link Ext.Element}.          * @return Ext.Element The document body          */         getBody : function(){             return Ext.get(DOC.body || DOC.documentElement);         },         /**          * Removes a DOM node from the document.          */         /**          * <p>Removes this element from the document, removes all DOM event listeners, and deletes the cache reference.          * All DOM event listeners are removed from this element. If {@link Ext#enableNestedListenerRemoval} is          * <code>true</code>, then DOM event listeners are also removed from all child nodes. The body node          * will be ignored if passed in.</p>          * @param {HTMLElement} node The node to remove          */         removeNode : isIE && !isIE8 ? function(){             var d;             return function(n){                 if(n && n.tagName != 'BODY'){                     (Ext.enableNestedListenerRemoval) ? Ext.EventManager.purgeElement(n, true) : Ext.EventManager.removeAll(n);                     d = d || DOC.createElement('div');                     d.appendChild(n);                     d.innerHTML = '';                     delete Ext.elCache[n.id];                 }             }         }() : function(n){             if(n && n.parentNode && n.tagName != 'BODY'){                 (Ext.enableNestedListenerRemoval) ? Ext.EventManager.purgeElement(n, true) : Ext.EventManager.removeAll(n);                 n.parentNode.removeChild(n);                 delete Ext.elCache[n.id];             }         },         /**          * <p>Returns true if the passed value is empty.</p>          * <p>The value is deemed to be empty if it is<div class="mdetail-params"><ul>          * <li>null</li>          * <li>undefined</li>          * <li>an empty array</li>          * <li>a zero length string (Unless the <tt>allowBlank</tt> parameter is <tt>true</tt>)</li>          * </ul></div>          * @param {Mixed} value The value to test          * @param {Boolean} allowBlank (optional) true to allow empty strings (defaults to false)          * @return {Boolean}          */         isEmpty : function(v, allowBlank){             return v === null || v === undefined || ((Ext.isArray(v) && !v.length)) || (!allowBlank ? v === '' : false);         },         /**          * Returns true if the passed value is a JavaScript array, otherwise false.          * @param {Mixed} value The value to test          * @return {Boolean}          */         isArray : function(v){             return toString.apply(v) === '[object Array]';         },         /**          * Returns true if the passed object is a JavaScript date object, otherwise false.          * @param {Object} object The object to test          * @return {Boolean}          */         isDate : function(v){             return toString.apply(v) === '[object Date]';         },         /**          * Returns true if the passed value is a JavaScript Object, otherwise false.          * @param {Mixed} value The value to test          * @return {Boolean}          */         isObject : function(v){             return !!v && Object.prototype.toString.call(v) === '[object Object]';         },         /**          * Returns true if the passed value is a JavaScript 'primitive', a string, number or boolean.          * @param {Mixed} value The value to test          * @return {Boolean}          */         isPrimitive : function(v){             return Ext.isString(v) || Ext.isNumber(v) || Ext.isBoolean(v);         },         /**          * Returns true if the passed value is a JavaScript Function, otherwise false.          * @param {Mixed} value The value to test          * @return {Boolean}          */         isFunction : function(v){             return toString.apply(v) === '[object Function]';         },         /**          * Returns true if the passed value is a number. Returns false for non-finite numbers.          * @param {Mixed} value The value to test          * @return {Boolean}          */         isNumber : function(v){             return typeof v === 'number' && isFinite(v);         },         /**          * Returns true if the passed value is a string.          * @param {Mixed} value The value to test          * @return {Boolean}          */         isString : function(v){             return typeof v === 'string';         },         /**          * Returns true if the passed value is a boolean.          * @param {Mixed} value The value to test          * @return {Boolean}          */         isBoolean : function(v){             return typeof v === 'boolean';         },         /**          * Returns true if the passed value is an HTMLElement          * @param {Mixed} value The value to test          * @return {Boolean}          */         isElement : function(v) {             return !!v && v.tagName;         },         /**          * Returns true if the passed value is not undefined.          * @param {Mixed} value The value to test          * @return {Boolean}          */         isDefined : function(v){             return typeof v !== 'undefined';         },         /**          * True if the detected browser is Opera.          * @type Boolean          */         isOpera : isOpera,         /**          * True if the detected browser uses WebKit.          * @type Boolean          */         isWebKit : isWebKit,         /**          * True if the detected browser is Chrome.          * @type Boolean          */         isChrome : isChrome,         /**          * True if the detected browser is Safari.          * @type Boolean          */         isSafari : isSafari,         /**          * True if the detected browser is Safari 3.x.          * @type Boolean          */         isSafari3 : isSafari3,         /**          * True if the detected browser is Safari 4.x.          * @type Boolean          */         isSafari4 : isSafari4,         /**          * True if the detected browser is Safari 2.x.          * @type Boolean          */         isSafari2 : isSafari2,         /**          * True if the detected browser is Internet Explorer.          * @type Boolean          */         isIE : isIE,         /**          * True if the detected browser is Internet Explorer 6.x.          * @type Boolean          */         isIE6 : isIE6,         /**          * True if the detected browser is Internet Explorer 7.x.          * @type Boolean          */         isIE7 : isIE7,         /**          * True if the detected browser is Internet Explorer 8.x.          * @type Boolean          */         isIE8 : isIE8,         /**          * True if the detected browser uses the Gecko layout engine (e.g. Mozilla, Firefox).          * @type Boolean          */         isGecko : isGecko,         /**          * True if the detected browser uses a pre-Gecko 1.9 layout engine (e.g. Firefox 2.x).          * @type Boolean          */         isGecko2 : isGecko2,         /**          * True if the detected browser uses a Gecko 1.9+ layout engine (e.g. Firefox 3.x).          * @type Boolean          */         isGecko3 : isGecko3,         /**          * True if the detected browser is Internet Explorer running in non-strict mode.          * @type Boolean          */         isBorderBox : isBorderBox,         /**          * True if the detected platform is Linux.          * @type Boolean          */         isLinux : isLinux,         /**          * True if the detected platform is Windows.          * @type Boolean          */         isWindows : isWindows,         /**          * True if the detected platform is Mac OS.          * @type Boolean          */         isMac : isMac,         /**          * True if the detected platform is Adobe Air.          * @type Boolean          */         isAir : isAir     });     /**      * Creates namespaces to be used for scoping variables and classes so that they are not global.      * Specifying the last node of a namespace implicitly creates all other nodes. Usage:      * <pre><code> Ext.namespace('Company', 'Company.data'); Ext.namespace('Company.data'); // equivalent and preferable to above syntax Company.Widget = function() { ... } Company.data.CustomStore = function(config) { ... } </code></pre>      * @param {String} namespace1      * @param {String} namespace2      * @param {String} etc      * @return {Object} The namespace object. (If multiple arguments are passed, this will be the last namespace created)      * @method ns      */     Ext.ns = Ext.namespace; })(); Ext.ns("Ext.util", "Ext.lib", "Ext.data"); Ext.elCache = {}; /**  * @class Function  * These functions are available on every Function object (any JavaScript function).  */ Ext.apply(Function.prototype, {      /**      * Creates an interceptor function. The passed function is called before the original one. If it returns false,      * the original one is not called. The resulting function returns the results of the original function.      * The passed function is called with the parameters of the original function. Example usage:      * <pre><code> var sayHi = function(name){     alert('Hi, ' + name); } sayHi('Fred'); // alerts "Hi, Fred" // create a new function that validates input without // directly modifying the original function: var sayHiToFriend = sayHi.createInterceptor(function(name){     return name == 'Brian'; }); sayHiToFriend('Fred');  // no alert sayHiToFriend('Brian'); // alerts "Hi, Brian" </code></pre>      * @param {Function} fcn The function to call before the original      * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the passed function is executed.      * <b>If omitted, defaults to the scope in which the original function is called or the browser window.</b>      * @return {Function} The new function      */     createInterceptor : function(fcn, scope){         var method = this;         return !Ext.isFunction(fcn) ?                 this :                 function() {                     var me = this,                         args = arguments;                     fcn.target = me;                     fcn.method = method;                     return (fcn.apply(scope || me || window, args) !== false) ?                             method.apply(me || window, args) :                             null;                 };     },      /**      * Creates a callback that passes arguments[0], arguments[1], arguments[2], ...      * Call directly on any function. Example: <code>myFunction.createCallback(arg1, arg2)</code>      * Will create a function that is bound to those 2 args. <b>If a specific scope is required in the      * callback, use {@link #createDelegate} instead.</b> The function returned by createCallback always      * executes in the window scope.      * <p>This method is required when you want to pass arguments to a callback function.  If no arguments      * are needed, you can simply pass a reference to the function as a callback (e.g., callback: myFn).      * However, if you tried to pass a function with arguments (e.g., callback: myFn(arg1, arg2)) the function      * would simply execute immediately when the code is parsed. Example usage:      * <pre><code> var sayHi = function(name){     alert('Hi, ' + name); } // clicking the button alerts "Hi, Fred" new Ext.Button({     text: 'Say Hi',     renderTo: Ext.getBody(),     handler: sayHi.createCallback('Fred') }); </code></pre>      * @return {Function} The new function     */     createCallback : function(/*args...*/){         // make args available, in function below         var args = arguments,             method = this;         return function() {             return method.apply(window, args);         };     },     /**      * Creates a delegate (callback) that sets the scope to obj.      * Call directly on any function. Example: <code>this.myFunction.createDelegate(this, [arg1, arg2])</code>      * Will create a function that is automatically scoped to obj so that the <tt>this</tt> variable inside the      * callback points to obj. Example usage:      * <pre><code> var sayHi = function(name){     // Note this use of "this.text" here.  This function expects to     // execute within a scope that contains a text property.  In this     // example, the "this" variable is pointing to the btn object that     // was passed in createDelegate below.     alert('Hi, ' + name + '. You clicked the "' + this.text + '" button.'); } var btn = new Ext.Button({     text: 'Say Hi',     renderTo: Ext.getBody() }); // This callback will execute in the scope of the // button instance. Clicking the button alerts // "Hi, Fred. You clicked the "Say Hi" button." btn.on('click', sayHi.createDelegate(btn, ['Fred'])); </code></pre>      * @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      */     createDelegate : function(obj, args, appendArgs){         var method = this;         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                 var applyArgs = [appendArgs, 0].concat(args); // create method call params                 Array.prototype.splice.apply(callArgs, applyArgs); // splice them in             }             return method.apply(obj || window, callArgs);         };     },     /**      * Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:      * <pre><code> var sayHi = function(name){     alert('Hi, ' + name); } // executes immediately: sayHi('Fred'); // executes after 2 seconds: sayHi.defer(2000, this, ['Fred']); // this syntax is sometimes useful for deferring // execution of an anonymous function: (function(){     alert('Anonymous'); }).defer(100); </code></pre>      * @param {Number} millis The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)      * @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 {Number} The timeout id that can be used with clearTimeout      */     defer : function(millis, obj, args, appendArgs){         var fn = this.createDelegate(obj, args, appendArgs);         if(millis > 0){             return setTimeout(fn, millis);         }         fn();         return 0;     } }); /**  * @class String  * These functions are available on every String object.  */ Ext.applyIf(String, {     /**      * Allows you to define a tokenized string and pass an arbitrary number of arguments to replace the tokens.  Each      * token must be unique, and must increment in the format {0}, {1}, etc.  Example usage:      * <pre><code> var cls = 'my-class', text = 'Some text'; var s = String.format('&lt;div class="{0}">{1}&lt;/div>', cls, text); // s now contains the string: '&lt;div class="my-class">Some text&lt;/div>'      * </code></pre>      * @param {String} string The tokenized string to be formatted      * @param {String} value1 The value to replace token {0}      * @param {String} value2 Etc...      * @return {String} The formatted string      * @static      */     format : function(format){         var args = Ext.toArray(arguments, 1);         return format.replace(/{(d+)}/g, function(m, i){             return args[i];         });     } }); /**  * @class Array  */ Ext.applyIf(Array.prototype, {     /**      * Checks whether or not the specified object exists in the array.      * @param {Object} o The object to check for      * @param {Number} from (Optional) The index at which to begin the search      * @return {Number} The index of o in the array (or -1 if it is not found)      */     indexOf : function(o, from){         var len = this.length;         from = from || 0;         from += (from < 0) ? len : 0;         for (; from < len; ++from){             if(this[from] === o){                 return from;             }         }         return -1;     },     /**      * Removes the specified object from the array.  If the object is not found nothing happens.      * @param {Object} o The object to remove      * @return {Array} this array      */     remove : function(o){         var index = this.indexOf(o);         if(index != -1){             this.splice(index, 1);         }         return this;     } }); /**  * @class Ext  */ Ext.ns("Ext.grid", "Ext.list", "Ext.dd", "Ext.tree", "Ext.form", "Ext.menu",        "Ext.state", "Ext.layout", "Ext.app", "Ext.ux", "Ext.chart", "Ext.direct");     /**      * Namespace alloted for extensions to the framework.      * @property ux      * @type Object      */ Ext.apply(Ext, function(){     var E = Ext,          idSeed = 0,         scrollWidth = null;     return {         /**         * A reusable empty function         * @property         * @type Function         */         emptyFn : function(){},         /**          * URL to a 1x1 transparent gif image used by Ext to create inline icons with CSS background images.           * In older versions of IE, this defaults to "http://extjs.com/s.gif" and you should change this to a URL on your server.          * For other browsers it uses an inline data URL.          * @type String          */         BLANK_IMAGE_URL : Ext.isIE6 || Ext.isIE7 || Ext.isAir ?                             'http:/' + '/extjs.com/s.gif' :                             'data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==',         extendX : function(supr, fn){             return Ext.extend(supr, fn(supr.prototype));         },         /**          * Returns the current HTML document object as an {@link Ext.Element}.          * @return Ext.Element The document          */         getDoc : function(){             return Ext.get(document);         },         /**          * Utility method for validating that a value is numeric, returning the specified default value if it is not.          * @param {Mixed} value Should be a number, but any type will be handled appropriately          * @param {Number} defaultValue The value to return if the original value is non-numeric          * @return {Number} Value, if numeric, else defaultValue          */         num : function(v, defaultValue){             v = Number(Ext.isEmpty(v) || Ext.isBoolean(v) ? NaN : v);             return isNaN(v) ? defaultValue : v;         },         /**          * <p>Utility method for returning a default value if the passed value is empty.</p>          * <p>The value is deemed to be empty if it is<div class="mdetail-params"><ul>          * <li>null</li>          * <li>undefined</li>          * <li>an empty array</li>          * <li>a zero length string (Unless the <tt>allowBlank</tt> parameter is <tt>true</tt>)</li>          * </ul></div>          * @param {Mixed} value The value to test          * @param {Mixed} defaultValue The value to return if the original value is empty          * @param {Boolean} allowBlank (optional) true to allow zero length strings to qualify as non-empty (defaults to false)          * @return {Mixed} value, if non-empty, else defaultValue          */         value : function(v, defaultValue, allowBlank){             return Ext.isEmpty(v, allowBlank) ? defaultValue : v;         },         /**          * Escapes the passed string for use in a regular expression          * @param {String} str          * @return {String}          */         escapeRe : function(s) {             return s.replace(/([-.*+?^${}()|[]/\])/g, "\$1");         },         sequence : function(o, name, fn, scope){             o[name] = o[name].createSequence(fn, scope);         },         /**          * Applies event listeners to elements by selectors when the document is ready.          * The event name is specified with an <tt>&#64;</tt> suffix.          * <pre><code> Ext.addBehaviors({     // add a listener for click on all anchors in element with id foo     '#foo a&#64;click' : function(e, t){         // do something     },          // add the same listener to multiple selectors (separated by comma BEFORE the &#64;)     '#foo a, #bar span.some-class&#64;mouseover' : function(){         // do something     } });          * </code></pre>           * @param {Object} obj The list of behaviors to apply          */         addBehaviors : function(o){             if(!Ext.isReady){                 Ext.onReady(function(){                     Ext.addBehaviors(o);                 });             } else {                 var cache = {}, // simple cache for applying multiple behaviors to same selector does query multiple times                     parts,                     b,                     s;                 for (b in o) {                     if ((parts = b.split('@'))[1]) { // for Object prototype breakers                         s = parts[0];                         if(!cache[s]){                             cache[s] = Ext.select(s);                         }                         cache[s].on(parts[1], o[b]);                     }                 }                 cache = null;             }         },                  /**          * Utility method for getting the width of the browser scrollbar. This can differ depending on          * operating system settings, such as the theme or font size.          * @param {Boolean} force (optional) true to force a recalculation of the value.          * @return {Number} The width of the scrollbar.          */         getScrollBarWidth: function(force){             if(!Ext.isReady){                 return 0;             }                          if(force === true || scrollWidth === null){                     // Append our div, do our calculation and then remove it                 var div = Ext.getBody().createChild('<div class="x-hide-offsets" style="width:100px;height:50px;overflow:hidden;"><div style="height:200px;"></div></div>'),                     child = div.child('div', true);                 var w1 = child.offsetWidth;                 div.setStyle('overflow', (Ext.isWebKit || Ext.isGecko) ? 'auto' : 'scroll');                 var w2 = child.offsetWidth;                 div.remove();                 // Need to add 2 to ensure we leave enough space                 scrollWidth = w1 - w2 + 2;             }             return scrollWidth;         },         // deprecated         combine : function(){             var as = arguments, l = as.length, r = [];             for(var i = 0; i < l; i++){                 var a = as[i];                 if(Ext.isArray(a)){                     r = r.concat(a);                 }else if(a.length !== undefined && !a.substr){                     r = r.concat(Array.prototype.slice.call(a, 0));                 }else{                     r.push(a);                 }             }             return r;         },         /**          * Copies a set of named properties fom the source object to the destination object.          * <p>example:<pre><code> ImageComponent = Ext.extend(Ext.BoxComponent, {     initComponent: function() {         this.autoEl = { tag: 'img' };         MyComponent.superclass.initComponent.apply(this, arguments);         this.initialBox = Ext.copyTo({}, this.initialConfig, 'x,y,width,height');     } });          * </code></pre>           * @param {Object} The destination object.          * @param {Object} The source object.          * @param {Array/String} Either an Array of property names, or a comma-delimited list          * of property names to copy.          * @return {Object} The modified object.         */         copyTo : function(dest, source, names){             if(Ext.isString(names)){                 names = names.split(/[,;s]/);             }             Ext.each(names, function(name){                 if(source.hasOwnProperty(name)){                     dest[name] = source[name];                 }             }, this);             return dest;         },         /**          * Attempts to destroy any objects passed to it by removing all event listeners, removing them from the          * DOM (if applicable) and calling their destroy functions (if available).  This method is primarily          * intended for arguments of type {@link Ext.Element} and {@link Ext.Component}, but any subclass of          * {@link Ext.util.Observable} can be passed in.  Any number of elements and/or components can be          * passed into this function in a single call as separate arguments.          * @param {Mixed} arg1 An {@link Ext.Element}, {@link Ext.Component}, or an Array of either of these to destroy          * @param {Mixed} arg2 (optional)          * @param {Mixed} etc... (optional)          */         destroy : function(){             Ext.each(arguments, function(arg){                 if(arg){                     if(Ext.isArray(arg)){                         this.destroy.apply(this, arg);                     }else if(Ext.isFunction(arg.destroy)){                         arg.destroy();                     }else if(arg.dom){                         arg.remove();                     }                     }             }, this);         },         /**          * Attempts to destroy and then remove a set of named properties of the passed object.          * @param {Object} o The object (most likely a Component) who's properties you wish to destroy.          * @param {Mixed} arg1 The name of the property to destroy and remove from the object.          * @param {Mixed} etc... More property names to destroy and remove.          */         destroyMembers : function(o, arg1, arg2, etc){             for(var i = 1, a = arguments, len = a.length; i < len; i++) {                 Ext.destroy(o[a[i]]);                 delete o[a[i]];             }         },         /**          * Creates a copy of the passed Array with falsy values removed.          * @param {Array/NodeList} arr The Array from which to remove falsy values.          * @return {Array} The new, compressed Array.          */         clean : function(arr){             var ret = [];             Ext.each(arr, function(v){                 if(!!v){                     ret.push(v);                 }             });             return ret;         },         /**          * Creates a copy of the passed Array, filtered to contain only unique values.          * @param {Array} arr The Array to filter          * @return {Array} The new Array containing unique values.          */         unique : function(arr){             var ret = [],                 collect = {};             Ext.each(arr, function(v) {                 if(!collect[v]){                     ret.push(v);                 }                 collect[v] = true;             });             return ret;         },         /**          * Recursively flattens into 1-d Array. Injects Arrays inline.          * @param {Array} arr The array to flatten          * @return {Array} The new, flattened array.          */         flatten : function(arr){             var worker = [];             function rFlatten(a) {                 Ext.each(a, function(v) {                     if(Ext.isArray(v)){                         rFlatten(v);                     }else{                         worker.push(v);                     }                 });                 return worker;             }             return rFlatten(arr);         },         /**          * Returns the minimum value in the Array.          * @param {Array|NodeList} arr The Array from which to select the minimum value.          * @param {Function} comp (optional) a function to perform the comparision which determines minimization.          *                   If omitted the "<" operator will be used. Note: gt = 1; eq = 0; lt = -1          * @return {Object} The minimum value in the Array.          */         min : function(arr, comp){             var ret = arr[0];             comp = comp || function(a,b){ return a < b ? -1 : 1; };             Ext.each(arr, function(v) {                 ret = comp(ret, v) == -1 ? ret : v;             });             return ret;         },         /**          * Returns the maximum value in the Array          * @param {Array|NodeList} arr The Array from which to select the maximum value.          * @param {Function} comp (optional) a function to perform the comparision which determines maximization.          *                   If omitted the ">" operator will be used. Note: gt = 1; eq = 0; lt = -1          * @return {Object} The maximum value in the Array.          */         max : function(arr, comp){             var ret = arr[0];             comp = comp || function(a,b){ return a > b ? 1 : -1; };             Ext.each(arr, function(v) {                 ret = comp(ret, v) == 1 ? ret : v;             });             return ret;         },         /**          * Calculates the mean of the Array          * @param {Array} arr The Array to calculate the mean value of.          * @return {Number} The mean.          */         mean : function(arr){            return Ext.sum(arr) / arr.length;         },         /**          * Calculates the sum of the Array          * @param {Array} arr The Array to calculate the sum value of.          * @return {Number} The sum.          */         sum : function(arr){            var ret = 0;            Ext.each(arr, function(v) {                ret += v;            });            return ret;         },         /**          * Partitions the set into two sets: a true set and a false set.          * Example:           * Example2:           * <pre><code> // Example 1: Ext.partition([true, false, true, true, false]); // [[true, true, true], [false, false]] // Example 2: Ext.partition(     Ext.query("p"),     function(val){         return val.className == "class1"     } ); // true are those paragraph elements with a className of "class1", // false set are those that do not have that className.          * </code></pre>          * @param {Array|NodeList} arr The array to partition          * @param {Function} truth (optional) a function to determine truth.  If this is omitted the element          *                   itself must be able to be evaluated for its truthfulness.          * @return {Array} [true<Array>,false<Array>]          */         partition : function(arr, truth){             var ret = [[],[]];             Ext.each(arr, function(v, i, a) {                 ret[ (truth && truth(v, i, a)) || (!truth && v) ? 0 : 1].push(v);             });             return ret;         },         /**          * Invokes a method on each item in an Array.          * <pre><code> // Example: Ext.invoke(Ext.query("p"), "getAttribute", "id"); // [el1.getAttribute("id"), el2.getAttribute("id"), ..., elN.getAttribute("id")]          * </code></pre>          * @param {Array|NodeList} arr The Array of items to invoke the method on.          * @param {String} methodName The method name to invoke.          * @param {Anything} ... Arguments to send into the method invocation.          * @return {Array} The results of invoking the method on each item in the array.          */         invoke : function(arr, methodName){             var ret = [],                 args = Array.prototype.slice.call(arguments, 2);             Ext.each(arr, function(v,i) {                 if (v && Ext.isFunction(v[methodName])) {                     ret.push(v[methodName].apply(v, args));                 } else {                     ret.push(undefined);                 }             });             return ret;         },         /**          * Plucks the value of a property from each item in the Array          * <pre><code> // Example: Ext.pluck(Ext.query("p"), "className"); // [el1.className, el2.className, ..., elN.className]          * </code></pre>          * @param {Array|NodeList} arr The Array of items to pluck the value from.          * @param {String} prop The property name to pluck from each element.          * @return {Array} The value from each item in the Array.          */         pluck : function(arr, prop){             var ret = [];             Ext.each(arr, function(v) {                 ret.push( v[prop] );             });             return ret;         },         /**          * <p>Zips N sets together.</p>          * <pre><code> // Example 1: Ext.zip([1,2,3],[4,5,6]); // [[1,4],[2,5],[3,6]] // Example 2: Ext.zip(     [ "+", "-", "+"],     [  12,  10,  22],     [  43,  15,  96],     function(a, b, c){         return "$" + a + "" + b + "." + c     } ); // ["$+12.43", "$-10.15", "$+22.96"]          * </code></pre>          * @param {Arrays|NodeLists} arr This argument may be repeated. Array(s) to contribute values.          * @param {Function} zipper (optional) The last item in the argument list. This will drive how the items are zipped together.          * @return {Array} The zipped set.          */         zip : function(){             var parts = Ext.partition(arguments, function( val ){ return !Ext.isFunction(val); }),                 arrs = parts[0],                 fn = parts[1][0],                 len = Ext.max(Ext.pluck(arrs, "length")),                 ret = [];             for (var i = 0; i < len; i++) {                 ret[i] = [];                 if(fn){                     ret[i] = fn.apply(fn, Ext.pluck(arrs, i));                 }else{                     for (var j = 0, aLen = arrs.length; j < aLen; j++){                         ret[i].push( arrs[j][i] );                     }                 }             }             return ret;         },         /**          * This is shorthand reference to {@link Ext.ComponentMgr#get}.          * Looks up an existing {@link Ext.Component Component} by {@link Ext.Component#id id}          * @param {String} id The component {@link Ext.Component#id id}          * @return Ext.Component The Component, <tt>undefined</tt> if not found, or <tt>null</tt> if a          * Class was found.         */         getCmp : function(id){             return Ext.ComponentMgr.get(id);         },         /**          * By default, Ext intelligently decides whether floating elements should be shimmed. If you are using flash,          * you may want to set this to true.          * @type Boolean          */         useShims: E.isIE6 || (E.isMac && E.isGecko2),         // inpired by a similar function in mootools library         /**          * Returns the type of object that is passed in. If the object passed in is null or undefined it          * return false otherwise it returns one of the following values:<div class="mdetail-params"><ul>          * <li><b>string</b>: If the object passed is a string</li>          * <li><b>number</b>: If the object passed is a number</li>          * <li><b>boolean</b>: If the object passed is a boolean value</li>          * <li><b>date</b>: If the object passed is a Date object</li>          * <li><b>function</b>: If the object passed is a function reference</li>          * <li><b>object</b>: If the object passed is an object</li>          * <li><b>array</b>: If the object passed is an array</li>          * <li><b>regexp</b>: If the object passed is a regular expression</li>          * <li><b>element</b>: If the object passed is a DOM Element</li>          * <li><b>nodelist</b>: If the object passed is a DOM NodeList</li>          * <li><b>textnode</b>: If the object passed is a DOM text node and contains something other than whitespace</li>          * <li><b>whitespace</b>: If the object passed is a DOM text node and contains only whitespace</li>          * </ul></div>          * @param {Mixed} object          * @return {String}          */         type : function(o){             if(o === undefined || o === null){                 return false;             }             if(o.htmlElement){                 return 'element';             }             var t = typeof o;             if(t == 'object' && o.nodeName) {                 switch(o.nodeType) {                     case 1: return 'element';                     case 3: return (/S/).test(o.nodeValue) ? 'textnode' : 'whitespace';                 }             }             if(t == 'object' || t == 'function') {                 switch(o.constructor) {                     case Array: return 'array';                     case RegExp: return 'regexp';                     case Date: return 'date';                 }                 if(Ext.isNumber(o.length) && Ext.isFunction(o.item)) {                     return 'nodelist';                 }             }             return t;         },         intercept : function(o, name, fn, scope){             o[name] = o[name].createInterceptor(fn, scope);         },         // internal         callback : function(cb, scope, args, delay){             if(Ext.isFunction(cb)){                 if(delay){                     cb.defer(delay, scope, args || []);                 }else{                     cb.apply(scope, args || []);                 }             }         }     }; }()); /**  * @class Function  * These functions are available on every Function object (any JavaScript function).  */ Ext.apply(Function.prototype, {     /**      * Create a combined function call sequence of the original function + the passed function.      * The resulting function returns the results of the original function.      * The passed fcn is called with the parameters of the original function. Example usage:      * <pre><code> var sayHi = function(name){     alert('Hi, ' + name); } sayHi('Fred'); // alerts "Hi, Fred" var sayGoodbye = sayHi.createSequence(function(name){     alert('Bye, ' + name); }); sayGoodbye('Fred'); // both alerts show </code></pre>      * @param {Function} fcn The function to sequence      * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the passed function is executed.      * <b>If omitted, defaults to the scope in which the original function is called or the browser window.</b>      * @return {Function} The new function      */     createSequence : function(fcn, scope){         var method = this;         return !Ext.isFunction(fcn) ?                 this :                 function(){                     var retval = method.apply(this || window, arguments);                     fcn.apply(scope || this || window, arguments);                     return retval;                 };     } }); /**  * @class String  * These functions are available as static methods on the JavaScript String object.  */ Ext.applyIf(String, {     /**      * Escapes the passed string for ' and       * @param {String} string The string to escape      * @return {String} The escaped string      * @static      */     escape : function(string) {         return string.replace(/('|\)/g, "\$1");     },     /**      * Pads the left side of a string with a specified character.  This is especially useful      * for normalizing number and date strings.  Example usage:      * <pre><code> var s = String.leftPad('123', 5, '0'); // s now contains the string: '00123'      * </code></pre>      * @param {String} string The original string      * @param {Number} size The total length of the output string      * @param {String} char (optional) The character with which to pad the original string (defaults to empty string " ")      * @return {String} The padded string      * @static      */     leftPad : function (val, size, ch) {         var result = String(val);         if(!ch) {             ch = " ";         }         while (result.length < size) {             result = ch + result;         }         return result;     } }); /**  * Utility function that allows you to easily switch a string between two alternating values.  The passed value  * is compared to the current string, and if they are equal, the other value that was passed in is returned.  If  * they are already different, the first value passed in is returned.  Note that this method returns the new value  * but does not change the current string.  * <pre><code> // alternate sort directions sort = sort.toggle('ASC', 'DESC'); // instead of conditional logic: sort = (sort == 'ASC' ? 'DESC' : 'ASC'); </code></pre>  * @param {String} value The value to compare to the current string  * @param {String} other The new value to use if the string already equals the first value passed in  * @return {String} The new value  */ String.prototype.toggle = function(value, other){     return this == value ? other : value; }; /**  * Trims whitespace from either end of a string, leaving spaces within the string intact.  Example:  * <pre><code> var s = '  foo bar  '; alert('-' + s + '-');         //alerts "- foo bar -" alert('-' + s.trim() + '-');  //alerts "-foo bar-" </code></pre>  * @return {String} The trimmed string  */ String.prototype.trim = function(){     var re = /^s+|s+$/g;     return function(){ return this.replace(re, ""); }; }(); // here to prevent dependency on Date.js /**  Returns the number of milliseconds between this date and date  @param {Date} date (optional) Defaults to now  @return {Number} The diff in milliseconds  @member Date getElapsed  */ Date.prototype.getElapsed = function(date) {     return Math.abs((date || new Date()).getTime()-this.getTime()); }; /**  * @class Number  */ Ext.applyIf(Number.prototype, {     /**      * Checks whether or not the current number is within a desired range.  If the number is already within the      * range it is returned, otherwise the min or max value is returned depending on which side of the range is      * exceeded.  Note that this method returns the constrained value but does not change the current number.      * @param {Number} min The minimum number in the range      * @param {Number} max The maximum number in the range      * @return {Number} The constrained value if outside the range, otherwise the current value      */     constrain : function(min, max){         return Math.min(Math.max(this, min), max);     } }); /**  * @class Ext.util.TaskRunner  * Provides the ability to execute one or more arbitrary tasks in a multithreaded  * manner.  Generally, you can use the singleton {@link Ext.TaskMgr} instead, but  * if needed, you can create separate instances of TaskRunner.  Any number of  * separate tasks can be started at any time and will run independently of each  * other. Example usage:  * <pre><code> // Start a simple clock task that updates a div once per second var updateClock = function(){     Ext.fly('clock').update(new Date().format('g:i:s A')); }  var task = {     run: updateClock,     interval: 1000 //1 second } var runner = new Ext.util.TaskRunner(); runner.start(task); // equivalent using TaskMgr Ext.TaskMgr.start({     run: updateClock,     interval: 1000 });  * </code></pre>  * Also see {@link Ext.util.DelayedTask}.   *   * @constructor  * @param {Number} interval (optional) The minimum precision in milliseconds supported by this TaskRunner instance  * (defaults to 10)  */ Ext.util.TaskRunner = function(interval){     interval = interval || 10;     var tasks = [],       removeQueue = [],      id = 0,      running = false,      // private      stopThread = function(){         running = false;         clearInterval(id);         id = 0;     },      // private      startThread = function(){         if(!running){             running = true;             id = setInterval(runTasks, interval);         }     },      // private      removeTask = function(t){         removeQueue.push(t);         if(t.onStop){             t.onStop.apply(t.scope || t);         }     },           // private      runTasks = function(){      var rqLen = removeQueue.length,      now = new Date().getTime();                        if(rqLen > 0){             for(var i = 0; i < rqLen; i++){                 tasks.remove(removeQueue[i]);             }             removeQueue = [];             if(tasks.length < 1){                 stopThread();                 return;             }         }                  for(var i = 0, t, itime, rt, len = tasks.length; i < len; ++i){             t = tasks[i];             itime = now - t.taskRunTime;             if(t.interval <= itime){                 rt = t.run.apply(t.scope || t, t.args || [++t.taskRunCount]);                 t.taskRunTime = now;                 if(rt === false || t.taskRunCount === t.repeat){                     removeTask(t);                     return;                 }             }             if(t.duration && t.duration <= (now - t.taskStartTime)){                 removeTask(t);             }         }     };     /**      * Starts a new task.      * @method start      * @param {Object} task A config object that supports the following properties:<ul>      * <li><code>run</code> : Function<div class="sub-desc">The function to execute each time the task is run. The      * function will be called at each interval and passed the <code>args</code> argument if specified.  If a      * particular scope is required, be sure to specify it using the <code>scope</code> argument.</div></li>      * <li><code>interval</code> : Number<div class="sub-desc">The frequency in milliseconds with which the task      * should be executed.</div></li>      * <li><code>args</code> : Array<div class="sub-desc">(optional) An array of arguments to be passed to the function      * specified by <code>run</code>.</div></li>      * <li><code>scope</code> : Object<div class="sub-desc">(optional) The scope (<tt>this</tt> reference) in which to execute the      * <code>run</code> function. Defaults to the task config object.</div></li>      * <li><code>duration</code> : Number<div class="sub-desc">(optional) The length of time in milliseconds to execute      * the task before stopping automatically (defaults to indefinite).</div></li>      * <li><code>repeat</code> : Number<div class="sub-desc">(optional) The number of times to execute the task before      * stopping automatically (defaults to indefinite).</div></li>      * </ul>      * @return {Object} The task      */     this.start = function(task){         tasks.push(task);         task.taskStartTime = new Date().getTime();         task.taskRunTime = 0;         task.taskRunCount = 0;         startThread();         return task;     };     /**      * Stops an existing running task.      * @method stop      * @param {Object} task The task to stop      * @return {Object} The task      */     this.stop = function(task){         removeTask(task);         return task;     };     /**      * Stops all tasks that are currently running.      * @method stopAll      */     this.stopAll = function(){         stopThread();         for(var i = 0, len = tasks.length; i < len; i++){             if(tasks[i].onStop){                 tasks[i].onStop();             }         }         tasks = [];         removeQueue = [];     }; }; /**  * @class Ext.TaskMgr  * @extends Ext.util.TaskRunner  * A static {@link Ext.util.TaskRunner} instance that can be used to start and stop arbitrary tasks.  See  * {@link Ext.util.TaskRunner} for supported methods and task config properties.  * <pre><code> // Start a simple clock task that updates a div once per second var task = {     run: function(){         Ext.fly('clock').update(new Date().format('g:i:s A'));     },     interval: 1000 //1 second } Ext.TaskMgr.start(task); </code></pre>  * @singleton  */ Ext.TaskMgr = new Ext.util.TaskRunner();(function(){
  2. var libFlyweight;
  3. function fly(el) {
  4.         if (!libFlyweight) {
  5.             libFlyweight = new Ext.Element.Flyweight();
  6.         }
  7.         libFlyweight.dom = el;
  8.         return libFlyweight;
  9.     }
  10.     
  11.     (function(){
  12. var doc = document,
  13. isCSS1 = doc.compatMode == "CSS1Compat",
  14. MAX = Math.max,
  15.         ROUND = Math.round,
  16. PARSEINT = parseInt;
  17. Ext.lib.Dom = {
  18.     isAncestor : function(p, c) {
  19.     var ret = false;
  20. p = Ext.getDom(p);
  21. c = Ext.getDom(c);
  22. if (p && c) {
  23. if (p.contains) {
  24. return p.contains(c);
  25. } else if (p.compareDocumentPosition) {
  26. return !!(p.compareDocumentPosition(c) & 16);
  27. } else {
  28. while (c = c.parentNode) {
  29. ret = c == p || ret;         
  30. }
  31. }             
  32. }
  33. return ret;
  34. },
  35.         getViewWidth : function(full) {
  36.             return full ? this.getDocumentWidth() : this.getViewportWidth();
  37.         },
  38.         getViewHeight : function(full) {
  39.             return full ? this.getDocumentHeight() : this.getViewportHeight();
  40.         },
  41.         getDocumentHeight: function() {            
  42.             return MAX(!isCSS1 ? doc.body.scrollHeight : doc.documentElement.scrollHeight, this.getViewportHeight());
  43.         },
  44.         getDocumentWidth: function() {            
  45.             return MAX(!isCSS1 ? doc.body.scrollWidth : doc.documentElement.scrollWidth, this.getViewportWidth());
  46.         },
  47.         getViewportHeight: function(){
  48.         return Ext.isIE ? 
  49.             (Ext.isStrict ? doc.documentElement.clientHeight : doc.body.clientHeight) :
  50.             self.innerHeight;
  51.         },
  52.         getViewportWidth : function() {
  53.         return !Ext.isStrict && !Ext.isOpera ? doc.body.clientWidth :
  54.             Ext.isIE ? doc.documentElement.clientWidth : self.innerWidth;
  55.         },
  56.         
  57.         getY : function(el) {
  58.             return this.getXY(el)[1];
  59.         },
  60.         getX : function(el) {
  61.             return this.getXY(el)[0];
  62.         },
  63.         getXY : function(el) {
  64.             var p, 
  65.              pe, 
  66.              b,
  67.              bt, 
  68.              bl,     
  69.              dbd,       
  70.              x = 0,
  71.              y = 0, 
  72.              scroll,
  73.              hasAbsolute, 
  74.              bd = (doc.body || doc.documentElement),
  75.              ret = [0,0];
  76.             
  77.             el = Ext.getDom(el);
  78.             if(el != bd){
  79.             if (el.getBoundingClientRect) {
  80.                 b = el.getBoundingClientRect();
  81.                 scroll = fly(document).getScroll();
  82.                 ret = [ROUND(b.left + scroll.left), ROUND(b.top + scroll.top)];
  83.             } else {  
  84.             p = el;
  85.             hasAbsolute = fly(el).isStyle("position", "absolute");
  86.             while (p) {
  87.             pe = fly(p);
  88.                 x += p.offsetLeft;
  89.                 y += p.offsetTop;
  90.                 hasAbsolute = hasAbsolute || pe.isStyle("position", "absolute");
  91.                 
  92.                 if (Ext.isGecko) {                     
  93.                     y += bt = PARSEINT(pe.getStyle("borderTopWidth"), 10) || 0;
  94.                     x += bl = PARSEINT(pe.getStyle("borderLeftWidth"), 10) || 0;
  95.                     if (p != el && !pe.isStyle('overflow','visible')) {
  96.                         x += bl;
  97.                         y += bt;
  98.                     }
  99.                 }
  100.                 p = p.offsetParent;
  101.             }
  102.             if (Ext.isSafari && hasAbsolute) {
  103.                 x -= bd.offsetLeft;
  104.                 y -= bd.offsetTop;
  105.             }
  106.             if (Ext.isGecko && !hasAbsolute) {
  107.                 dbd = fly(bd);
  108.                 x += PARSEINT(dbd.getStyle("borderLeftWidth"), 10) || 0;
  109.                 y += PARSEINT(dbd.getStyle("borderTopWidth"), 10) || 0;
  110.             }
  111.             p = el.parentNode;
  112.             while (p && p != bd) {
  113.                 if (!Ext.isOpera || (p.tagName != 'TR' && !fly(p).isStyle("display", "inline"))) {
  114.                     x -= p.scrollLeft;
  115.                     y -= p.scrollTop;
  116.                 }
  117.                 p = p.parentNode;
  118.             }
  119.             ret = [x,y];
  120.             }
  121.           }
  122.             return ret
  123.         },
  124.         setXY : function(el, xy) {
  125.             (el = Ext.fly(el, '_setXY')).position();
  126.             
  127.             var pts = el.translatePoints(xy),
  128.              style = el.dom.style,
  129.              pos;            
  130.             
  131.             for (pos in pts) {             
  132.             if(!isNaN(pts[pos])) style[pos] = pts[pos] + "px"
  133.             }
  134.         },
  135.         setX : function(el, x) {
  136.             this.setXY(el, [x, false]);
  137.         },
  138.         setY : function(el, y) {
  139.             this.setXY(el, [false, y]);
  140.         }
  141.     };
  142. })();Ext.lib.Dom.getRegion = function(el) {
  143.     return Ext.lib.Region.getRegion(el);
  144. };Ext.lib.Event = function() {     var loadComplete = false,         unloadListeners = {},         retryCount = 0,         onAvailStack = [],         _interval,         locked = false,         win = window,         doc = document,         // constants         POLL_RETRYS = 200,         POLL_INTERVAL = 20,         EL = 0,         TYPE = 0,         FN = 1,         WFN = 2,         OBJ = 2,         ADJ_SCOPE = 3,         SCROLLLEFT = 'scrollLeft',         SCROLLTOP = 'scrollTop',         UNLOAD = 'unload',         MOUSEOVER = 'mouseover',         MOUSEOUT = 'mouseout',         // private         doAdd = function() {             var ret;             if (win.addEventListener) {                 ret = function(el, eventName, fn, capture) {                     if (eventName == 'mouseenter') {                         fn = fn.createInterceptor(checkRelatedTarget);                         el.addEventListener(MOUSEOVER, fn, (capture));                     } else if (eventName == 'mouseleave') {                         fn = fn.createInterceptor(checkRelatedTarget);                         el.addEventListener(MOUSEOUT, fn, (capture));                     } else {                         el.addEventListener(eventName, fn, (capture));                     }                     return fn;                 };             } else if (win.attachEvent) {                 ret = function(el, eventName, fn, capture) {                     el.attachEvent("on" + eventName, fn);                     return fn;                 };             } else {                 ret = function(){};             }             return ret;         }(),         // private         doRemove = function(){             var ret;             if (win.removeEventListener) {                 ret = function (el, eventName, fn, capture) {                     if (eventName == 'mouseenter') {                         eventName = MOUSEOVER;                     } else if (eventName == 'mouseleave') {                         eventName = MOUSEOUT;                     }                     el.removeEventListener(eventName, fn, (capture));                 };             } else if (win.detachEvent) {                 ret = function (el, eventName, fn) {                     el.detachEvent("on" + eventName, fn);                 };             } else {                 ret = function(){};             }             return ret;         }();     function checkRelatedTarget(e) {         return !elContains(e.currentTarget, pub.getRelatedTarget(e));     }     function elContains(parent, child) {        if(parent && parent.firstChild){          while(child) {             if(child === parent) {                 return true;             }             child = child.parentNode;             if(child && (child.nodeType != 1)) {                 child = null;             }           }         }         return false;     }     // private     function _tryPreloadAttach() {         var ret = false,             notAvail = [],             element, i, len, v,             tryAgain = !loadComplete || (retryCount > 0);         if (!locked) {             locked = true;             for (i = 0, len = onAvailStack.length; i < len; i++) {                 v = onAvailStack[i];                 if(v && (element = doc.getElementById(v.id))){                     if(!v.checkReady || loadComplete || element.nextSibling || (doc && doc.body)) {                         element = v.override ? (v.override === true ? v.obj : v.override) : element;                         v.fn.call(element, v.obj);                         v = null;                     } else {                         notAvail.push(v);                     }                 }             }             retryCount = (notAvail.length === 0) ? 0 : retryCount - 1;             if (tryAgain) {                 startInterval();             } else {                 clearInterval(_interval);                 _interval = null;             }             ret = !(locked = false);         }         return ret;     }     // private     function startInterval() {         if(!_interval){             var callback = function() {                 _tryPreloadAttach();             };             _interval = setInterval(callback, POLL_INTERVAL);         }     }     // private     function getScroll() {         var dd = doc.documentElement,             db = doc.body;         if(dd && (dd[SCROLLTOP] || dd[SCROLLLEFT])){             return [dd[SCROLLLEFT], dd[SCROLLTOP]];         }else if(db){             return [db[SCROLLLEFT], db[SCROLLTOP]];         }else{             return [0, 0];         }     }     // private     function getPageCoord (ev, xy) {         ev = ev.browserEvent || ev;         var coord  = ev['page' + xy];         if (!coord && coord !== 0) {             coord = ev['client' + xy] || 0;             if (Ext.isIE) {                 coord += getScroll()[xy == "X" ? 0 : 1];             }         }         return coord;     }     var pub =  {         extAdapter: true,         onAvailable : function(p_id, p_fn, p_obj, p_override) {             onAvailStack.push({                 id:         p_id,                 fn:         p_fn,                 obj:        p_obj,                 override:   p_override,                 checkReady: false });             retryCount = POLL_RETRYS;             startInterval();         },         // This function should ALWAYS be called from Ext.EventManager         addListener: function(el, eventName, fn) {             el = Ext.getDom(el);             if (el && fn) {                 if (eventName == UNLOAD) {                     if (unloadListeners[el.id] === undefined) {                         unloadListeners[el.id] = [];                     }                     unloadListeners[el.id].push([eventName, fn]);                     return fn;                 }                 return doAdd(el, eventName, fn, false);             }             return false;         },         // This function should ALWAYS be called from Ext.EventManager         removeListener: function(el, eventName, fn) {             el = Ext.getDom(el);             var i, len, li;             if (el && fn) {                 if (eventName == UNLOAD) {                     if (unloadListeners[id] !== undefined) {                         for (i = 0, len = unloadListeners[id].length; i < len; i++) {                             li = unloadListeners[id][i];                             if (li && li[TYPE] == eventName && li[FN] == fn) {                                 unloadListeners[id].splice(i, 1);                             }                         }                     }                     return;                 }                 doRemove(el, eventName, fn, false);             }         },         getTarget : function(ev) {             ev = ev.browserEvent || ev;             return this.resolveTextNode(ev.target || ev.srcElement);         },         resolveTextNode : Ext.isGecko ? function(node){             if(!node){                 return;             }             // work around firefox bug, https://bugzilla.mozilla.org/show_bug.cgi?id=101197             var s = HTMLElement.prototype.toString.call(node);             if(s == '[xpconnect wrapped native prototype]' || s == '[object XULElement]'){                 return;             }             return node.nodeType == 3 ? node.parentNode : node;         } : function(node){             return node && node.nodeType == 3 ? node.parentNode : node;         },         getRelatedTarget : function(ev) {             ev = ev.browserEvent || ev;             return this.resolveTextNode(ev.relatedTarget ||                     (ev.type == MOUSEOUT ? ev.toElement :                      ev.type == MOUSEOVER ? ev.fromElement : null));         },         getPageX : function(ev) {             return getPageCoord(ev, "X");         },         getPageY : function(ev) {             return getPageCoord(ev, "Y");         },         getXY : function(ev) {             return [this.getPageX(ev), this.getPageY(ev)];         },         stopEvent : function(ev) {             this.stopPropagation(ev);             this.preventDefault(ev);         },         stopPropagation : function(ev) {             ev = ev.browserEvent || ev;             if (ev.stopPropagation) {                 ev.stopPropagation();             } else {                 ev.cancelBubble = true;             }         },         preventDefault : function(ev) {             ev = ev.browserEvent || ev;             if (ev.preventDefault) {                 ev.preventDefault();             } else {                 ev.returnValue = false;             }         },         getEvent : function(e) {             e = e || win.event;             if (!e) {                 var c = this.getEvent.caller;                 while (c) {                     e = c.arguments[0];                     if (e && Event == e.constructor) {                         break;                     }                     c = c.caller;                 }             }             return e;         },         getCharCode : function(ev) {             ev = ev.browserEvent || ev;             return ev.charCode || ev.keyCode || 0;         },         //clearCache: function() {},         // deprecated, call from EventManager         getListeners : function(el, eventName) {             Ext.EventManager.getListeners(el, eventName);         },         // deprecated, call from EventManager         purgeElement : function(el, recurse, eventName) {             Ext.EventManager.purgeElement(el, recurse, eventName);         },         _load : function(e) {             loadComplete = true;             var EU = Ext.lib.Event;             if (Ext.isIE && e !== true) {         // IE8 complains that _load is null or not an object         // so lets remove self via arguments.callee                 doRemove(win, "load", arguments.callee);             }         },         _unload : function(e) {              var EU = Ext.lib.Event,                 i, j, l, v, ul, id, len, index, scope;             for (id in unloadListeners) {                 ul = unloadListeners[id];                 for (i = 0, len = ul.length; i < len; i++) {                     v = ul[i];                     if (v) {                         try{                             scope = v[ADJ_SCOPE] ? (v[ADJ_SCOPE] === true ? v[OBJ] : v[ADJ_SCOPE]) :  win;                             v[FN].call(scope, EU.getEvent(e), v[OBJ]);                         }catch(ex){}                     }                 }             };             unloadListeners = null;             Ext.EventManager._unload();             doRemove(win, UNLOAD, EU._unload);         }     };     // Initialize stuff.     pub.on = pub.addListener;     pub.un = pub.removeListener;     if (doc && doc.body) {         pub._load(true);     } else {         doAdd(win, "load", pub._load);     }     doAdd(win, UNLOAD, pub._unload);     _tryPreloadAttach();     return pub; }(); /*
  145. * Portions of this file are based on pieces of Yahoo User Interface Library
  146. * Copyright (c) 2007, Yahoo! Inc. All rights reserved.
  147. * YUI licensed under the BSD License:
  148. * http://developer.yahoo.net/yui/license.txt
  149. */
  150. Ext.lib.Ajax = function() {     
  151.     var activeX = ['MSXML2.XMLHTTP.3.0',
  152.                    'MSXML2.XMLHTTP',
  153.                    'Microsoft.XMLHTTP'],
  154.         CONTENTTYPE = 'Content-Type';
  155.                    
  156.     // private
  157.     function setHeader(o) {
  158.         var conn = o.conn,
  159.             prop;
  160.         
  161.         function setTheHeaders(conn, headers){
  162.             for (prop in headers) {
  163.                 if (headers.hasOwnProperty(prop)) {
  164.                     conn.setRequestHeader(prop, headers[prop]);
  165.                 }
  166.             }   
  167.         }       
  168.         
  169.         if (pub.defaultHeaders) {
  170.             setTheHeaders(conn, pub.defaultHeaders);
  171.         }
  172.         if (pub.headers) {
  173.             setTheHeaders(conn, pub.headers);
  174.             delete pub.headers;                
  175.         }
  176.     }    
  177.     
  178.     // private
  179.     function createExceptionObject(tId, callbackArg, isAbort, isTimeout) {          
  180.         return {
  181.             tId : tId,
  182.             status : isAbort ? -1 : 0,
  183.             statusText : isAbort ? 'transaction aborted' : 'communication failure',
  184.             isAbort: isAbort,
  185.             isTimeout: isTimeout,
  186.             argument : callbackArg
  187.         };
  188.     }  
  189.     
  190.     // private 
  191.     function initHeader(label, value) {         
  192.         (pub.headers = pub.headers || {})[label] = value;                       
  193.     }
  194.     
  195.     // private
  196.     function createResponseObject(o, callbackArg) {
  197.         var headerObj = {},
  198.             headerStr,              
  199.             conn = o.conn,
  200.             t,
  201.             s;
  202.         try {
  203.             headerStr = o.conn.getAllResponseHeaders();   
  204.             Ext.each(headerStr.replace(/rn/g, 'n').split('n'), function(v){
  205.                 t = v.indexOf(':');
  206.                 if(t >= 0){
  207.                     s = v.substr(0, t).toLowerCase();
  208.                     if(v.charAt(t + 1) == ' '){
  209.                         ++t;
  210.                     }
  211.                     headerObj[s] = v.substr(t + 1);
  212.                 }
  213.             });
  214.         } catch(e) {}
  215.                     
  216.         return {
  217.             tId : o.tId,
  218.             status : conn.status,
  219.             statusText : conn.statusText,
  220.             getResponseHeader : function(header){return headerObj[header.toLowerCase()];},
  221.             getAllResponseHeaders : function(){return headerStr},
  222.             responseText : conn.responseText,
  223.             responseXML : conn.responseXML,
  224.             argument : callbackArg
  225.         };
  226.     }
  227.     
  228.     // private
  229.     function releaseObject(o) {
  230.         o.conn = null;
  231.         o = null;
  232.     }        
  233.     
  234.     // private
  235.     function handleTransactionResponse(o, callback, isAbort, isTimeout) {
  236.         if (!callback) {
  237.             releaseObject(o);
  238.             return;
  239.         }
  240.         var httpStatus, responseObject;
  241.         try {
  242.             if (o.conn.status !== undefined && o.conn.status != 0) {
  243.                 httpStatus = o.conn.status;
  244.             }
  245.             else {
  246.                 httpStatus = 13030;
  247.             }
  248.         }
  249.         catch(e) {
  250.             httpStatus = 13030;
  251.         }
  252.         if ((httpStatus >= 200 && httpStatus < 300) || (Ext.isIE && httpStatus == 1223)) {
  253.             responseObject = createResponseObject(o, callback.argument);
  254.             if (callback.success) {
  255.                 if (!callback.scope) {
  256.                     callback.success(responseObject);
  257.                 }
  258.                 else {
  259.                     callback.success.apply(callback.scope, [responseObject]);
  260.                 }
  261.             }
  262.         }
  263.         else {
  264.             switch (httpStatus) {
  265.                 case 12002:
  266.                 case 12029:
  267.                 case 12030:
  268.                 case 12031:
  269.                 case 12152:
  270.                 case 13030:
  271.                     responseObject = createExceptionObject(o.tId, callback.argument, (isAbort ? isAbort : false), isTimeout);
  272.                     if (callback.failure) {
  273.                         if (!callback.scope) {
  274.                             callback.failure(responseObject);
  275.                         }
  276.                         else {
  277.                             callback.failure.apply(callback.scope, [responseObject]);
  278.                         }
  279.                     }
  280.                     break;
  281.                 default:
  282.                     responseObject = createResponseObject(o, callback.argument);
  283.                     if (callback.failure) {
  284.                         if (!callback.scope) {
  285.                             callback.failure(responseObject);
  286.                         }
  287.                         else {
  288.                             callback.failure.apply(callback.scope, [responseObject]);
  289.                         }
  290.                     }
  291.             }
  292.         }
  293.         releaseObject(o);
  294.         responseObject = null;
  295.     }  
  296.     
  297.     // private
  298.     function handleReadyState(o, callback){
  299.     callback = callback || {};
  300.         var conn = o.conn,
  301.             tId = o.tId,
  302.             poll = pub.poll,
  303.             cbTimeout = callback.timeout || null;
  304.         if (cbTimeout) {
  305.             pub.timeout[tId] = setTimeout(function() {
  306.                 pub.abort(o, callback, true);
  307.             }, cbTimeout);
  308.         }
  309.         poll[tId] = setInterval(
  310.             function() {
  311.                 if (conn && conn.readyState == 4) {
  312.                     clearInterval(poll[tId]);
  313.                     poll[tId] = null;
  314.                     if (cbTimeout) {
  315.                         clearTimeout(pub.timeout[tId]);
  316.                         pub.timeout[tId] = null;
  317.                     }
  318.                     handleTransactionResponse(o, callback);
  319.                 }
  320.             },
  321.             pub.pollInterval);
  322.     }
  323.     
  324.     // private
  325.     function asyncRequest(method, uri, callback, postData) {
  326.         var o = getConnectionObject() || null;
  327.         if (o) {
  328.             o.conn.open(method, uri, true);
  329.             if (pub.useDefaultXhrHeader) {                    
  330.                 initHeader('X-Requested-With', pub.defaultXhrHeader);
  331.             }
  332.             if(postData && pub.useDefaultHeader && (!pub.headers || !pub.headers[CONTENTTYPE])){
  333.                 initHeader(CONTENTTYPE, pub.defaultPostHeader);
  334.             }
  335.             if (pub.defaultHeaders || pub.headers) {
  336.                 setHeader(o);
  337.             }
  338.             handleReadyState(o, callback);
  339.             o.conn.send(postData || null);
  340.         }
  341.         return o;
  342.     }
  343.     
  344.     // private
  345.     function getConnectionObject() {
  346.         var o;          
  347.         try {
  348.             if (o = createXhrObject(pub.transactionId)) {
  349.                 pub.transactionId++;
  350.             }
  351.         } catch(e) {
  352.         } finally {
  353.             return o;
  354.         }
  355.     }
  356.        
  357.     // private
  358.     function createXhrObject(transactionId) {
  359.         var http;
  360.             
  361.         try {
  362.             http = new XMLHttpRequest();                
  363.         } catch(e) {
  364.             for (var i = 0; i < activeX.length; ++i) {              
  365.                 try {
  366.                     http = new ActiveXObject(activeX[i]);                        
  367.                     break;
  368.                 } catch(e) {}
  369.             }
  370.         } finally {
  371.             return {conn : http, tId : transactionId};
  372.         }
  373.     }
  374.          
  375.     var pub = {
  376.         request : function(method, uri, cb, data, options) {
  377.             if(options){
  378.                 var me = this,              
  379.                     xmlData = options.xmlData,
  380.                     jsonData = options.jsonData,
  381.                     hs;
  382.                     
  383.                 Ext.applyIf(me, options);           
  384.                 
  385.                 if(xmlData || jsonData){
  386.                     hs = me.headers;
  387.                     if(!hs || !hs[CONTENTTYPE]){
  388.                         initHeader(CONTENTTYPE, xmlData ? 'text/xml' : 'application/json');
  389.                     }
  390.                     data = xmlData || (!Ext.isPrimitive(jsonData) ? Ext.encode(jsonData) : jsonData);
  391.                 }
  392.             }                       
  393.             return asyncRequest(method || options.method || "POST", uri, cb, data);
  394.         },
  395.         serializeForm : function(form) {
  396.             var fElements = form.elements || (document.forms[form] || Ext.getDom(form)).elements,
  397.                 hasSubmit = false,
  398.                 encoder = encodeURIComponent,
  399.                 element,
  400.                 options, 
  401.                 name, 
  402.                 val,                
  403.                 data = '',
  404.                 type;
  405.                 
  406.             Ext.each(fElements, function(element) {                 
  407.                 name = element.name;                 
  408.                 type = element.type;
  409.                 
  410.                 if (!element.disabled && name){
  411.                     if(/select-(one|multiple)/i.test(type)) {
  412.                         Ext.each(element.options, function(opt) {
  413.                             if (opt.selected) {
  414.                                 data += String.format("{0}={1}&", encoder(name), encoder((opt.hasAttribute ? opt.hasAttribute('value') : opt.getAttribute('value') !== null) ? opt.value : opt.text));
  415.                             }                               
  416.                         });
  417.                     } else if(!/file|undefined|reset|button/i.test(type)) {
  418.                             if(!(/radio|checkbox/i.test(type) && !element.checked) && !(type == 'submit' && hasSubmit)){
  419.                                 
  420.                                 data += encoder(name) + '=' + encoder(element.value) + '&';                     
  421.                                 hasSubmit = /submit/i.test(type);    
  422.                             }                       
  423.                     } 
  424.                 }
  425.             });            
  426.             return data.substr(0, data.length - 1);
  427.         },
  428.         
  429.         useDefaultHeader : true,
  430.         defaultPostHeader : 'application/x-www-form-urlencoded; charset=UTF-8',
  431.         useDefaultXhrHeader : true,
  432.         defaultXhrHeader : 'XMLHttpRequest',        
  433.         poll : {},
  434.         timeout : {},
  435.         pollInterval : 50,
  436.         transactionId : 0,
  437.         
  438. //  This is never called - Is it worth exposing this?               
  439. //          setProgId : function(id) {
  440. //              activeX.unshift(id);
  441. //          },
  442. //  This is never called - Is it worth exposing this?   
  443. //          setDefaultPostHeader : function(b) {
  444. //              this.useDefaultHeader = b;
  445. //          },
  446.         
  447. //  This is never called - Is it worth exposing this?   
  448. //          setDefaultXhrHeader : function(b) {
  449. //              this.useDefaultXhrHeader = b;
  450. //          },
  451. //  This is never called - Is it worth exposing this?           
  452. //          setPollingInterval : function(i) {
  453. //              if (typeof i == 'number' && isFinite(i)) {
  454. //                  this.pollInterval = i;
  455. //              }
  456. //          },
  457.         
  458. //  This is never called - Is it worth exposing this?
  459. //          resetDefaultHeaders : function() {
  460. //              this.defaultHeaders = null;
  461. //          },
  462.     
  463.             abort : function(o, callback, isTimeout) {
  464.                 var me = this,
  465.                     tId = o.tId,
  466.                     isAbort = false;
  467.                 
  468.                 if (me.isCallInProgress(o)) {
  469.                     o.conn.abort();
  470.                     clearInterval(me.poll[tId]);
  471.                     me.poll[tId] = null;
  472.                     clearTimeout(pub.timeout[tId]);
  473.                     me.timeout[tId] = null;
  474.                     
  475.                     handleTransactionResponse(o, callback, (isAbort = true), isTimeout);                
  476.                 }
  477.                 return isAbort;
  478.             },
  479.     
  480.             isCallInProgress : function(o) {
  481.                 // if there is a connection and readyState is not 0 or 4
  482.                 return o.conn && !{0:true,4:true}[o.conn.readyState];           
  483.             }
  484.         };
  485.         return pub;
  486.     }(); Ext.lib.Region = function(t, r, b, l) {
  487. var me = this;
  488.         me.top = t;
  489.         me[1] = t;
  490.         me.right = r;
  491.         me.bottom = b;
  492.         me.left = l;
  493.         me[0] = l;
  494.     };
  495.     Ext.lib.Region.prototype = {
  496.         contains : function(region) {
  497.         var me = this;
  498.             return ( region.left >= me.left &&
  499.                      region.right <= me.right &&
  500.                      region.top >= me.top &&
  501.                      region.bottom <= me.bottom );
  502.         },
  503.         getArea : function() {
  504.         var me = this;
  505.             return ( (me.bottom - me.top) * (me.right - me.left) );
  506.         },
  507.         intersect : function(region) {
  508.             var me = this,
  509.              t = Math.max(me.top, region.top),
  510.              r = Math.min(me.right, region.right),
  511.              b = Math.min(me.bottom, region.bottom),
  512.              l = Math.max(me.left, region.left);
  513.             if (b >= t && r >= l) {
  514.                 return new Ext.lib.Region(t, r, b, l);
  515.             }
  516.         },
  517.         
  518.         union : function(region) {
  519.         var me = this,
  520.              t = Math.min(me.top, region.top),
  521.              r = Math.max(me.right, region.right),
  522.              b = Math.max(me.bottom, region.bottom),
  523.              l = Math.min(me.left, region.left);
  524.             return new Ext.lib.Region(t, r, b, l);
  525.         },
  526.         constrainTo : function(r) {
  527.         var me = this;
  528.             me.top = me.top.constrain(r.top, r.bottom);
  529.             me.bottom = me.bottom.constrain(r.top, r.bottom);
  530.             me.left = me.left.constrain(r.left, r.right);
  531.             me.right = me.right.constrain(r.left, r.right);
  532.             return me;
  533.         },
  534.         adjust : function(t, l, b, r) {
  535.         var me = this;
  536.             me.top += t;
  537.             me.left += l;
  538.             me.right += r;
  539.             me.bottom += b;
  540.             return me;
  541.         }
  542.     };
  543.     Ext.lib.Region.getRegion = function(el) {
  544.         var p = Ext.lib.Dom.getXY(el),
  545.          t = p[1],
  546.          r = p[0] + el.offsetWidth,
  547.          b = p[1] + el.offsetHeight,
  548.          l = p[0];
  549.         return new Ext.lib.Region(t, r, b, l);
  550.     }; Ext.lib.Point = function(x, y) {
  551.         if (Ext.isArray(x)) {
  552.             y = x[1];
  553.             x = x[0];
  554.         }
  555.         var me = this;
  556.         me.x = me.right = me.left = me[0] = x;
  557.         me.y = me.top = me.bottom = me[1] = y;
  558.     };
  559.     Ext.lib.Point.prototype = new Ext.lib.Region();
  560. (function(){    
  561.     var EXTLIB = Ext.lib,
  562.         noNegatives = /width|height|opacity|padding/i,
  563.         offsetAttribute = /^((width|height)|(top|left))$/,
  564.         defaultUnit = /width|height|top$|bottom$|left$|right$/i,
  565.         offsetUnit =  /d+(em|%|en|ex|pt|in|cm|mm|pc)$/i,
  566.         isset = function(v){
  567.             return typeof v !== 'undefined';
  568.         },
  569.         now = function(){
  570.             return new Date();    
  571.         };
  572.         
  573.     EXTLIB.Anim = {
  574.         motion : function(el, args, duration, easing, cb, scope) {
  575.             return this.run(el, args, duration, easing, cb, scope, Ext.lib.Motion);
  576.         },
  577.         run : function(el, args, duration, easing, cb, scope, type) {
  578.             type = type || Ext.lib.AnimBase;
  579.             if (typeof easing == "string") {
  580.                 easing = Ext.lib.Easing[easing];
  581.             }
  582.             var anim = new type(el, args, duration, easing);
  583.             anim.animateX(function() {
  584.                 if(Ext.isFunction(cb)){
  585.                     cb.call(scope);
  586.                 }
  587.             });
  588.             return anim;
  589.         }
  590.     };
  591.     
  592.     EXTLIB.AnimBase = function(el, attributes, duration, method) {
  593.         if (el) {
  594.             this.init(el, attributes, duration, method);
  595.         }
  596.     };
  597.     EXTLIB.AnimBase.prototype = {
  598.         doMethod: function(attr, start, end) {
  599.             var me = this;
  600.             return me.method(me.curFrame, start, end - start, me.totalFrames);
  601.         },
  602.         setAttr: function(attr, val, unit) {
  603.             if (noNegatives.test(attr) && val < 0) {
  604.                 val = 0;
  605.             }
  606.             Ext.fly(this.el, '_anim').setStyle(attr, val + unit);
  607.         },
  608.         getAttr: function(attr) {
  609.             var el = Ext.fly(this.el),
  610.                 val = el.getStyle(attr),
  611.                 a = offsetAttribute.exec(attr) || []
  612.             if (val !== 'auto' && !offsetUnit.test(val)) {
  613.                 return parseFloat(val);
  614.             }
  615.             return (!!(a[2]) || (el.getStyle('position') == 'absolute' && !!(a[3]))) ? el.dom['offset' + a[0].charAt(0).toUpperCase() + a[0].substr(1)] : 0;
  616.         },
  617.         getDefaultUnit: function(attr) {
  618.             return defaultUnit.test(attr) ? 'px' : '';
  619.         },
  620.         animateX : function(callback, scope) {
  621.             var me = this,
  622.                 f = function() {
  623.                 me.onComplete.removeListener(f);
  624.                 if (Ext.isFunction(callback)) {
  625.                     callback.call(scope || me, me);
  626.                 }
  627.             };
  628.             me.onComplete.addListener(f, me);
  629.             me.animate();
  630.         },
  631.         setRunAttr: function(attr) {            
  632.             var me = this,
  633.                 a = this.attributes[attr],
  634.                 to = a.to,
  635.                 by = a.by,
  636.                 from = a.from,
  637.                 unit = a.unit,
  638.                 ra = (this.runAttrs[attr] = {}),
  639.                 end;
  640.             if (!isset(to) && !isset(by)){
  641.                 return false;
  642.             }
  643.             var start = isset(from) ? from : me.getAttr(attr);
  644.             if (isset(to)) {
  645.                 end = to;
  646.             }else if(isset(by)) {
  647.                 if (Ext.isArray(start)){
  648.                     end = [];
  649. for(var i=0,len=start.length; i<len; i++) {
  650. end[i] = start[i] + by[i];
  651. }
  652.                 }else{
  653.                     end = start + by;
  654.                 }
  655.             }
  656.             Ext.apply(ra, {
  657.                 start: start,
  658.                 end: end,
  659.                 unit: isset(unit) ? unit : me.getDefaultUnit(attr)
  660.             });
  661.         },
  662.         init: function(el, attributes, duration, method) {
  663.             var me = this,
  664.                 actualFrames = 0,
  665.                 mgr = EXTLIB.AnimMgr;
  666.                 
  667.             Ext.apply(me, {
  668.                 isAnimated: false,
  669.                 startTime: null,
  670.                 el: Ext.getDom(el),
  671.                 attributes: attributes || {},
  672.                 duration: duration || 1,
  673.                 method: method || EXTLIB.Easing.easeNone,
  674.                 useSec: true,
  675.                 curFrame: 0,
  676.                 totalFrames: mgr.fps,
  677.                 runAttrs: {},
  678.                 animate: function(){
  679.                     var me = this,
  680.                         d = me.duration;
  681.                     
  682.                     if(me.isAnimated){
  683.                         return false;
  684.                     }
  685.                     me.curFrame = 0;
  686.                     me.totalFrames = me.useSec ? Math.ceil(mgr.fps * d) : d;
  687.                     mgr.registerElement(me); 
  688.                 },
  689.                 
  690.                 stop: function(finish){
  691.                     var me = this;
  692.                 
  693.                     if(finish){
  694.                         me.curFrame = me.totalFrames;
  695.                         me._onTween.fire();
  696.                     }
  697.                     mgr.stop(me);
  698.                 }
  699.             });
  700.             var onStart = function(){
  701.                 var me = this,
  702.                     attr;
  703.                 
  704.                 me.onStart.fire();
  705.                 me.runAttrs = {};
  706.                 for(attr in this.attributes){
  707.                     this.setRunAttr(attr);
  708.                 }
  709.                 me.isAnimated = true;
  710.                 me.startTime = now();
  711.                 actualFrames = 0;
  712.             };
  713.             var onTween = function(){
  714.                 var me = this;
  715.                 me.onTween.fire({
  716.                     duration: now() - me.startTime,
  717.                     curFrame: me.curFrame
  718.                 });
  719.                 var ra = me.runAttrs;
  720.                 for (var attr in ra) {
  721.                     this.setAttr(attr, me.doMethod(attr, ra[attr].start, ra[attr].end), ra[attr].unit);
  722.                 }
  723.                 ++actualFrames;
  724.             };
  725.             var onComplete = function() {
  726.                 var me = this,
  727.                     actual = (now() - me.startTime) / 1000,
  728.                     data = {
  729.                         duration: actual,
  730.                         frames: actualFrames,
  731.                         fps: actualFrames / actual
  732.                     };
  733.                 me.isAnimated = false;
  734.                 actualFrames = 0;
  735.                 me.onComplete.fire(data);
  736.             };
  737.             me.onStart = new Ext.util.Event(me);
  738.             me.onTween = new Ext.util.Event(me);            
  739.             me.onComplete = new Ext.util.Event(me);
  740.             (me._onStart = new Ext.util.Event(me)).addListener(onStart);
  741.             (me._onTween = new Ext.util.Event(me)).addListener(onTween);
  742.             (me._onComplete = new Ext.util.Event(me)).addListener(onComplete); 
  743.         }
  744.     };
  745.     Ext.lib.AnimMgr = new function() {
  746.         var me = this,
  747.             thread = null,
  748.             queue = [],
  749.             tweenCount = 0;
  750.         Ext.apply(me, {
  751.             fps: 1000,
  752.             delay: 1,
  753.             registerElement: function(tween){
  754.                 queue.push(tween);
  755.                 ++tweenCount;
  756.                 tween._onStart.fire();
  757.                 me.start();
  758.             },
  759.             
  760.             unRegister: function(tween, index){
  761.                 tween._onComplete.fire();
  762.                 index = index || getIndex(tween);
  763.                 if (index != -1) {
  764.                     queue.splice(index, 1);
  765.                 }
  766.                 if (--tweenCount <= 0) {
  767.                     me.stop();
  768.                 }
  769.             },
  770.             
  771.             start: function(){
  772.                 if(thread === null){
  773.                     thread = setInterval(me.run, me.delay);
  774.                 }
  775.             },
  776.             
  777.             stop: function(tween){
  778.                 if(!tween){
  779.                     clearInterval(thread);
  780.                     for(var i = 0, len = queue.length; i < len; ++i){
  781.                         if(queue[0].isAnimated){
  782.                             me.unRegister(queue[0], 0);
  783.                         }
  784.                     }
  785.                     queue = [];
  786.                     thread = null;
  787.                     tweenCount = 0;
  788.                 }else{
  789.                     me.unRegister(tween);
  790.                 }
  791.             },
  792.             
  793.             run: function(){
  794.                 var tf, i, len, tween;
  795.                 for(i = 0, len = queue.length; i<len; i++) {
  796.                     tween = queue[i];
  797.                     if(tween && tween.isAnimated){
  798.                         tf = tween.totalFrames;
  799.                         if(tween.curFrame < tf || tf === null){
  800.                             ++tween.curFrame;
  801.                             if(tween.useSec){
  802.                                 correctFrame(tween);
  803.                             }
  804.                             tween._onTween.fire();
  805.                         }else{
  806.                             me.stop(tween);
  807.                         }
  808.                     }                   
  809.                 }
  810.             }
  811.         });
  812.         var getIndex = function(anim) {
  813.             var i, len;
  814.             for(i = 0, len = queue.length; i<len; i++) {
  815.                 if(queue[i] === anim) {
  816.                     return i;
  817.                 }
  818.             }
  819.             return -1;
  820.         };
  821.         var correctFrame = function(tween) {
  822.             var frames = tween.totalFrames,
  823.                 frame = tween.curFrame,
  824.                 duration = tween.duration,
  825.                 expected = (frame * duration * 1000 / frames),
  826.                 elapsed = (now() - tween.startTime),
  827.                 tweak = 0;
  828.             if(elapsed < duration * 1000){
  829.                 tweak = Math.round((elapsed / expected - 1) * frame);
  830.             }else{
  831.                 tweak = frames - (frame + 1);
  832.             }
  833.             if(tweak > 0 && isFinite(tweak)){
  834.                 if(tween.curFrame + tweak >= frames){
  835.                     tweak = frames - (frame + 1);
  836.                 }
  837.                 tween.curFrame += tweak;
  838.             }
  839.         };
  840.     };
  841.     EXTLIB.Bezier = new function() {
  842.         this.getPosition = function(points, t) {
  843.             var n = points.length,
  844.                 tmp = [],
  845.                 c = 1 - t, 
  846.                 i,
  847.                 j;
  848.             for (i = 0; i < n; ++i) {
  849.                 tmp[i] = [points[i][0], points[i][1]];
  850.             }
  851.             for (j = 1; j < n; ++j) {
  852.                 for (i = 0; i < n - j; ++i) {
  853.                     tmp[i][0] = c * tmp[i][0] + t * tmp[parseInt(i + 1, 10)][0];
  854.                     tmp[i][1] = c * tmp[i][1] + t * tmp[parseInt(i + 1, 10)][1];
  855.                 }
  856.             }
  857.             return [ tmp[0][0], tmp[0][1] ];
  858.         };
  859.     };
  860.     EXTLIB.Easing = {
  861.         easeNone: function (t, b, c, d) {
  862.             return c * t / d + b;
  863.         },
  864.         easeIn: function (t, b, c, d) {
  865.             return c * (t /= d) * t + b;
  866.         },
  867.         easeOut: function (t, b, c, d) {
  868.             return -c * (t /= d) * (t - 2) + b;
  869.         }
  870.     };
  871.     (function() {
  872.         EXTLIB.Motion = function(el, attributes, duration, method) {
  873.             if (el) {
  874.                 EXTLIB.Motion.superclass.constructor.call(this, el, attributes, duration, method);
  875.             }
  876.         };
  877.         Ext.extend(EXTLIB.Motion, Ext.lib.AnimBase);
  878.         var superclass = EXTLIB.Motion.superclass,
  879.             proto = EXTLIB.Motion.prototype,
  880.             pointsRe = /^points$/i;
  881.         Ext.apply(EXTLIB.Motion.prototype, {
  882.             setAttr: function(attr, val, unit){
  883.                 var me = this,
  884.                     setAttr = superclass.setAttr;
  885.                     
  886.                 if (pointsRe.test(attr)) {
  887.                     unit = unit || 'px';
  888.                     setAttr.call(me, 'left', val[0], unit);
  889.                     setAttr.call(me, 'top', val[1], unit);
  890.                 } else {
  891.                     setAttr.call(me, attr, val, unit);
  892.                 }
  893.             },
  894.             
  895.             getAttr: function(attr){
  896.                 var me = this,
  897.                     getAttr = superclass.getAttr;
  898.                     
  899.                 return pointsRe.test(attr) ? [getAttr.call(me, 'left'), getAttr.call(me, 'top')] : getAttr.call(me, attr);
  900.             },
  901.             
  902.             doMethod: function(attr, start, end){
  903.                 var me = this;
  904.                 
  905.                 return pointsRe.test(attr)
  906.                         ? EXTLIB.Bezier.getPosition(me.runAttrs[attr], me.method(me.curFrame, 0, 100, me.totalFrames) / 100)
  907.                         : superclass.doMethod.call(me, attr, start, end);
  908.             },
  909.             
  910.             setRunAttr: function(attr){
  911.                 if(pointsRe.test(attr)){
  912.                     
  913.                     var me = this,
  914.                         el = this.el,
  915.                         points = this.attributes.points,
  916.                         control = points.control || [],
  917.                         from = points.from,
  918.                         to = points.to,
  919.                         by = points.by,
  920.                         DOM = EXTLIB.Dom,
  921.                         start,
  922.                         i,
  923.                         end,
  924.                         len,
  925.                         ra;
  926.                   
  927.                     if(control.length > 0 && !Ext.isArray(control[0])){
  928.                         control = [control];
  929.                     }else{
  930.                         /*
  931.                         var tmp = [];
  932.                         for (i = 0,len = control.length; i < len; ++i) {
  933.                             tmp[i] = control[i];
  934.                         }
  935.                         control = tmp;
  936.                         */
  937.                     }
  938.                     Ext.fly(el, '_anim').position();
  939.                     DOM.setXY(el, isset(from) ? from : DOM.getXY(el));
  940.                     start = me.getAttr('points');
  941.                     if(isset(to)){
  942.                         end = translateValues.call(me, to, start);
  943.                         for (i = 0,len = control.length; i < len; ++i) {
  944.                             control[i] = translateValues.call(me, control[i], start);
  945.                         }
  946.                     } else if (isset(by)) {
  947.                         end = [start[0] + by[0], start[1] + by[1]];
  948.                         for (i = 0,len = control.length; i < len; ++i) {
  949.                             control[i] = [ start[0] + control[i][0], start[1] + control[i][1] ];
  950.                         }
  951.                     }
  952.                     ra = this.runAttrs[attr] = [start];
  953.                     if (control.length > 0) {
  954.                         ra = ra.concat(control);
  955.                     }
  956.                     ra[ra.length] = end;
  957.                 }else{
  958.                     superclass.setRunAttr.call(this, attr);
  959.                 }
  960.             }
  961.         });
  962.         var translateValues = function(val, start) {
  963.             var pageXY = EXTLIB.Dom.getXY(this.el);
  964.             return [val[0] - pageXY[0] + start[0], val[1] - pageXY[1] + start[1]];
  965.         };
  966.     })();
  967. })();// Easing functions
  968. (function(){
  969. // shortcuts to aid compression
  970. var abs = Math.abs,
  971.   pi = Math.PI,
  972.   asin = Math.asin,
  973.   pow = Math.pow,
  974.   sin = Math.sin,
  975. EXTLIB = Ext.lib;
  976.  
  977.     Ext.apply(EXTLIB.Easing, {
  978.         
  979.         easeBoth: function (t, b, c, d) {
  980.         return ((t /= d / 2) < 1)  ?  c / 2 * t * t + b  :  -c / 2 * ((--t) * (t - 2) - 1) + b;               
  981.         },
  982.         
  983.         easeInStrong: function (t, b, c, d) {
  984.             return c * (t /= d) * t * t * t + b;
  985.         },
  986.         easeOutStrong: function (t, b, c, d) {
  987.             return -c * ((t = t / d - 1) * t * t * t - 1) + b;
  988.         },
  989.         easeBothStrong: function (t, b, c, d) {
  990.             return ((t /= d / 2) < 1)  ?  c / 2 * t * t * t * t + b  :  -c / 2 * ((t -= 2) * t * t * t - 2) + b;
  991.         },
  992.         elasticIn: function (t, b, c, d, a, p) {
  993.         if (t == 0 || (t /= d) == 1) {
  994.                 return t == 0 ? b : b + c;
  995.             }             
  996.             p = p || (d * .3);             
  997. var s;
  998. if (a >= abs(c)) {
  999. s = p / (2 * pi) * asin(c / a);
  1000. } else {
  1001. a = c;
  1002. s = p / 4;
  1003. }
  1004.             return -(a * pow(2, 10 * (t -= 1)) * sin((t * d - s) * (2 * pi) / p)) + b;
  1005.                    
  1006.         }, 
  1007. elasticOut: function (t, b, c, d, a, p) {
  1008.         if (t == 0 || (t /= d) == 1) {
  1009.                 return t == 0 ? b : b + c;
  1010.             }             
  1011.             p = p || (d * .3);             
  1012. var s;
  1013. if (a >= abs(c)) {
  1014. s = p / (2 * pi) * asin(c / a);
  1015. } else {
  1016. a = c;
  1017. s = p / 4;
  1018. }
  1019.             return a * pow(2, -10 * t) * sin((t * d - s) * (2 * pi) / p) + c + b;  
  1020.         }, 
  1021.         elasticBoth: function (t, b, c, d, a, p) {
  1022.             if (t == 0 || (t /= d / 2) == 2) {
  1023.                 return t == 0 ? b : b + c;
  1024.             }          
  1025.             
  1026.             p = p || (d * (.3 * 1.5));              
  1027.             var s;
  1028.             if (a >= abs(c)) {
  1029.             s = p / (2 * pi) * asin(c / a);
  1030.             } else {
  1031.             a = c;
  1032.                 s = p / 4;
  1033.             }
  1034.             return t < 1 ?
  1035.                  -.5 * (a * pow(2, 10 * (t -= 1)) * sin((t * d - s) * (2 * pi) / p)) + b :
  1036.                     a * pow(2, -10 * (t -= 1)) * sin((t * d - s) * (2 * pi) / p) * .5 + c + b;
  1037.         },
  1038.         backIn: function (t, b, c, d, s) {
  1039.             s = s ||  1.70158;              
  1040.             return c * (t /= d) * t * ((s + 1) * t - s) + b;
  1041.         },
  1042.         backOut: function (t, b, c, d, s) {
  1043.             if (!s) {
  1044.                 s = 1.70158;
  1045.             }
  1046.             return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
  1047.         },
  1048.         backBoth: function (t, b, c, d, s) {
  1049.             s = s || 1.70158;              
  1050.             return ((t /= d / 2 ) < 1) ?
  1051.                     c / 2 * (t * t * (((s *= (1.525)) + 1) * t - s)) + b :              
  1052.              c / 2 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2) + b;
  1053.         },
  1054.         bounceIn: function (t, b, c, d) {
  1055.             return c - EXTLIB.Easing.bounceOut(d - t, 0, c, d) + b;
  1056.         },
  1057.         bounceOut: function (t, b, c, d) {
  1058.         if ((t /= d) < (1 / 2.75)) {
  1059.                 return c * (7.5625 * t * t) + b;
  1060.             } else if (t < (2 / 2.75)) {
  1061.                 return c * (7.5625 * (t -= (1.5 / 2.75)) * t + .75) + b;
  1062.             } else if (t < (2.5 / 2.75)) {
  1063.                 return c * (7.5625 * (t -= (2.25 / 2.75)) * t + .9375) + b;
  1064.             }
  1065.             return c * (7.5625 * (t -= (2.625 / 2.75)) * t + .984375) + b;
  1066.         },
  1067.         bounceBoth: function (t, b, c, d) {
  1068.             return (t < d / 2) ?
  1069.                    EXTLIB.Easing.bounceIn(t * 2, 0, c, d) * .5 + b : 
  1070.                 EXTLIB.Easing.bounceOut(t * 2 - d, 0, c, d) * .5 + c * .5 + b;
  1071.         }
  1072.     });
  1073. })();
  1074. (function() {
  1075.     var EXTLIB = Ext.lib;
  1076. // Color Animation
  1077. EXTLIB.Anim.color = function(el, args, duration, easing, cb, scope) {
  1078.     return EXTLIB.Anim.run(el, args, duration, easing, cb, scope, EXTLIB.ColorAnim);
  1079. }
  1080.     EXTLIB.ColorAnim = function(el, attributes, duration, method) {
  1081.         EXTLIB.ColorAnim.superclass.constructor.call(this, el, attributes, duration, method);
  1082.     };
  1083.     Ext.extend(EXTLIB.ColorAnim, EXTLIB.AnimBase);
  1084.     var superclass = EXTLIB.ColorAnim.superclass,
  1085.      colorRE = /color$/i,
  1086.      transparentRE = /^transparent|rgba(0, 0, 0, 0)$/,
  1087.         rgbRE = /^rgb(([0-9]+)s*,s*([0-9]+)s*,s*([0-9]+))$/i,
  1088.         hexRE= /^#?([0-9A-F]{2})([0-9A-F]{2})([0-9A-F]{2})$/i,
  1089.         hex3RE = /^#?([0-9A-F]{1})([0-9A-F]{1})([0-9A-F]{1})$/i,
  1090.         isset = function(v){
  1091.             return typeof v !== 'undefined';
  1092.         }
  1093.          
  1094.     // private
  1095.     function parseColor(s) {
  1096.         var pi = parseInt,
  1097.             base,
  1098.             out = null,
  1099.             c;
  1100.         
  1101.     if (s.length == 3) {
  1102.             return s;
  1103.         }
  1104.         Ext.each([hexRE, rgbRE, hex3RE], function(re, idx){
  1105.             base = (idx % 2 == 0) ? 16 : 10;
  1106.             c = re.exec(s);
  1107.             if(c && c.length == 4){
  1108.                 out = [pi(c[1], base), pi(c[2], base), pi(c[3], base)];
  1109.                 return false;
  1110.             }
  1111.         });
  1112.         return out;
  1113.     }
  1114.     Ext.apply(EXTLIB.ColorAnim.prototype, {
  1115.         getAttr : function(attr) {
  1116.             var me = this,
  1117.                 el = me.el,
  1118.                 val;                
  1119.             if(colorRE.test(attr)){
  1120.                 while(el && transparentRE.test(val = Ext.fly(el).getStyle(attr))){
  1121.                     el = el.parentNode;
  1122.                     val = "fff";
  1123.                 }
  1124.             }else{
  1125.                 val = superclass.getAttr.call(me, attr);
  1126.             }
  1127.             return val;
  1128.         },
  1129.         doMethod : function(attr, start, end) {
  1130.             var me = this,
  1131.              val,
  1132.              floor = Math.floor,
  1133. i, len = start.length, v;            
  1134.             if(colorRE.test(attr)){
  1135.                 val = [];
  1136. for(i=0; i<len; i++) {
  1137. v = start[i];
  1138. val[i] = superclass.doMethod.call(me, attr, v, end[i]);
  1139. }
  1140.                 val = 'rgb(' + floor(val[0]) + ',' + floor(val[1]) + ',' + floor(val[2]) + ')';
  1141.             }else{
  1142.                 val = superclass.doMethod.call(me, attr, start, end);
  1143.             }
  1144.             return val;
  1145.         },
  1146.         setRunAttr : function(attr) {
  1147.             var me = this,
  1148.                 a = me.attributes[attr],
  1149.                 to = a.to,
  1150.                 by = a.by,
  1151.                 ra;
  1152.                 
  1153.             superclass.setRunAttr.call(me, attr);
  1154.             ra = me.runAttrs[attr];
  1155.             if(colorRE.test(attr)){
  1156.                 var start = parseColor(ra.start),
  1157.                     end = parseColor(ra.end);
  1158.                 if(!isset(to) && isset(by)){
  1159.                     end = parseColor(by);
  1160. for(var i=0,len=start.length; i<len; i++) {
  1161. end[i] = start[i] + end[i];
  1162. }
  1163.                 }
  1164.                 ra.start = start;
  1165.                 ra.end = end;
  1166.             }
  1167.         }
  1168. });
  1169. })();
  1170. (function() {
  1171.     // Scroll Animation
  1172.     var EXTLIB = Ext.lib;
  1173. EXTLIB.Anim.scroll = function(el, args, duration, easing, cb, scope) {         
  1174.     return EXTLIB.Anim.run(el, args, duration, easing, cb, scope, EXTLIB.Scroll);
  1175. }
  1176.     EXTLIB.Scroll = function(el, attributes, duration, method) {
  1177.         if(el){
  1178.             EXTLIB.Scroll.superclass.constructor.call(this, el, attributes, duration, method);
  1179.         }
  1180.     };
  1181.     Ext.extend(EXTLIB.Scroll, EXTLIB.ColorAnim);
  1182.     var superclass = EXTLIB.Scroll.superclass,
  1183.      SCROLL = 'scroll';
  1184.     Ext.apply(EXTLIB.Scroll.prototype, {
  1185.         doMethod : function(attr, start, end) {
  1186.             var val,
  1187.              me = this,
  1188.              curFrame = me.curFrame,
  1189.              totalFrames = me.totalFrames;
  1190.             if(attr == SCROLL){
  1191.                 val = [me.method(curFrame, start[0], end[0] - start[0], totalFrames),
  1192.                        me.method(curFrame, start[1], end[1] - start[1], totalFrames)];
  1193.             }else{
  1194.                 val = superclass.doMethod.call(me, attr, start, end);
  1195.             }
  1196.             return val;
  1197.         },
  1198.         getAttr : function(attr) {
  1199.             var me = this;
  1200.             if (attr == SCROLL) {
  1201.                 return [me.el.scrollLeft, me.el.scrollTop];
  1202.             }else{
  1203.                 return superclass.getAttr.call(me, attr);
  1204.             }
  1205.         },
  1206.         setAttr : function(attr, val, unit) {
  1207.             var me = this;
  1208.             if(attr == SCROLL){
  1209.                 me.el.scrollLeft = val[0];
  1210.                 me.el.scrollTop = val[1];
  1211.             }else{
  1212.                 superclass.setAttr.call(me, attr, val, unit);
  1213.             }
  1214.         }
  1215.     });
  1216. })();
  1217. if(Ext.isIE) {
  1218.         function fnCleanUp() {
  1219.             var p = Function.prototype;
  1220.             delete p.createSequence;
  1221.             delete p.defer;
  1222.             delete p.createDelegate;
  1223.             delete p.createCallback;
  1224.             delete p.createInterceptor;
  1225.             window.detachEvent("onunload", fnCleanUp);
  1226.         }
  1227.         window.attachEvent("onunload", fnCleanUp);
  1228.     }
  1229. })();