Upgrade to ExtJS 4.0.0 - Released 04/26/2011
[extjs.git] / docs / source / Ext.html
index c503375..066add6 100644 (file)
-<html>\r
-<head>\r
-  <title>The source code</title>\r
-    <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />\r
-    <script type="text/javascript" src="../resources/prettify/prettify.js"></script>\r
-</head>\r
-<body  onload="prettyPrint();">\r
-    <pre class="prettyprint lang-js">\r
-// for old browsers\r
-window.undefined = window.undefined;\r
-\r
-<div id="cls-Ext"></div>/**\r
- * @class Ext\r
- * Ext core utilities and functions.\r
- * @singleton\r
- */\r
-\r
-Ext = {\r
-    <div id="prop-Ext-version"></div>/**\r
-     * The version of the framework\r
-     * @type String\r
-     */\r
-    version : '3.0'\r
-};\r
-\r
-<div id="method-Ext-apply"></div>/**\r
- * Copies all the properties of config to obj.\r
- * @param {Object} obj The receiver of the properties\r
- * @param {Object} config The source of the properties\r
- * @param {Object} defaults A different object that will also be applied for default values\r
- * @return {Object} returns obj\r
- * @member Ext apply\r
- */\r
-Ext.apply = function(o, c, defaults){\r
-    // no "this" reference for friendly out of scope calls\r
-    if(defaults){\r
-        Ext.apply(o, defaults);\r
-    }\r
-    if(o && c && typeof c == 'object'){\r
-        for(var p in c){\r
-            o[p] = c[p];\r
-        }\r
-    }\r
-    return o;\r
-};\r
-\r
-(function(){\r
-    var idSeed = 0,\r
-        toString = Object.prototype.toString,\r
-        //assume it's not null and not an array\r
-        isIterable = function(v){\r
-            //check for array or arguments\r
-            if(Ext.isArray(v) || v.callee){\r
-                return true;\r
-            }\r
-            //check for node list type\r
-            if(/NodeList|HTMLCollection/.test(toString.call(v))){\r
-                return true;\r
-            }\r
-            //NodeList has an item and length property\r
-            //IXMLDOMNodeList has nextNode method, needs to be checked first.\r
-            return ((v.nextNode || v.item) && Ext.isNumber(v.length));\r
-        },\r
-        ua = navigator.userAgent.toLowerCase(),\r
-        check = function(r){\r
-            return r.test(ua);\r
-        },\r
-        DOC = document,\r
-        isStrict = DOC.compatMode == "CSS1Compat",\r
-        isOpera = check(/opera/),\r
-        isChrome = check(/chrome/),\r
-        isWebKit = check(/webkit/),\r
-        isSafari = !isChrome && check(/safari/),\r
-        isSafari2 = isSafari && check(/applewebkit\/4/), // unique to Safari 2\r
-        isSafari3 = isSafari && check(/version\/3/),\r
-        isSafari4 = isSafari && check(/version\/4/),\r
-        isIE = !isOpera && check(/msie/),\r
-        isIE7 = isIE && check(/msie 7/),\r
-        isIE8 = isIE && check(/msie 8/),\r
-        isIE6 = isIE && !isIE7 && !isIE8,\r
-        isGecko = !isWebKit && check(/gecko/),\r
-        isGecko2 = isGecko && check(/rv:1\.8/),\r
-        isGecko3 = isGecko && check(/rv:1\.9/),\r
-        isBorderBox = isIE && !isStrict,\r
-        isWindows = check(/windows|win32/),\r
-        isMac = check(/macintosh|mac os x/),\r
-        isAir = check(/adobeair/),\r
-        isLinux = check(/linux/),\r
-        isSecure = /^https/i.test(window.location.protocol);\r
-\r
-    // remove css image flicker\r
-    if(isIE6){\r
-        try{\r
-            DOC.execCommand("BackgroundImageCache", false, true);\r
-        }catch(e){}\r
-    }\r
-\r
-    Ext.apply(Ext, {\r
-        <div id="prop-Ext-SSL_SECURE_URL"></div>/**\r
-         * URL to a blank file used by Ext when in secure mode for iframe src and onReady src to prevent\r
-         * the IE insecure content warning (defaults to javascript:false).\r
-         * @type String\r
-         */\r
-        SSL_SECURE_URL : 'javascript:false',\r
-        <div id="prop-Ext-isStrict"></div>/**\r
-         * True if the browser is in strict (standards-compliant) mode, as opposed to quirks mode\r
-         * @type Boolean\r
-         */\r
-        isStrict : isStrict,\r
-        <div id="prop-Ext-isSecure"></div>/**\r
-         * True if the page is running over SSL\r
-         * @type Boolean\r
-         */\r
-        isSecure : isSecure,\r
-        <div id="prop-Ext-isReady"></div>/**\r
-         * True when the document is fully initialized and ready for action\r
-         * @type Boolean\r
-         */\r
-        isReady : false,\r
-\r
-        <div id="prop-Ext-enableFx"></div>/**\r
-         * True if the {@link Ext.Fx} Class is available\r
-         * @type Boolean\r
-         * @property enableFx\r
-         */\r
-\r
-        <div id="prop-Ext-enableGarbageCollector"></div>/**\r
-         * True to automatically uncache orphaned Ext.Elements periodically (defaults to true)\r
-         * @type Boolean\r
-         */\r
-        enableGarbageCollector : true,\r
-\r
-        <div id="prop-Ext-enableListenerCollection"></div>/**\r
-         * True to automatically purge event listeners after uncaching an element (defaults to false).\r
-         * Note: this only happens if {@link #enableGarbageCollector} is true.\r
-         * @type Boolean\r
-         */\r
-        enableListenerCollection : false,\r
-\r
-        <div id="prop-Ext-USE_NATIVE_JSON"></div>/**\r
-         * Indicates whether to use native browser parsing for JSON methods.\r
-         * This option is ignored if the browser does not support native JSON methods.\r
-         * <b>Note: Native JSON methods will not work with objects that have functions.\r
-         * Also, property names must be quoted, otherwise the data will not parse.</b> (Defaults to false)\r
-         * @type Boolean\r
-         */\r
-        USE_NATIVE_JSON : false,\r
-\r
-        <div id="method-Ext-applyIf"></div>/**\r
-         * Copies all the properties of config to obj if they don't already exist.\r
-         * @param {Object} obj The receiver of the properties\r
-         * @param {Object} config The source of the properties\r
-         * @return {Object} returns obj\r
-         */\r
-        applyIf : function(o, c){\r
-            if(o){\r
-                for(var p in c){\r
-                    if(Ext.isEmpty(o[p])){\r
-                        o[p] = c[p];\r
-                    }\r
-                }\r
-            }\r
-            return o;\r
-        },\r
-\r
-        <div id="method-Ext-id"></div>/**\r
-         * Generates unique ids. If the element already has an id, it is unchanged\r
-         * @param {Mixed} el (optional) The element to generate an id for\r
-         * @param {String} prefix (optional) Id prefix (defaults "ext-gen")\r
-         * @return {String} The generated Id.\r
-         */\r
-        id : function(el, prefix){\r
-            return (el = Ext.getDom(el) || {}).id = el.id || (prefix || "ext-gen") + (++idSeed);\r
-        },\r
-\r
-        <div id="method-Ext-extend"></div>/**\r
-         * Extends one class with another class and optionally overrides members with the passed literal. This class\r
-         * also adds the function "override()" to the class that can be used to override\r
-         * members on an instance.\r
-         * * <p>\r
-         * This function also supports a 2-argument call in which the subclass's constructor is\r
-         * not passed as an argument. In this form, the parameters are as follows:</p><p>\r
-         * <div class="mdetail-params"><ul>\r
-         * <li><code>superclass</code>\r
-         * <div class="sub-desc">The class being extended</div></li>\r
-         * <li><code>overrides</code>\r
-         * <div class="sub-desc">A literal with members which are copied into the subclass's\r
-         * prototype, and are therefore shared among all instances of the new class.<p>\r
-         * This may contain a special member named <tt><b>constructor</b></tt>. This is used\r
-         * to define the constructor of the new class, and is returned. If this property is\r
-         * <i>not</i> specified, a constructor is generated and returned which just calls the\r
-         * superclass's constructor passing on its parameters.</p></div></li>\r
-         * </ul></div></p><p>\r
-         * For example, to create a subclass of the Ext GridPanel:\r
-         * <pre><code>\r
-MyGridPanel = Ext.extend(Ext.grid.GridPanel, {\r
-    constructor: function(config) {\r
-        // Your preprocessing here\r
-        MyGridPanel.superclass.constructor.apply(this, arguments);\r
-        // Your postprocessing here\r
-    },\r
-\r
-    yourMethod: function() {\r
-        // etc.\r
-    }\r
-});\r
-</code></pre>\r
-         * </p>\r
-         * @param {Function} subclass The class inheriting the functionality\r
-         * @param {Function} superclass The class being extended\r
-         * @param {Object} overrides (optional) A literal with members which are copied into the subclass's\r
-         * prototype, and are therefore shared between all instances of the new class.\r
-         * @return {Function} The subclass constructor.\r
-         * @method extend\r
-         */\r
-        extend : function(){\r
-            // inline overrides\r
-            var io = function(o){\r
-                for(var m in o){\r
-                    this[m] = o[m];\r
-                }\r
-            };\r
-            var oc = Object.prototype.constructor;\r
-\r
-            return function(sb, sp, overrides){\r
-                if(Ext.isObject(sp)){\r
-                    overrides = sp;\r
-                    sp = sb;\r
-                    sb = overrides.constructor != oc ? overrides.constructor : function(){sp.apply(this, arguments);};\r
-                }\r
-                var F = function(){},\r
-                    sbp,\r
-                    spp = sp.prototype;\r
-\r
-                F.prototype = spp;\r
-                sbp = sb.prototype = new F();\r
-                sbp.constructor=sb;\r
-                sb.superclass=spp;\r
-                if(spp.constructor == oc){\r
-                    spp.constructor=sp;\r
-                }\r
-                sb.override = function(o){\r
-                    Ext.override(sb, o);\r
-                };\r
-                sbp.superclass = sbp.supr = (function(){\r
-                    return spp;\r
-                });\r
-                sbp.override = io;\r
-                Ext.override(sb, overrides);\r
-                sb.extend = function(o){Ext.extend(sb, o);};\r
-                return sb;\r
-            };\r
-        }(),\r
-\r
-        <div id="method-Ext-override"></div>/**\r
-         * Adds a list of functions to the prototype of an existing class, overwriting any existing methods with the same name.\r
-         * Usage:<pre><code>\r
-Ext.override(MyClass, {\r
-    newMethod1: function(){\r
-        // etc.\r
-    },\r
-    newMethod2: function(foo){\r
-        // etc.\r
-    }\r
-});\r
-</code></pre>\r
-         * @param {Object} origclass The class to override\r
-         * @param {Object} overrides The list of functions to add to origClass.  This should be specified as an object literal\r
-         * containing one or more methods.\r
-         * @method override\r
-         */\r
-        override : function(origclass, overrides){\r
-            if(overrides){\r
-                var p = origclass.prototype;\r
-                Ext.apply(p, overrides);\r
-                if(Ext.isIE && overrides.toString != origclass.toString){\r
-                    p.toString = overrides.toString;\r
-                }\r
-            }\r
-        },\r
-\r
-        /**\r
-         * Creates namespaces to be used for scoping variables and classes so that they are not global.\r
-         * Specifying the last node of a namespace implicitly creates all other nodes. Usage:\r
-         * <pre><code>\r
-Ext.namespace('Company', 'Company.data');\r
-Ext.namespace('Company.data'); // equivalent and preferable to above syntax\r
-Company.Widget = function() { ... }\r
-Company.data.CustomStore = function(config) { ... }\r
-</code></pre>\r
-         * @param {String} namespace1\r
-         * @param {String} namespace2\r
-         * @param {String} etc\r
-         * @method namespace\r
-         */\r
-        namespace : function(){\r
-            var o, d;\r
-            Ext.each(arguments, function(v) {\r
-                d = v.split(".");\r
-                o = window[d[0]] = window[d[0]] || {};\r
-                Ext.each(d.slice(1), function(v2){\r
-                    o = o[v2] = o[v2] || {};\r
-                });\r
-            });\r
-            return o;\r
-        },\r
-\r
-        <div id="method-Ext-urlEncode"></div>/**\r
-         * 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.\r
-         * @param {Object} o\r
-         * @param {String} pre (optional) A prefix to add to the url encoded string\r
-         * @return {String}\r
-         */\r
-        urlEncode: function(o, pre){\r
-            var undef, buf = [], key, e = encodeURIComponent;\r
-\r
-            for(key in o){\r
-                undef = !Ext.isDefined(o[key]);\r
-                Ext.each(undef ? key : o[key], function(val, i){\r
-                    buf.push("&", e(key), "=", (val != key || !undef) ? e(val) : "");\r
-                });\r
-            }\r
-            if(!pre){\r
-                buf.shift();\r
-                pre = "";\r
-            }\r
-            return pre + buf.join('');\r
-        },\r
-\r
-        <div id="method-Ext-urlDecode"></div>/**\r
-         * Takes an encoded URL and and converts it to an object. Example: <pre><code>\r
-Ext.urlDecode("foo=1&bar=2"); // returns {foo: "1", bar: "2"}\r
-Ext.urlDecode("foo=1&bar=2&bar=3&bar=4", false); // returns {foo: "1", bar: ["2", "3", "4"]}\r
-</code></pre>\r
-         * @param {String} string\r
-         * @param {Boolean} overwrite (optional) Items of the same name will overwrite previous values instead of creating an an array (Defaults to false).\r
-         * @return {Object} A literal with members\r
-         */\r
-        urlDecode : function(string, overwrite){\r
-            var obj = {},\r
-                pairs = string.split('&'),\r
-                d = decodeURIComponent,\r
-                name,\r
-                value;\r
-            Ext.each(pairs, function(pair) {\r
-                pair = pair.split('=');\r
-                name = d(pair[0]);\r
-                value = d(pair[1]);\r
-                obj[name] = overwrite || !obj[name] ? value :\r
-                            [].concat(obj[name]).concat(value);\r
-            });\r
-            return obj;\r
-        },\r
-\r
-        <div id="method-Ext-urlAppend"></div>/**\r
-         * Appends content to the query string of a URL, which handles logic for whether to place\r
-         * a question mark or ampersand.\r
-         * @param {String} url The url to append to.\r
-         * @@param {String} s The content to append to the url.\r
-         * @return (String) The appended string\r
-         */\r
-        urlAppend : function(url, s){\r
-            if(!Ext.isEmpty(s)){\r
-                return url + (url.indexOf('?') === -1 ? '?' : '&') + s;\r
-            }\r
-            return url;\r
-        },\r
-\r
-        <div id="method-Ext-toArray"></div>/**\r
-         * Converts any iterable (numeric indices and a length property) into a true array\r
-         * Don't use this on strings. IE doesn't support "abc"[0] which this implementation depends on.\r
-         * For strings, use this instead: "abc".match(/./g) => [a,b,c];\r
-         * @param {Iterable} the iterable object to be turned into a true Array.\r
-         * @return (Array) array\r
-         */\r
-        toArray : function(){\r
-            return isIE ?\r
-                function(a, i, j, res){\r
-                    res = [];\r
-                    Ext.each(a, function(v) {\r
-                        res.push(v);\r
-                    });\r
-                    return res.slice(i || 0, j || res.length);\r
-                } :\r
-                function(a, i, j){\r
-                    return Array.prototype.slice.call(a, i || 0, j || a.length);\r
-                }\r
-        }(),\r
-\r
-        <div id="method-Ext-each"></div>/**\r
-         * Iterates an array calling the passed function with each item, stopping if your function returns false. If the\r
-         * passed array is not really an array, your function is called once with it.\r
-         * The supplied function is called with (Object item, Number index, Array allItems).\r
-         * @param {Array/NodeList/Mixed} array\r
-         * @param {Function} fn\r
-         * @param {Object} scope\r
-         */\r
-        each: function(array, fn, scope){\r
-            if(Ext.isEmpty(array, true)){\r
-                return;\r
-            }\r
-            if(!isIterable(array) || Ext.isPrimitive(array)){\r
-                array = [array];\r
-            }\r
-            for(var i = 0, len = array.length; i < len; i++){\r
-                if(fn.call(scope || array[i], array[i], i, array) === false){\r
-                    return i;\r
-                };\r
-            }\r
-        },\r
-\r
-        <div id="method-Ext-iterate"></div>/**\r
-         * Iterates either the elements in an array, or each of the properties in an object.\r
-         * <b>Note</b>: If you are only iterating arrays, it is better to call {@link #each}.\r
-         * @param {Object/Array} object The object or array to be iterated\r
-         * @param {Function} fn The function to be called for each iteration.\r
-         * The iteration will stop if the supplied function returns false, or\r
-         * all array elements / object properties have been covered. The signature\r
-         * varies depending on the type of object being interated:\r
-         * <div class="mdetail-params"><ul>\r
-         * <li>Arrays : <tt>(Object item, Number index, Array allItems)</tt>\r
-         * <div class="sub-desc">\r
-         * When iterating an array, the supplied function is called with each item.</div></li>\r
-         * <li>Objects : <tt>(String key, Object value)</tt>\r
-         * <div class="sub-desc">\r
-         * When iterating an object, the supplied function is called with each key-value pair in\r
-         * the object.</div></li>\r
-         * </ul></div>\r
-         * @param {Object} scope The scope to call the supplied function with, defaults to\r
-         * the specified <tt>object</tt>\r
-         */\r
-        iterate : function(obj, fn, scope){\r
-            if(isIterable(obj)){\r
-                Ext.each(obj, fn, scope);\r
-                return;\r
-            }else if(Ext.isObject(obj)){\r
-                for(var prop in obj){\r
-                    if(obj.hasOwnProperty(prop)){\r
-                        if(fn.call(scope || obj, prop, obj[prop]) === false){\r
-                            return;\r
-                        };\r
-                    }\r
-                }\r
-            }\r
-        },\r
-\r
-        <div id="method-Ext-getDom"></div>/**\r
-         * Return the dom node for the passed String (id), dom node, or Ext.Element.\r
-         * Here are some examples:\r
-         * <pre><code>\r
-// gets dom node based on id\r
-var elDom = Ext.getDom('elId');\r
-// gets dom node based on the dom node\r
-var elDom1 = Ext.getDom(elDom);\r
-\r
-// If we don&#39;t know if we are working with an\r
-// Ext.Element or a dom node use Ext.getDom\r
-function(el){\r
-    var dom = Ext.getDom(el);\r
-    // do something with the dom node\r
-}\r
-         * </code></pre>\r
-         * <b>Note</b>: the dom node to be found actually needs to exist (be rendered, etc)\r
-         * when this method is called to be successful.\r
-         * @param {Mixed} el\r
-         * @return HTMLElement\r
-         */\r
-        getDom : function(el){\r
-            if(!el || !DOC){\r
-                return null;\r
-            }\r
-            return el.dom ? el.dom : (Ext.isString(el) ? DOC.getElementById(el) : el);\r
-        },\r
-\r
-        <div id="method-Ext-getBody"></div>/**\r
-         * Returns the current document body as an {@link Ext.Element}.\r
-         * @return Ext.Element The document body\r
-         */\r
-        getBody : function(){\r
-            return Ext.get(DOC.body || DOC.documentElement);\r
-        },\r
-\r
-        <div id="method-Ext-removeNode"></div>/**\r
-         * Removes a DOM node from the document.  The body node will be ignored if passed in.\r
-         * @param {HTMLElement} node The node to remove\r
-         */\r
-        removeNode : isIE ? function(){\r
-            var d;\r
-            return function(n){\r
-                if(n && n.tagName != 'BODY'){\r
-                    d = d || DOC.createElement('div');\r
-                    d.appendChild(n);\r
-                    d.innerHTML = '';\r
-                }\r
-            }\r
-        }() : function(n){\r
-            if(n && n.parentNode && n.tagName != 'BODY'){\r
-                n.parentNode.removeChild(n);\r
-            }\r
-        },\r
-\r
-        <div id="method-Ext-isEmpty"></div>/**\r
-         * <p>Returns true if the passed value is empty.</p>\r
-         * <p>The value is deemed to be empty if it is<div class="mdetail-params"><ul>\r
-         * <li>null</li>\r
-         * <li>undefined</li>\r
-         * <li>an empty array</li>\r
-         * <li>a zero length string (Unless the <tt>allowBlank</tt> parameter is <tt>true</tt>)</li>\r
-         * </ul></div>\r
-         * @param {Mixed} value The value to test\r
-         * @param {Boolean} allowBlank (optional) true to allow empty strings (defaults to false)\r
-         * @return {Boolean}\r
-         */\r
-        isEmpty : function(v, allowBlank){\r
-            return v === null || v === undefined || ((Ext.isArray(v) && !v.length)) || (!allowBlank ? v === '' : false);\r
-        },\r
-\r
-        <div id="method-Ext-isArray"></div>/**\r
-         * Returns true if the passed object is a JavaScript array, otherwise false.\r
-         * @param {Object} object The object to test\r
-         * @return {Boolean}\r
-         */\r
-        isArray : function(v){\r
-            return toString.apply(v) === '[object Array]';\r
-        },\r
-\r
-        <div id="method-Ext-isObject"></div>/**\r
-         * Returns true if the passed object is a JavaScript Object, otherwise false.\r
-         * @param {Object} object The object to test\r
-         * @return {Boolean}\r
-         */\r
-        isObject : function(v){\r
-            return v && typeof v == "object";\r
-        },\r
-\r
-        <div id="method-Ext-isPrimitive"></div>/**\r
-         * Returns true if the passed object is a JavaScript 'primitive', a string, number or boolean.\r
-         * @param {Mixed} value The value to test\r
-         * @return {Boolean}\r
-         */\r
-        isPrimitive : function(v){\r
-            return Ext.isString(v) || Ext.isNumber(v) || Ext.isBoolean(v);\r
-        },\r
-\r
-        <div id="method-Ext-isFunction"></div>/**\r
-         * Returns true if the passed object is a JavaScript Function, otherwise false.\r
-         * @param {Object} object The object to test\r
-         * @return {Boolean}\r
-         */\r
-        isFunction : function(v){\r
-            return toString.apply(v) === '[object Function]';\r
-        },\r
-\r
-        <div id="method-Ext-isNumber"></div>/**\r
-         * Returns true if the passed object is a number. Returns false for non-finite numbers.\r
-         * @param {Object} v The object to test\r
-         * @return {Boolean}\r
-         */\r
-        isNumber: function(v){\r
-            return typeof v === 'number' && isFinite(v);\r
-        },\r
-\r
-        <div id="method-Ext-isString"></div>/**\r
-         * Returns true if the passed object is a string.\r
-         * @param {Object} v The object to test\r
-         * @return {Boolean}\r
-         */\r
-        isString: function(v){\r
-            return typeof v === 'string';\r
-        },\r
-\r
-        <div id="method-Ext-isBoolean"></div>/**\r
-         * Returns true if the passed object is a boolean.\r
-         * @param {Object} v The object to test\r
-         * @return {Boolean}\r
-         */\r
-        isBoolean: function(v){\r
-            return typeof v === 'boolean';\r
-        },\r
-\r
-        <div id="method-Ext-isDefined"></div>/**\r
-         * Returns true if the passed object is not undefined.\r
-         * @param {Object} v The object to test\r
-         * @return {Boolean}\r
-         */\r
-        isDefined: function(v){\r
-            return typeof v !== 'undefined';\r
-        },\r
-\r
-        <div id="prop-Ext-isOpera"></div>/**\r
-         * True if the detected browser is Opera.\r
-         * @type Boolean\r
-         */\r
-        isOpera : isOpera,\r
-        <div id="prop-Ext-isWebKit"></div>/**\r
-         * True if the detected browser uses WebKit.\r
-         * @type Boolean\r
-         */\r
-        isWebKit: isWebKit,\r
-        <div id="prop-Ext-isChrome"></div>/**\r
-         * True if the detected browser is Chrome.\r
-         * @type Boolean\r
-         */\r
-        isChrome : isChrome,\r
-        <div id="prop-Ext-isSafari"></div>/**\r
-         * True if the detected browser is Safari.\r
-         * @type Boolean\r
-         */\r
-        isSafari : isSafari,\r
-        <div id="prop-Ext-isSafari3"></div>/**\r
-         * True if the detected browser is Safari 3.x.\r
-         * @type Boolean\r
-         */\r
-        isSafari3 : isSafari3,\r
-        <div id="prop-Ext-isSafari4"></div>/**\r
-         * True if the detected browser is Safari 4.x.\r
-         * @type Boolean\r
-         */\r
-        isSafari4 : isSafari4,\r
-        <div id="prop-Ext-isSafari2"></div>/**\r
-         * True if the detected browser is Safari 2.x.\r
-         * @type Boolean\r
-         */\r
-        isSafari2 : isSafari2,\r
-        <div id="prop-Ext-isIE"></div>/**\r
-         * True if the detected browser is Internet Explorer.\r
-         * @type Boolean\r
-         */\r
-        isIE : isIE,\r
-        <div id="prop-Ext-isIE6"></div>/**\r
-         * True if the detected browser is Internet Explorer 6.x.\r
-         * @type Boolean\r
-         */\r
-        isIE6 : isIE6,\r
-        <div id="prop-Ext-isIE7"></div>/**\r
-         * True if the detected browser is Internet Explorer 7.x.\r
-         * @type Boolean\r
-         */\r
-        isIE7 : isIE7,\r
-        <div id="prop-Ext-isIE8"></div>/**\r
-         * True if the detected browser is Internet Explorer 8.x.\r
-         * @type Boolean\r
-         */\r
-        isIE8 : isIE8,\r
-        <div id="prop-Ext-isGecko"></div>/**\r
-         * True if the detected browser uses the Gecko layout engine (e.g. Mozilla, Firefox).\r
-         * @type Boolean\r
-         */\r
-        isGecko : isGecko,\r
-        <div id="prop-Ext-isGecko2"></div>/**\r
-         * True if the detected browser uses a pre-Gecko 1.9 layout engine (e.g. Firefox 2.x).\r
-         * @type Boolean\r
-         */\r
-        isGecko2 : isGecko2,\r
-        <div id="prop-Ext-isGecko3"></div>/**\r
-         * True if the detected browser uses a Gecko 1.9+ layout engine (e.g. Firefox 3.x).\r
-         * @type Boolean\r
-         */\r
-        isGecko3 : isGecko3,\r
-        <div id="prop-Ext-isBorderBox"></div>/**\r
-         * True if the detected browser is Internet Explorer running in non-strict mode.\r
-         * @type Boolean\r
-         */\r
-        isBorderBox : isBorderBox,\r
-        <div id="prop-Ext-isLinux"></div>/**\r
-         * True if the detected platform is Linux.\r
-         * @type Boolean\r
-         */\r
-        isLinux : isLinux,\r
-        <div id="prop-Ext-isWindows"></div>/**\r
-         * True if the detected platform is Windows.\r
-         * @type Boolean\r
-         */\r
-        isWindows : isWindows,\r
-        <div id="prop-Ext-isMac"></div>/**\r
-         * True if the detected platform is Mac OS.\r
-         * @type Boolean\r
-         */\r
-        isMac : isMac,\r
-        <div id="prop-Ext-isAir"></div>/**\r
-         * True if the detected platform is Adobe Air.\r
-         * @type Boolean\r
-         */\r
-        isAir : isAir\r
-    });\r
-\r
-    <div id="method-Ext-namespace"></div>/**\r
-     * Creates namespaces to be used for scoping variables and classes so that they are not global.\r
-     * Specifying the last node of a namespace implicitly creates all other nodes. Usage:\r
-     * <pre><code>\r
-Ext.namespace('Company', 'Company.data');\r
-Ext.namespace('Company.data'); // equivalent and preferable to above syntax\r
-Company.Widget = function() { ... }\r
-Company.data.CustomStore = function(config) { ... }\r
-</code></pre>\r
-     * @param {String} namespace1\r
-     * @param {String} namespace2\r
-     * @param {String} etc\r
-     * @method namespace\r
-     */\r
-    Ext.ns = Ext.namespace;\r
-})();\r
-\r
-Ext.ns("Ext", "Ext.util", "Ext.lib", "Ext.data");\r
-\r
-\r
-<div id="cls-Function"></div>/**\r
- * @class Function\r
- * These functions are available on every Function object (any JavaScript function).\r
- */\r
-Ext.apply(Function.prototype, {\r
-     <div id="method-Function-createInterceptor"></div>/**\r
-     * Creates an interceptor function. The passed fcn is called before the original one. If it returns false,\r
-     * the original one is not called. The resulting function returns the results of the original function.\r
-     * The passed fcn is called with the parameters of the original function. Example usage:\r
-     * <pre><code>\r
-var sayHi = function(name){\r
-    alert('Hi, ' + name);\r
-}\r
-\r
-sayHi('Fred'); // alerts "Hi, Fred"\r
-\r
-// create a new function that validates input without\r
-// directly modifying the original function:\r
-var sayHiToFriend = sayHi.createInterceptor(function(name){\r
-    return name == 'Brian';\r
-});\r
-\r
-sayHiToFriend('Fred');  // no alert\r
-sayHiToFriend('Brian'); // alerts "Hi, Brian"\r
-</code></pre>\r
-     * @param {Function} fcn The function to call before the original\r
-     * @param {Object} scope (optional) The scope of the passed fcn (Defaults to scope of original function or window)\r
-     * @return {Function} The new function\r
-     */\r
-    createInterceptor : function(fcn, scope){\r
-        var method = this;\r
-        return !Ext.isFunction(fcn) ?\r
-                this :\r
-                function() {\r
-                    var me = this,\r
-                        args = arguments;\r
-                    fcn.target = me;\r
-                    fcn.method = method;\r
-                    return (fcn.apply(scope || me || window, args) !== false) ?\r
-                            method.apply(me || window, args) :\r
-                            null;\r
-                };\r
-    },\r
-\r
-     <div id="method-Function-createCallback"></div>/**\r
-     * Creates a callback that passes arguments[0], arguments[1], arguments[2], ...\r
-     * Call directly on any function. Example: <code>myFunction.createCallback(arg1, arg2)</code>\r
-     * Will create a function that is bound to those 2 args. <b>If a specific scope is required in the\r
-     * callback, use {@link #createDelegate} instead.</b> The function returned by createCallback always\r
-     * executes in the window scope.\r
-     * <p>This method is required when you want to pass arguments to a callback function.  If no arguments\r
-     * are needed, you can simply pass a reference to the function as a callback (e.g., callback: myFn).\r
-     * However, if you tried to pass a function with arguments (e.g., callback: myFn(arg1, arg2)) the function\r
-     * would simply execute immediately when the code is parsed. Example usage:\r
-     * <pre><code>\r
-var sayHi = function(name){\r
-    alert('Hi, ' + name);\r
-}\r
-\r
-// clicking the button alerts "Hi, Fred"\r
-new Ext.Button({\r
-    text: 'Say Hi',\r
-    renderTo: Ext.getBody(),\r
-    handler: sayHi.createCallback('Fred')\r
-});\r
-</code></pre>\r
-     * @return {Function} The new function\r
-    */\r
-    createCallback : function(/*args...*/){\r
-        // make args available, in function below\r
-        var args = arguments,\r
-            method = this;\r
-        return function() {\r
-            return method.apply(window, args);\r
-        };\r
-    },\r
-\r
-    <div id="method-Function-createDelegate"></div>/**\r
-     * Creates a delegate (callback) that sets the scope to obj.\r
-     * Call directly on any function. Example: <code>this.myFunction.createDelegate(this, [arg1, arg2])</code>\r
-     * Will create a function that is automatically scoped to obj so that the <tt>this</tt> variable inside the\r
-     * callback points to obj. Example usage:\r
-     * <pre><code>\r
-var sayHi = function(name){\r
-    // Note this use of "this.text" here.  This function expects to\r
-    // execute within a scope that contains a text property.  In this\r
-    // example, the "this" variable is pointing to the btn object that\r
-    // was passed in createDelegate below.\r
-    alert('Hi, ' + name + '. You clicked the "' + this.text + '" button.');\r
-}\r
-\r
-var btn = new Ext.Button({\r
-    text: 'Say Hi',\r
-    renderTo: Ext.getBody()\r
-});\r
-\r
-// This callback will execute in the scope of the\r
-// button instance. Clicking the button alerts\r
-// "Hi, Fred. You clicked the "Say Hi" button."\r
-btn.on('click', sayHi.createDelegate(btn, ['Fred']));\r
-</code></pre>\r
-     * @param {Object} obj (optional) The object for which the scope is set\r
-     * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)\r
-     * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,\r
-     *                                             if a number the args are inserted at the specified position\r
-     * @return {Function} The new function\r
-     */\r
-    createDelegate : function(obj, args, appendArgs){\r
-        var method = this;\r
-        return function() {\r
-            var callArgs = args || arguments;\r
-            if (appendArgs === true){\r
-                callArgs = Array.prototype.slice.call(arguments, 0);\r
-                callArgs = callArgs.concat(args);\r
-            }else if (Ext.isNumber(appendArgs)){\r
-                callArgs = Array.prototype.slice.call(arguments, 0); // copy arguments first\r
-                var applyArgs = [appendArgs, 0].concat(args); // create method call params\r
-                Array.prototype.splice.apply(callArgs, applyArgs); // splice them in\r
-            }\r
-            return method.apply(obj || window, callArgs);\r
-        };\r
-    },\r
-\r
-    <div id="method-Function-defer"></div>/**\r
-     * Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:\r
-     * <pre><code>\r
-var sayHi = function(name){\r
-    alert('Hi, ' + name);\r
-}\r
-\r
-// executes immediately:\r
-sayHi('Fred');\r
-\r
-// executes after 2 seconds:\r
-sayHi.defer(2000, this, ['Fred']);\r
-\r
-// this syntax is sometimes useful for deferring\r
-// execution of an anonymous function:\r
-(function(){\r
-    alert('Anonymous');\r
-}).defer(100);\r
-</code></pre>\r
-     * @param {Number} millis The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)\r
-     * @param {Object} obj (optional) The object for which the scope is set\r
-     * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)\r
-     * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,\r
-     *                                             if a number the args are inserted at the specified position\r
-     * @return {Number} The timeout id that can be used with clearTimeout\r
-     */\r
-    defer : function(millis, obj, args, appendArgs){\r
-        var fn = this.createDelegate(obj, args, appendArgs);\r
-        if(millis > 0){\r
-            return setTimeout(fn, millis);\r
-        }\r
-        fn();\r
-        return 0;\r
-    }\r
-});\r
-\r
-<div id="cls-String"></div>/**\r
- * @class String\r
- * These functions are available on every String object.\r
- */\r
-Ext.applyIf(String, {\r
-    <div id="method-String-format"></div>/**\r
-     * Allows you to define a tokenized string and pass an arbitrary number of arguments to replace the tokens.  Each\r
-     * token must be unique, and must increment in the format {0}, {1}, etc.  Example usage:\r
-     * <pre><code>\r
-var cls = 'my-class', text = 'Some text';\r
-var s = String.format('&lt;div class="{0}">{1}&lt;/div>', cls, text);\r
-// s now contains the string: '&lt;div class="my-class">Some text&lt;/div>'\r
-     * </code></pre>\r
-     * @param {String} string The tokenized string to be formatted\r
-     * @param {String} value1 The value to replace token {0}\r
-     * @param {String} value2 Etc...\r
-     * @return {String} The formatted string\r
-     * @static\r
-     */\r
-    format : function(format){\r
-        var args = Ext.toArray(arguments, 1);\r
-        return format.replace(/\{(\d+)\}/g, function(m, i){\r
-            return args[i];\r
-        });\r
-    }\r
-});\r
-\r
-<div id="cls-Array"></div>/**\r
- * @class Array\r
- */\r
-Ext.applyIf(Array.prototype, {\r
-    <div id="method-Array-indexOf"></div>/**\r
-     * Checks whether or not the specified object exists in the array.\r
-     * @param {Object} o The object to check for\r
-     * @return {Number} The index of o in the array (or -1 if it is not found)\r
-     */\r
-    indexOf : function(o){\r
-        for (var i = 0, len = this.length; i < len; i++){\r
-            if(this[i] == o){\r
-                return i;\r
-            }\r
-        }\r
-        return -1;\r
-    },\r
-\r
-    <div id="method-Array-remove"></div>/**\r
-     * Removes the specified object from the array.  If the object is not found nothing happens.\r
-     * @param {Object} o The object to remove\r
-     * @return {Array} this array\r
-     */\r
-    remove : function(o){\r
-        var index = this.indexOf(o);\r
-        if(index != -1){\r
-            this.splice(index, 1);\r
-        }\r
-        return this;\r
-    }\r
-});\r
-</pre>    \r
-</body>\r
-</html>
\ No newline at end of file
+<!DOCTYPE html><html><head><title>Sencha Documentation Project</title><link rel="stylesheet" href="../reset.css" type="text/css"><link rel="stylesheet" href="../prettify.css" type="text/css"><link rel="stylesheet" href="../prettify_sa.css" type="text/css"><script type="text/javascript" src="../prettify.js"></script></head><body onload="prettyPrint()"><pre class="prettyprint"><pre><span id='Ext'>/**
+</span> * @class Ext
+ * @singleton
+ */
+(function() {
+    var global = this,
+        objectPrototype = Object.prototype,
+        toString = Object.prototype.toString,
+        enumerables = true,
+        enumerablesTest = { toString: 1 },
+        i;
+
+    if (typeof Ext === 'undefined') {
+        global.Ext = {};
+    }
+
+    Ext.global = global;
+
+    for (i in enumerablesTest) {
+        enumerables = null;
+    }
+
+    if (enumerables) {
+        enumerables = ['hasOwnProperty', 'valueOf', 'isPrototypeOf', 'propertyIsEnumerable',
+                       'toLocaleString', 'toString', 'constructor'];
+    }
+
+<span id='Ext-property-enumerables'>    /**
+</span>     * An array containing extra enumerables for old browsers
+     * @type Array
+     */
+    Ext.enumerables = enumerables;
+
+<span id='Ext-method-apply'>    /**
+</span>     * Copies all the properties of config to the specified object.
+     * Note that if recursive merging and cloning without referencing the original objects / arrays is needed, use
+     * {@link Ext.Object#merge} instead.
+     * @param {Object} object 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
+     */
+    Ext.apply = function(object, config, defaults) {
+        if (defaults) {
+            Ext.apply(object, defaults);
+        }
+
+        if (object &amp;&amp; config &amp;&amp; typeof config === 'object') {
+            var i, j, k;
+
+            for (i in config) {
+                object[i] = config[i];
+            }
+
+            if (enumerables) {
+                for (j = enumerables.length; j--;) {
+                    k = enumerables[j];
+                    if (config.hasOwnProperty(k)) {
+                        object[k] = config[k];
+                    }
+                }
+            }
+        }
+
+        return object;
+    };
+
+    Ext.buildSettings = Ext.apply({
+        baseCSSPrefix: 'x-',
+        scopeResetCSS: false
+    }, Ext.buildSettings || {});
+
+    Ext.apply(Ext, {
+<span id='Ext-method-emptyFn'>        /**
+</span>         * A reusable empty function
+         */
+        emptyFn: function() {},
+
+        baseCSSPrefix: Ext.buildSettings.baseCSSPrefix,
+
+<span id='Ext-method-applyIf'>        /**
+</span>         * Copies all the properties of config to object if they don't already exist.
+         * @function
+         * @param {Object} object The receiver of the properties
+         * @param {Object} config The source of the properties
+         * @return {Object} returns obj
+         */
+        applyIf: function(object, config) {
+            var property;
+
+            if (object) {
+                for (property in config) {
+                    if (object[property] === undefined) {
+                        object[property] = config[property];
+                    }
+                }
+            }
+
+            return object;
+        },
+
+<span id='Ext-method-iterate'>        /**
+</span>         * Iterates either an array or an object. This method delegates to
+         * {@link Ext.Array#each Ext.Array.each} if the given value is iterable, and {@link Ext.Object#each Ext.Object.each} otherwise.
+         *
+         * @param {Object/Array} object The object or array to be iterated.
+         * @param {Function} fn The function to be called for each iteration. See and {@link Ext.Array#each Ext.Array.each} and
+         * {@link Ext.Object#each Ext.Object.each} for detailed lists of arguments passed to this function depending on the given object
+         * type that is being iterated.
+         * @param {Object} scope (Optional) The scope (`this` reference) in which the specified function is executed.
+         * Defaults to the object being iterated itself.
+         * @markdown
+         */
+        iterate: function(object, fn, scope) {
+            if (Ext.isEmpty(object)) {
+                return;
+            }
+
+            if (scope === undefined) {
+                scope = object;
+            }
+
+            if (Ext.isIterable(object)) {
+                Ext.Array.each.call(Ext.Array, object, fn, scope);
+            }
+            else {
+                Ext.Object.each.call(Ext.Object, object, fn, scope);
+            }
+        }
+    });
+
+    Ext.apply(Ext, {
+
+<span id='Ext-method-extend'>        /**
+</span>         * This method deprecated. Use {@link Ext#define Ext.define} instead.
+         * @function
+         * @param {Function} superclass
+         * @param {Object} overrides
+         * @return {Function} The subclass constructor from the &lt;tt&gt;overrides&lt;/tt&gt; parameter, or a generated one if not provided.
+         * @deprecated 4.0.0 Use {@link Ext#define Ext.define} instead
+         */
+        extend: function() {
+            // inline overrides
+            var objectConstructor = objectPrototype.constructor,
+                inlineOverrides = function(o) {
+                for (var m in o) {
+                    if (!o.hasOwnProperty(m)) {
+                        continue;
+                    }
+                    this[m] = o[m];
+                }
+            };
+
+            return function(subclass, superclass, overrides) {
+                // First we check if the user passed in just the superClass with overrides
+                if (Ext.isObject(superclass)) {
+                    overrides = superclass;
+                    superclass = subclass;
+                    subclass = overrides.constructor !== objectConstructor ? overrides.constructor : function() {
+                        superclass.apply(this, arguments);
+                    };
+                }
+
+                //&lt;debug&gt;
+                if (!superclass) {
+                    Ext.Error.raise({
+                        sourceClass: 'Ext',
+                        sourceMethod: 'extend',
+                        msg: 'Attempting to extend from a class which has not been loaded on the page.'
+                    });
+                }
+                //&lt;/debug&gt;
+
+                // We create a new temporary class
+                var F = function() {},
+                    subclassProto, superclassProto = superclass.prototype;
+
+                F.prototype = superclassProto;
+                subclassProto = subclass.prototype = new F();
+                subclassProto.constructor = subclass;
+                subclass.superclass = superclassProto;
+
+                if (superclassProto.constructor === objectConstructor) {
+                    superclassProto.constructor = superclass;
+                }
+
+                subclass.override = function(overrides) {
+                    Ext.override(subclass, overrides);
+                };
+
+                subclassProto.override = inlineOverrides;
+                subclassProto.proto = subclassProto;
+
+                subclass.override(overrides);
+                subclass.extend = function(o) {
+                    return Ext.extend(subclass, o);
+                };
+
+                return subclass;
+            };
+        }(),
+
+<span id='Ext-method-override'>        /**
+</span>         * Proxy to {@link Ext.Base#override}. Please refer {@link Ext.Base#override} for further details.
+
+    Ext.define('My.cool.Class', {
+        sayHi: function() {
+            alert('Hi!');
+        }
+    }
+
+    Ext.override(My.cool.Class, {
+        sayHi: function() {
+            alert('About to say...');
+
+            this.callOverridden();
+        }
+    });
+
+    var cool = new My.cool.Class();
+    cool.sayHi(); // alerts 'About to say...'
+                  // alerts 'Hi!'
+
+         * Please note that `this.callOverridden()` only works if the class was previously
+         * created with {@link Ext#define)
+         *
+         * @param {Object} cls 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
+         * @markdown
+         */
+        override: function(cls, overrides) {
+            if (cls.prototype.$className) {
+                return cls.override(overrides);
+            }
+            else {
+                Ext.apply(cls.prototype, overrides);
+            }
+        }
+    });
+
+    // A full set of static methods to do type checking
+    Ext.apply(Ext, {
+
+<span id='Ext-method-valueFrom'>        /**
+</span>         * Returns the given value itself if it's not empty, as described in {@link Ext#isEmpty}; returns the default
+         * value (second argument) otherwise.
+         *
+         * @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
+         */
+        valueFrom: function(value, defaultValue, allowBlank){
+            return Ext.isEmpty(value, allowBlank) ? defaultValue : value;
+        },
+
+<span id='Ext-method-typeOf'>        /**
+</span>         * Returns the type of the given variable in string format. List of possible values are:
+         *
+         * - `undefined`: If the given value is `undefined`
+         * - `null`: If the given value is `null`
+         * - `string`: If the given value is a string
+         * - `number`: If the given value is a number
+         * - `boolean`: If the given value is a boolean value
+         * - `date`: If the given value is a `Date` object
+         * - `function`: If the given value is a function reference
+         * - `object`: If the given value is an object
+         * - `array`: If the given value is an array
+         * - `regexp`: If the given value is a regular expression
+         * - `element`: If the given value is a DOM Element
+         * - `textnode`: If the given value is a DOM text node and contains something other than whitespace
+         * - `whitespace`: If the given value is a DOM text node and contains only whitespace
+         *
+         * @param {Mixed} value
+         * @return {String}
+         * @markdown
+         */
+        typeOf: function(value) {
+            if (value === null) {
+                return 'null';
+            }
+
+            var type = typeof value;
+
+            if (type === 'undefined' || type === 'string' || type === 'number' || type === 'boolean') {
+                return type;
+            }
+
+            var typeToString = toString.call(value);
+
+            switch(typeToString) {
+                case '[object Array]':
+                    return 'array';
+                case '[object Date]':
+                    return 'date';
+                case '[object Boolean]':
+                    return 'boolean';
+                case '[object Number]':
+                    return 'number';
+                case '[object RegExp]':
+                    return 'regexp';
+            }
+
+            if (type === 'function') {
+                return 'function';
+            }
+
+            if (type === 'object') {
+                if (value.nodeType !== undefined) {
+                    if (value.nodeType === 3) {
+                        return (/\S/).test(value.nodeValue) ? 'textnode' : 'whitespace';
+                    }
+                    else {
+                        return 'element';
+                    }
+                }
+
+                return 'object';
+            }
+
+            //&lt;debug error&gt;
+            Ext.Error.raise({
+                sourceClass: 'Ext',
+                sourceMethod: 'typeOf',
+                msg: 'Failed to determine the type of the specified value &quot;' + value + '&quot;. This is most likely a bug.'
+            });
+            //&lt;/debug&gt;
+        },
+
+<span id='Ext-method-isEmpty'>        /**
+</span>         * Returns true if the passed value is empty, false otherwise. The value is deemed to be empty if it is either:
+         *
+         * - `null`
+         * - `undefined`
+         * - a zero-length array
+         * - a zero-length string (Unless the `allowEmptyString` parameter is set to `true`)
+         *
+         * @param {Mixed} value The value to test
+         * @param {Boolean} allowEmptyString (optional) true to allow empty strings (defaults to false)
+         * @return {Boolean}
+         * @markdown
+         */
+        isEmpty: function(value, allowEmptyString) {
+            return (value === null) || (value === undefined) || (!allowEmptyString ? value === '' : false) || (Ext.isArray(value) &amp;&amp; value.length === 0);
+        },
+
+<span id='Ext-property-isArray'>        /**
+</span>         * Returns true if the passed value is a JavaScript Array, false otherwise.
+         *
+         * @param {Mixed} target The target to test
+         * @return {Boolean}
+         */
+        isArray: ('isArray' in Array) ? Array.isArray : function(value) {
+            return toString.call(value) === '[object Array]';
+        },
+
+<span id='Ext-method-isDate'>        /**
+</span>         * Returns true if the passed value is a JavaScript Date object, false otherwise.
+         * @param {Object} object The object to test
+         * @return {Boolean}
+         */
+        isDate: function(value) {
+            return toString.call(value) === '[object Date]';
+        },
+
+<span id='Ext-property-isObject'>        /**
+</span>         * Returns true if the passed value is a JavaScript Object, false otherwise.
+         * @param {Mixed} value The value to test
+         * @return {Boolean}
+         */
+        isObject: (toString.call(null) === '[object Object]') ?
+        function(value) {
+            return value !== null &amp;&amp; value !== undefined &amp;&amp; toString.call(value) === '[object Object]' &amp;&amp; value.nodeType === undefined;
+        } :
+        function(value) {
+            return toString.call(value) === '[object Object]';
+        },
+
+<span id='Ext-method-isPrimitive'>        /**
+</span>         * 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(value) {
+            var type = typeof value;
+
+            return type === 'string' || type === 'number' || type === 'boolean';
+        },
+
+<span id='Ext-property-isFunction'>        /**
+</span>         * Returns true if the passed value is a JavaScript Function, false otherwise.
+         * @param {Mixed} value The value to test
+         * @return {Boolean}
+         */
+        isFunction:
+        // Safari 3.x and 4.x returns 'function' for typeof &lt;NodeList&gt;, hence we need to fall back to using
+        // Object.prorotype.toString (slower)
+        (typeof document !== 'undefined' &amp;&amp; typeof document.getElementsByTagName('body') === 'function') ? function(value) {
+            return toString.call(value) === '[object Function]';
+        } : function(value) {
+            return typeof value === 'function';
+        },
+
+<span id='Ext-method-isNumber'>        /**
+</span>         * 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(value) {
+            return typeof value === 'number' &amp;&amp; isFinite(value);
+        },
+
+<span id='Ext-method-isNumeric'>        /**
+</span>         * Validates that a value is numeric.
+         * @param {Mixed} value Examples: 1, '1', '2.34'
+         * @return {Boolean} True if numeric, false otherwise
+         */
+        isNumeric: function(value) {
+            return !isNaN(parseFloat(value)) &amp;&amp; isFinite(value);
+        },
+
+<span id='Ext-method-isString'>        /**
+</span>         * Returns true if the passed value is a string.
+         * @param {Mixed} value The value to test
+         * @return {Boolean}
+         */
+        isString: function(value) {
+            return typeof value === 'string';
+        },
+
+<span id='Ext-method-isBoolean'>        /**
+</span>         * Returns true if the passed value is a boolean.
+         *
+         * @param {Mixed} value The value to test
+         * @return {Boolean}
+         */
+        isBoolean: function(value) {
+            return typeof value === 'boolean';
+        },
+
+<span id='Ext-method-isElement'>        /**
+</span>         * Returns true if the passed value is an HTMLElement
+         * @param {Mixed} value The value to test
+         * @return {Boolean}
+         */
+        isElement: function(value) {
+            return value ? value.nodeType !== undefined : false;
+        },
+
+<span id='Ext-method-isTextNode'>        /**
+</span>         * Returns true if the passed value is a TextNode
+         * @param {Mixed} value The value to test
+         * @return {Boolean}
+         */
+        isTextNode: function(value) {
+            return value ? value.nodeName === &quot;#text&quot; : false;
+        },
+
+<span id='Ext-method-isDefined'>        /**
+</span>         * Returns true if the passed value is defined.
+         * @param {Mixed} value The value to test
+         * @return {Boolean}
+         */
+        isDefined: function(value) {
+            return typeof value !== 'undefined';
+        },
+
+<span id='Ext-method-isIterable'>        /**
+</span>         * Returns true if the passed value is iterable, false otherwise
+         * @param {Mixed} value The value to test
+         * @return {Boolean}
+         */
+        isIterable: function(value) {
+            return (value &amp;&amp; typeof value !== 'string') ? value.length !== undefined : false;
+        }
+    });
+
+    Ext.apply(Ext, {
+
+<span id='Ext-method-clone'>        /**
+</span>         * Clone almost any type of variable including array, object, DOM nodes and Date without keeping the old reference
+         * @param {Mixed} item The variable to clone
+         * @return {Mixed} clone
+         */
+        clone: function(item) {
+            if (item === null || item === undefined) {
+                return item;
+            }
+
+            // DOM nodes
+            // TODO proxy this to Ext.Element.clone to handle automatic id attribute changing
+            // recursively
+            if (item.nodeType &amp;&amp; item.cloneNode) {
+                return item.cloneNode(true);
+            }
+
+            var type = toString.call(item);
+
+            // Date
+            if (type === '[object Date]') {
+                return new Date(item.getTime());
+            }
+
+            var i, j, k, clone, key;
+
+            // Array
+            if (type === '[object Array]') {
+                i = item.length;
+
+                clone = [];
+
+                while (i--) {
+                    clone[i] = Ext.clone(item[i]);
+                }
+            }
+            // Object
+            else if (type === '[object Object]' &amp;&amp; item.constructor === Object) {
+                clone = {};
+
+                for (key in item) {
+                    clone[key] = Ext.clone(item[key]);
+                }
+
+                if (enumerables) {
+                    for (j = enumerables.length; j--;) {
+                        k = enumerables[j];
+                        clone[k] = item[k];
+                    }
+                }
+            }
+
+            return clone || item;
+        },
+
+<span id='Ext-method-getUniqueGlobalNamespace'>        /**
+</span>         * @private
+         * Generate a unique reference of Ext in the global scope, useful for sandboxing
+         */
+        getUniqueGlobalNamespace: function() {
+            var uniqueGlobalNamespace = this.uniqueGlobalNamespace;
+
+            if (uniqueGlobalNamespace === undefined) {
+                var i = 0;
+
+                do {
+                    uniqueGlobalNamespace = 'ExtSandbox' + (++i);
+                } while (Ext.global[uniqueGlobalNamespace] !== undefined);
+
+                Ext.global[uniqueGlobalNamespace] = Ext;
+                this.uniqueGlobalNamespace = uniqueGlobalNamespace;
+            }
+
+            return uniqueGlobalNamespace;
+        },
+
+<span id='Ext-method-functionFactory'>        /**
+</span>         * @private
+         */
+        functionFactory: function() {
+            var args = Array.prototype.slice.call(arguments);
+
+            if (args.length &gt; 0) {
+                args[args.length - 1] = 'var Ext=window.' + this.getUniqueGlobalNamespace() + ';' +
+                    args[args.length - 1];
+            }
+
+            return Function.prototype.constructor.apply(Function.prototype, args);
+        }
+    });
+
+<span id='Ext-property-type'>    /**
+</span>     * Old alias to {@link Ext#typeOf}
+     * @deprecated 4.0.0 Use {@link Ext#typeOf} instead
+     */
+    Ext.type = Ext.typeOf;
+
+})();
+</pre></pre></body></html>
\ No newline at end of file