Alien-Web-ExtJS-V3
view release on metacpan or search on metacpan
share/adapter/jquery/ext-jquery-adapter-debug.js view on Meta::CPAN
</code></pre>
*
* <p>This function also supports a 3-argument call in which the subclass's constructor is
* passed as an argument. In this form, the parameters are as follows:</p>
* <div class="mdetail-params"><ul>
* <li><code>subclass</code> : Function <div class="sub-desc">The subclass constructor.</div></li>
* <li><code>superclass</code> : Function <div class="sub-desc">The constructor of class being extended</div></li>
* <li><code>overrides</code> : Object <div class="sub-desc">A literal with members which are copied into the subclass's
* prototype, and are therefore shared among all instances of the new class.</div></li>
* </ul></div>
*
* @param {Function} superclass The constructor of class being extended.
* @param {Object} overrides <p>A literal with members which are copied into the subclass's
* prototype, and are therefore shared between all instances of the new class.</p>
* <p>This may contain a special member named <tt><b>constructor</b></tt>. This is used
* to define the constructor of the new class, and is returned. If this property is
* <i>not</i> specified, a constructor is generated and returned which just calls the
* superclass's constructor passing on its parameters.</p>
* <p><b>It is essential that you call the superclass constructor in any provided constructor. See example code.</b></p>
* @return {Function} The subclass constructor from the <code>overrides</code> parameter, or a generated one if not provided.
*/
extend : function(){
// inline overrides
var io = function(o){
for(var m in o){
this[m] = o[m];
}
};
var oc = Object.prototype.constructor;
return function(sb, sp, overrides){
if(typeof sp == 'object'){
overrides = sp;
sp = sb;
sb = overrides.constructor != oc ? overrides.constructor : function(){sp.apply(this, arguments);};
}
var F = function(){},
sbp,
spp = sp.prototype;
F.prototype = spp;
sbp = sb.prototype = new F();
sbp.constructor=sb;
sb.superclass=spp;
if(spp.constructor == oc){
spp.constructor=sp;
}
sb.override = function(o){
Ext.override(sb, o);
};
sbp.superclass = sbp.supr = (function(){
return spp;
});
sbp.override = io;
Ext.override(sb, overrides);
sb.extend = function(o){return Ext.extend(sb, o);};
return sb;
};
}(),
global: (function () {
return this;
})(),
Base: Base,
namespaceCache: {},
createNamespace: function (namespaceOrClass, isClass) {
var cache = Ext.namespaceCache,
namespace = isClass ? namespaceOrClass.substring(0, namespaceOrClass.lastIndexOf('.'))
: namespaceOrClass,
ns = cache[namespace],
i, n, part, parts, partials;
if (!ns) {
ns = Ext.global;
if (namespace) {
partials = [];
parts = namespace.split('.');
for (i = 0, n = parts.length; i < n; ++i) {
part = parts[i];
ns = ns[part] || (ns[part] = {});
partials.push(part);
cache[partials.join('.')] = ns; // build up prefixes as we go
}
}
}
return ns;
},
getClassByName: function (className) {
var parts = className.split('.'),
cls = Ext.global,
n = parts.length,
i;
for (i = 0; cls && i < n; ++i) {
cls = cls[parts[i]];
}
return cls || null;
},
addMembers: function (cls, target, members, handleNonEnumerables) {
var i, name, member;
for (name in members) {
if (members.hasOwnProperty(name)) {
member = members[name];
if (typeof member == 'function') {
member.$owner = cls;
member.$name = name;
}
target[name] = member;
}
}
if (handleNonEnumerables && nonEnumerables) {
for (i = nonEnumerables.length; i-- > 0; ) {
name = nonEnumerables[i];
if (members.hasOwnProperty(name)) {
member = members[name];
if (typeof member == 'function') {
member.$owner = cls;
member.$name = name;
}
target[name] = member;
}
}
}
},
/**
* @method
* Defines a class or override. A basic class is defined like this:
*
* Ext.define('My.awesome.Class', {
* someProperty: 'something',
*
* someMethod: function(s) {
* alert(s + this.someProperty);
* }
*
* ...
* });
*
* var obj = new My.awesome.Class();
*
* obj.someMethod('Say '); // alerts 'Say something'
*
* To create an anonymous class, pass `null` for the `className`:
share/adapter/jquery/ext-jquery-adapter-debug.js view on Meta::CPAN
*/
override: function (target, overrides) {
var proto, statics;
if (overrides) {
if (target.$isClass) {
statics = overrides.statics;
if (statics) {
delete overrides.statics;
}
Ext.addMembers(target, target.prototype, overrides, true);
if (statics) {
Ext.addMembers(target, target, statics);
}
} else if (typeof target == 'function') {
proto = target.prototype;
Ext.apply(proto, overrides);
if(Ext.isIE && overrides.hasOwnProperty('toString')){
proto.toString = overrides.toString;
}
} else {
var owner = target.self,
name, value;
if (owner && owner.$isClass) {
for (name in overrides) {
if (overrides.hasOwnProperty(name)) {
value = overrides[name];
if (typeof value == 'function') {
//<debug>
if (owner.$className) {
value.displayName = owner.$className + '#' + name;
}
//</debug>
value.$name = name;
value.$owner = owner;
value.$previous = target.hasOwnProperty(name)
? target[name] // already hooked, so call previous hook
: callOverrideParent; // calls by name on prototype
}
target[name] = value;
}
}
} else {
Ext.apply(target, overrides);
if (!target.constructor.$isClass) {
target.constructor.prototype.callParent = Base.prototype.callParent;
target.constructor.callParent = Base.callParent;
}
}
}
}
},
/**
* Creates namespaces to be used for scoping variables and classes so that they are not global.
* Specifying the last node of a namespace implicitly creates all other nodes. Usage:
* <pre><code>
Ext.namespace('Company', 'Company.data');
Ext.namespace('Company.data'); // equivalent and preferable to above syntax
Company.Widget = function() { ... }
Company.data.CustomStore = function(config) { ... }
</code></pre>
* @param {String} namespace1
* @param {String} namespace2
* @param {String} etc
* @return {Object} The namespace object. (If multiple arguments are passed, this will be the last namespace created)
* @method namespace
*/
namespace : function(){
var len1 = arguments.length,
i = 0,
len2,
j,
main,
ns,
sub,
current;
for(; i < len1; ++i) {
main = arguments[i];
ns = arguments[i].split('.');
current = window[ns[0]];
if (current === undefined) {
current = window[ns[0]] = {};
}
sub = ns.slice(1);
len2 = sub.length;
for(j = 0; j < len2; ++j) {
current = current[sub[j]] = current[sub[j]] || {};
}
}
return current;
},
/**
* 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/v...
* @param {Object} o
* @param {String} pre (optional) A prefix to add to the url encoded string
* @return {String}
*/
urlEncode : function(o, pre){
var empty,
buf = [],
e = encodeURIComponent;
Ext.iterate(o, function(key, item){
empty = Ext.isEmpty(item);
Ext.each(empty ? key : item, function(val){
buf.push('&', e(key), '=', (!Ext.isEmpty(val) && (val != key || !empty)) ? (Ext.isDate(val) ? Ext.encode(val).replace(/"/g, '') : e(val)) : '');
});
});
if(!pre){
buf.shift();
pre = '';
}
share/adapter/jquery/ext-jquery-adapter-debug.js view on Meta::CPAN
/**
* True if the detected browser is Internet Explorer 9.x or lower
* @type Boolean
*/
isIE9m : isIE9m,
/**
* True if the detected browser is Internet Explorer 10.x or higher
* @type Boolean
*/
isIE10p : isIE && !(isIE6 || isIE7 || isIE8 || isIE9),
// IE10 quirks behaves like Gecko/WebKit quirks, so don't include it here
// Used internally
isIEQuirks: isIE && (!isStrict && (isIE6 || isIE7 || isIE8 || isIE9)),
/**
* True if the detected browser uses the Gecko layout engine (e.g. Mozilla, Firefox).
* @type Boolean
*/
isGecko : isGecko,
/**
* True if the detected browser uses a pre-Gecko 1.9 layout engine (e.g. Firefox 2.x).
* @type Boolean
*/
isGecko2 : isGecko2,
/**
* True if the detected browser uses a Gecko 1.9+ layout engine (e.g. Firefox 3.x).
* @type Boolean
*/
isGecko3 : isGecko3,
/**
* True if the detected browser is Internet Explorer running in non-strict mode.
* @type Boolean
*/
isBorderBox : isBorderBox,
/**
* True if the detected platform is Linux.
* @type Boolean
*/
isLinux : isLinux,
/**
* True if the detected platform is Windows.
* @type Boolean
*/
isWindows : isWindows,
/**
* True if the detected platform is Mac OS.
* @type Boolean
*/
isMac : isMac,
/**
* True if the detected platform is Adobe Air.
* @type Boolean
*/
isAir : isAir
});
/**
* Creates namespaces to be used for scoping variables and classes so that they are not global.
* Specifying the last node of a namespace implicitly creates all other nodes. Usage:
* <pre><code>
Ext.namespace('Company', 'Company.data');
Ext.namespace('Company.data'); // equivalent and preferable to above syntax
Company.Widget = function() { ... }
Company.data.CustomStore = function(config) { ... }
</code></pre>
* @param {String} namespace1
* @param {String} namespace2
* @param {String} etc
* @return {Object} The namespace object. (If multiple arguments are passed, this will be the last namespace created)
* @method ns
*/
Ext.ns = Ext.namespace;
})();
Ext.ns('Ext.util', 'Ext.lib', 'Ext.data', 'Ext.supports');
Ext.elCache = {};
/**
* @class Function
* These functions are available on every Function object (any JavaScript function).
*/
Ext.apply(Function.prototype, {
/**
* Creates an interceptor function. The passed function is called before the original one. If it returns false,
* the original one is not called. The resulting function returns the results of the original function.
* The passed function is called with the parameters of the original function. Example usage:
* <pre><code>
var sayHi = function(name){
alert('Hi, ' + name);
}
sayHi('Fred'); // alerts "Hi, Fred"
// create a new function that validates input without
// directly modifying the original function:
var sayHiToFriend = sayHi.createInterceptor(function(name){
return name == 'Brian';
});
sayHiToFriend('Fred'); // no alert
sayHiToFriend('Brian'); // alerts "Hi, Brian"
</code></pre>
* @param {Function} fcn The function to call before the original
* @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the passed function is executed.
* <b>If omitted, defaults to the scope in which the original function is called or the browser window.</b>
* @return {Function} The new function
*/
createInterceptor : function(fcn, scope){
var method = this;
return !Ext.isFunction(fcn) ?
this :
function() {
var me = this,
args = arguments;
fcn.target = me;
fcn.method = method;
return (fcn.apply(scope || me || window, args) !== false) ?
( run in 1.347 second using v1.01-cache-2.11-cpan-97f6503c9c8 )