Ext SIP Phone 源代码

/* This file is part of Ext JS 4.2 Copyright (c) 2011-2013 Sencha Inc Contact: http://www.sencha.com/contact Commercial Usage Licensees holding valid commercial licenses may use this file in accordance with the Commercial Software License Agreement provided with the Software or, alternatively, in accordance with the terms contained in a written agreement between you and Sencha. If you are unsure which license is appropriate for your use, please contact the sales department at http://www.sencha.com/contact. Build date: 2013-05-16 14:36:50 (f9be68accb407158ba2b1be2c226a6ce1f649314) */ (function(Ext) { Ext.sandboxName = 'Ext4'; Ext.isSandboxed = true; Ext.buildSettings = { baseCSSPrefix: "x4-", scopeResetCSS: true }; // @tag foundation,core // @define Ext /** * @class Ext * @singleton */ var Ext = Ext || {}; Ext._startTime = new Date().getTime(); (function() { var global = this, objectPrototype = Object.prototype, toString = objectPrototype.toString, enumerables = true, enumerablesTest = {toString: 1}, emptyFn = function () {}, // This is the "$previous" method of a hook function on an instance. When called, it // calls through the class prototype by the name of the called method. callOverrideParent = function () { var method = callOverrideParent.caller.caller; // skip callParent (our caller) return method.$owner.prototype[method.$name].apply(this, arguments); }, i, nonWhitespaceRe = /\S/, ExtApp, iterableRe = /\[object\s*(?:Array|Arguments|\w*Collection|\w*List|HTML\s+document\.all\s+class)\]/; Function.prototype.$extIsFunction = true; Ext.global = global; for (i in enumerablesTest) { enumerables = null; } if (enumerables) { enumerables = ['hasOwnProperty', 'valueOf', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'constructor']; } /** * An array containing extra enumerables for old browsers * @property {String[]} */ Ext.enumerables = enumerables; /** * 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 && config && 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-' }, Ext.buildSettings || {}); Ext.apply(Ext, { /** * @property {String} [name='Ext'] * <p>The name of the property in the global namespace (The <code>window</code> in browser environments) which refers to the current instance of Ext.</p> * <p>This is usually <code>"Ext"</code>, but if a sandboxed build of ExtJS is being used, this will be an alternative name.</p> * <p>If code is being generated for use by <code>eval</code> or to create a <code>new Function</code>, and the global instance * of Ext must be referenced, this is the name that should be built into the code.</p> */ name: Ext.sandboxName || 'Ext', /** * @property {Function} * A reusable empty function */ emptyFn: emptyFn, /** * A reusable identity function. The function will always return the first argument, unchanged. */ identityFn: function(o) { return o; }, /** * A zero length string which will pass a truth test. Useful for passing to methods * which use a truth test to reject <i>falsy</i> values where a string value must be cleared. */ emptyString: new String(), baseCSSPrefix: Ext.buildSettings.baseCSSPrefix, /** * Copies all the properties of config to object if they don't already exist. * @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; }, /** * 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, { /** * This method deprecated. Use {@link Ext#define Ext.define} instead. * @method * @param {Function} superclass * @param {Object} overrides * @return {Function} The subclass constructor from the <tt>overrides</tt> 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); }; } if (!superclass) { Ext.Error.raise({ sourceClass: 'Ext',