/**
* @author Jacky Nguyen <jacky@sencha.com>
* @docauthor Jacky Nguyen <jacky@sencha.com>
* @class Ext.Base
*
* The root of all classes created with {@link Ext#define}
* All prototype and static members of this class are inherited by any other class
*
*/
(function(flexSetter) {
var Base = Ext.Base = function() {};
Base.prototype = {
$className: 'Ext.Base',
$class: Base,
/**
* Get the reference to the current class from which this object was instantiated. Unlike {@link Ext.Base#statics},
* `this.self` is scope-dependent and it's meant to be used for dynamic inheritance. See {@link Ext.Base#statics}
* for a detailed comparison
Ext.define('My.Cat', {
statics: {
speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
},
constructor: function() {
alert(this.self.speciesName); / dependent on 'this'
return this;
},
clone: function() {
return new this.self();
}
});
Ext.define('My.SnowLeopard', {
extend: 'My.Cat',
statics: {
speciesName: 'Snow Leopard' // My.SnowLeopard.speciesName = 'Snow Leopard'
}
});
var cat = new My.Cat(); // alerts 'Cat'
var snowLeopard = new My.SnowLeopard(); // alerts 'Snow Leopard'
var clone = snowLeopard.clone();
alert(Ext.getClassName(clone)); // alerts 'My.SnowLeopard'
* @type Class
* @protected
* @markdown
*/
self: Base,
/**
* Default constructor, simply returns `this`
*
* @constructor
* @protected
* @return {Object} this
*/
constructor: function() {
return this;
},
/**
* Initialize configuration for this class. a typical example:
Ext.define('My.awesome.Class', {
// The default config
config: {
name: 'Awesome',
isAwesome: true
},
constructor: function(config) {
this.initConfig(config);
return this;
}
});
var awesome = new My.awesome.Class({
name: 'Super Awesome'
});
alert(awesome.getName()); // 'Super Awesome'
* @protected
* @param {Object} config
* @return {Object} mixins The mixin prototypes as key - value pairs
* @markdown
*/
initConfig: function(config) {
if (!this.$configInited) {
this.config = Ext.Object.merge({}, this.config || {}, config || {});
this.applyConfig(this.config);
this.$configInited = true;
}
return this;
},
/**
* @private
*/
setConfig: function(config) {
this.applyConfig(config || {});
return this;
},
/**
* @private
*/
applyConfig: flexSetter(function(name, value) {
var setter = 'set' + Ext.String.capitalize(name);
if (typeof this[setter] === 'function') {
this[setter].call(this, value);
}
return this;
}),
/**
* Call the parent's overridden method. For example:
Ext.define('My.own.A', {
constructor: function(test) {
alert(test);
}
});
Ext.define('My.own.B', {
extend: 'My.own.A',
constructor: function(test) {
alert(test);
this.callParent([test + 1]);
}
});
Ext.define('My.own.C', {
extend: 'My.own.B',
constructor: function() {
alert("Going to call parent's overriden constructor...");
this.callParent(arguments);
}
});
var a = new My.own.A(1); // alerts '1'
var b = new My.own.B(1); // alerts '1', then alerts '2'
var c = new My.own.C(2); // alerts "Going to call parent's overriden constructor..."
// alerts '2', then alerts '3'
* @protected
* @param {Array/Arguments} args The arguments, either an array or the `arguments` object
* from the current method, for example: `this.callParent(arguments)`
* @return {Mixed} Returns the result from the superclass' method
* @markdown
*/
callParent: function(args) {
var method = this.callParent.caller,
parentClass, methodName;
if (!method.$owner) {
//<debug error>
if (!method.caller) {
Ext.Error.raise({
sourceClass: Ext.getClassName(this),
sourceMethod: "callParent",
msg: "Attempting to call a protected method from the public scope, which is not allowed"
});
}
//</debug>
method = method.caller;
}
parentClass = method.$owner.superclass;
methodName = method.$name;
//<debug error>
if (!(methodName in parentClass)) {
Ext.Error.raise({
sourceClass: Ext.getClassName(this),
sourceMethod: methodName,
msg: "this.callParent() was called but there's no such method (" + methodName +
") found in the parent class (" + (Ext.getClassName(parentClass) || 'Object') + ")"
});
}
//</debug>
return parentClass[methodName].apply(this, args || []);
},
/**
* Get the reference to the class from which this object was instantiated. Note that unlike {@link Ext.Base#self},
* `this.statics()` is scope-independent and it always returns the class from which it was called, regardless of what
* `this` points to during run-time
Ext.define('My.Cat', {
statics: {
totalCreated: 0,
speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
},
constructor: function() {
var statics = this.statics();
alert(statics.speciesName); // always equals to 'Cat' no matter what 'this' refers to
// equivalent to: My.Cat.speciesName
alert(this.self.speciesName); // dependent on 'this'
statics.totalCreated++;
return this;
},
clone: function() {
var cloned = new this.self; // dependent on 'this'
cloned.groupName = this.statics().speciesName; // equivalent to: My.Cat.speciesName
return cloned;
}
});
Ext.define('My.SnowLeopard', {
extend: 'My.Cat',
statics: {
speciesName: 'Snow Leopard' // My.SnowLeopard.speciesName = 'Snow Leopard'
},
constructor: function() {
this.callParent();
}
});
var cat = new My.Cat(); // alerts 'Cat', then alerts 'Cat'
var snowLeopard = new My.SnowLeopard(); // alerts 'Cat', then alerts 'Snow Leopard'
var clone = snowLeopard.clone();
alert(Ext.getClassName(clone)); // alerts 'My.SnowLeopard'
alert(clone.groupName); // alerts 'Cat'
alert(My.Cat.totalCreated); // alerts 3
* @protected
* @return {Class}
* @markdown
*/
statics: function() {
var method = this.statics.caller,
self = this.self;
if (!method) {
return self;
}
return method.$owner;
},
/**
* Call the original method that was previously overridden with {@link Ext.Base#override}
Ext.define('My.Cat', {
constructor: function() {
alert("I'm a cat!");
return this;
}
});
My.Cat.override({
constructor: function() {
alert("I'm going to be a cat!");
var instance = this.callOverridden();
alert("Meeeeoooowwww");
return instance;
}
});
var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
// alerts "I'm a cat!"
// alerts "Meeeeoooowwww"
* @param {Array/Arguments} args The arguments, either an array or the `arguments` object
* @return {Mixed} Returns the result after calling the overridden method
* @markdown
*/
callOverridden: function(args) {
var method = this.callOverridden.caller;
//<debug error>
if (!method.$owner) {
Ext.Error.raise({
sourceClass: Ext.getClassName(this),
sourceMethod: "callOverridden",
msg: "Attempting to call a protected method from the public scope, which is not allowed"
});
}
if (!method.$previous) {
Ext.Error.raise({
sourceClass: Ext.getClassName(this),
sourceMethod: "callOverridden",
msg: "this.callOverridden was called in '" + method.$name +
"' but this method has never been overridden"
});
}
//</debug>
return method.$previous.apply(this, args || []);
},
destroy: function() {}
};
// These static properties will be copied to every newly created class with {@link Ext#define}
Ext.apply(Ext.Base, {
/**
* Create a new instance of this Class.
Ext.define('My.cool.Class', {
...
});
My.cool.Class.create({
someConfig: true
});
* @property create
* @static
* @type Function
* @markdown
*/
create: function() {
return Ext.create.apply(Ext, [this].concat(Array.prototype.slice.call(arguments, 0)));
},
/**
* @private
*/
own: flexSetter(function(name, value) {
if (typeof value === 'function') {
this.ownMethod(name, value);
}
else {
this.prototype[name] = value;
}
}),
/**
* @private
*/
ownMethod: function(name, fn) {
var originalFn;
if (fn.$owner !== undefined && fn !== Ext.emptyFn) {
originalFn = fn;
fn = function() {
return originalFn.apply(this, arguments);
};
}
//<debug>
var className;
className = Ext.getClassName(this);
if (className) {
fn.displayName = className + '#' + name;
}
//</debug>
fn.$owner = this;
fn.$name = name;
this.prototype[name] = fn;
},
/**
* Add / override static properties of this class.
Ext.define('My.cool.Class', {
...
});
My.cool.Class.addStatics({
someProperty: 'someValue', // My.cool.Class.someProperty = 'someValue'
method1: function() { ... }, // My.cool.Class.method1 = function() { ... };
method2: function() { ... } // My.cool.Class.method2 = function() { ... };
});
* @property addStatics
* @static
* @type Function
* @param {Object} members
* @markdown
*/
addStatics: function(members) {
for (var name in members) {
if (members.hasOwnProperty(name)) {
this[name] = members[name];
}
}
return this;
},
/**
* Add methods / properties to the prototype of this class.
Ext.define('My.awesome.Cat', {
constructor: function() {
...
}
});
My.awesome.Cat.implement({
meow: function() {
alert('Meowww...');
}
});
var kitty = new My.awesome.Cat;
kitty.meow();
* @property implement
* @static
* @type Function
* @param {Object} members
* @markdown
*/
implement: function(members) {
var prototype = this.prototype,
name, i, member, previous;
//<debug>
var className = Ext.getClassName(this);
//</debug>
for (name in members) {
if (members.hasOwnProperty(name)) {
member = members[name];
if (typeof member === 'function') {
member.$owner = this;
member.$name = name;
//<debug>
if (className) {
member.displayName = className + '#' + name;
}
//</debug>
}
prototype[name] = member;
}
}
if (Ext.enumerables) {
var enumerables = Ext.enumerables;
for (i = enumerables.length; i--;) {
name = enumerables[i];
if (members.hasOwnProperty(name)) {
member = members[name];
member.$owner = this;
member.$name = name;
prototype[name] = member;
}
}
}
},
/**
* Borrow another class' members to the prototype of this class.
Ext.define('Bank', {
money: '$$$',
printMoney: function() {
alert('$$$$$$$');
}
});
Ext.define('Thief', {
...
});
Thief.borrow(Bank, ['money', 'printMoney']);
var steve = new Thief();
alert(steve.money); // alerts '$$$'
steve.printMoney(); // alerts '$$$$$$$'
* @property borrow
* @static
* @type Function
* @param {Ext.Base} fromClass The class to borrow members from
* @param {Array/String} members The names of the members to borrow
* @return {Ext.Base} this
* @markdown
*/
borrow: function(fromClass, members) {
var fromPrototype = fromClass.prototype,
i, ln, member;
members = Ext.Array.from(members);
for (i = 0, ln = members.length; i < ln; i++) {
member = members[i];
this.own(member, fromPrototype[member]);
}
return this;
},
/**
* Override prototype members of this class. Overridden methods can be invoked via
* {@link Ext.Base#callOverridden}
Ext.define('My.Cat', {
constructor: function() {
alert("I'm a cat!");
return this;
}
});
My.Cat.override({
constructor: function() {
alert("I'm going to be a cat!");
var instance = this.callOverridden();
alert("Meeeeoooowwww");
return instance;
}
});
var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
// alerts "I'm a cat!"
// alerts "Meeeeoooowwww"
* @property override
* @static
* @type Function
* @param {Object} members
* @return {Ext.Base} this
* @markdown
*/
override: function(members) {
var prototype = this.prototype,
name, i, member, previous;
for (name in members) {
if (members.hasOwnProperty(name)) {
member = members[name];
if (typeof member === 'function') {
if (typeof prototype[name] === 'function') {
previous = prototype[name];
member.$previous = previous;
}
this.ownMethod(name, member);
}
else {
prototype[name] = member;
}
}
}
if (Ext.enumerables) {
var enumerables = Ext.enumerables;
for (i = enumerables.length; i--;) {
name = enumerables[i];
if (members.hasOwnProperty(name)) {
if (prototype[name] !== undefined) {
previous = prototype[name];
members[name].$previous = previous;
}
this.ownMethod(name, members[name]);
}
}
}
return this;
},
/**
* Used internally by the mixins pre-processor
* @private
*/
mixin: flexSetter(function(name, cls) {
var mixin = cls.prototype,
my = this.prototype,
i, fn;
for (i in mixin) {
if (mixin.hasOwnProperty(i)) {
if (my[i] === undefined) {
if (typeof mixin[i] === 'function') {
fn = mixin[i];
if (fn.$owner === undefined) {
this.ownMethod(i, fn);
}
else {
my[i] = fn;
}
}
else {
my[i] = mixin[i];
}
}
else if (i === 'config' && my.config && mixin.config) {
Ext.Object.merge(my.config, mixin.config);
}
}
}
if (my.mixins === undefined) {
my.mixins = {};
}
my.mixins[name] = mixin;
}),
/**
* Get the current class' name in string format.
Ext.define('My.cool.Class', {
constructor: function() {
alert(this.self.getName()); // alerts 'My.cool.Class'
}
});
My.cool.Class.getName(); // 'My.cool.Class'
* @return {String} className
* @markdown
*/
getName: function() {
return Ext.getClassName(this);
},
/**
* Create aliases for existing prototype methods. Example:
Ext.define('My.cool.Class', {
method1: function() { ... },
method2: function() { ... }
});
var test = new My.cool.Class();
My.cool.Class.createAlias({
method3: 'method1',
method4: 'method2'
});
test.method3(); // test.method1()
My.cool.Class.createAlias('method5', 'method3');
test.method5(); // test.method3() -> test.method1()
* @property createAlias
* @static
* @type Function
* @param {String/Object} alias The new method name, or an object to set multiple aliases. See
* {@link Ext.Function#flexSetter flexSetter}
* @param {String/Object} origin The original method name
* @markdown
*/
createAlias: flexSetter(function(alias, origin) {
this.prototype[alias] = this.prototype[origin];
})
});
})(Ext.Function.flexSetter);