--- /dev/null
+<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'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('<div class="{0}">{1}</div>', cls, text);\r
+// s now contains the string: '<div class="my-class">Some text</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
git.ithinksw.org / extjs.git / blobdiff