--- /dev/null
+/**
+ * @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);
git.ithinksw.org / extjs.git / blobdiff