X-Git-Url: http://git.ithinksw.org/extjs.git/blobdiff_plain/3789b528d8dd8aad4558e38e22d775bcab1cbd36..6746dc89c47ed01b165cc1152533605f97eb8e8d:/docs/source/ClassManager.html diff --git a/docs/source/ClassManager.html b/docs/source/ClassManager.html index da4041e6..fc049b86 100644 --- a/docs/source/ClassManager.html +++ b/docs/source/ClassManager.html @@ -19,19 +19,18 @@ * @author Jacky Nguyen <jacky@sencha.com> * @docauthor Jacky Nguyen <jacky@sencha.com> * @class Ext.ClassManager - -Ext.ClassManager manages all classes and handles mapping from string class name to -actual class objects throughout the whole framework. It is not generally accessed directly, rather through -these convenient shorthands: - -- {@link Ext#define Ext.define} -- {@link Ext#create Ext.create} -- {@link Ext#widget Ext.widget} -- {@link Ext#getClass Ext.getClass} -- {@link Ext#getClassName Ext.getClassName} - + * + * Ext.ClassManager manages all classes and handles mapping from string class name to + * actual class objects throughout the whole framework. It is not generally accessed directly, rather through + * these convenient shorthands: + * + * - {@link Ext#define Ext.define} + * - {@link Ext#create Ext.create} + * - {@link Ext#widget Ext.widget} + * - {@link Ext#getClass Ext.getClass} + * - {@link Ext#getClassName Ext.getClassName} + * * @singleton - * @markdown */ (function(Class, alias) { @@ -40,8 +39,7 @@ these convenient shorthands: var Manager = Ext.ClassManager = { /** - * @property classes - * @type Object + * @property {Object} classes * All classes which were defined through the ClassManager. Keys are the * name of the classes and the values are references to the classes. * @private @@ -189,14 +187,13 @@ these convenient shorthands: /** * Creates a namespace and assign the `value` to the created object - - Ext.ClassManager.setNamespace('MyCompany.pkg.Example', someObject); - - alert(MyCompany.pkg.Example === someObject); // alerts true - + * + * Ext.ClassManager.setNamespace('MyCompany.pkg.Example', someObject); + * + * alert(MyCompany.pkg.Example === someObject); // alerts true + * * @param {String} name * @param {Mixed} value - * @markdown */ setNamespace: function(name, value) { var root = Ext.global, @@ -383,14 +380,14 @@ these convenient shorthands: }, /** - * Get the name of the class by its reference or its instance; - * usually invoked by the shorthand {@link Ext#getClassName Ext.getClassName} - - Ext.ClassManager.getName(Ext.Action); // returns "Ext.Action" - + * Get the name of the class by its reference or its instance. + * + * Ext.ClassManager.getName(Ext.Action); // returns "Ext.Action" + * + * {@link Ext#getClassName Ext.getClassName} is alias for {@link Ext.ClassManager#getName Ext.ClassManager.getName}. + * * @param {Class/Object} object * @return {String} className - * @markdown */ getName: function(object) { return object && object.$className || ''; @@ -398,57 +395,63 @@ these convenient shorthands: /** * Get the class of the provided object; returns null if it's not an instance - * of any class created with Ext.define. This is usually invoked by the shorthand {@link Ext#getClass Ext.getClass} + * of any class created with Ext.define. + * + * var component = new Ext.Component(); + * + * Ext.ClassManager.getClass(component); // returns Ext.Component + * + * {@link Ext#getClass Ext.getClass} is alias for {@link Ext.ClassManager#getClass Ext.ClassManager.getClass}. * - var component = new Ext.Component(); - - Ext.ClassManager.getClass(component); // returns Ext.Component - * * @param {Object} object * @return {Class} class - * @markdown */ getClass: function(object) { return object && object.self || null; }, /** - * Defines a class. This is usually invoked via the alias {@link Ext#define Ext.define} - - Ext.ClassManager.create('My.awesome.Class', { - someProperty: 'something', - someMethod: function() { ... } - ... - - }, function() { - alert('Created!'); - alert(this === My.awesome.Class); // alerts true - - var myInstance = new this(); - }); - + * Defines a class. + * + * Ext.ClassManager.create('My.awesome.Class', { + * someProperty: 'something', + * someMethod: function() { ... } + * ... + * + * }, function() { + * alert('Created!'); + * alert(this === My.awesome.Class); // alerts true + * + * var myInstance = new this(); + * }); + * + * {@link Ext#define Ext.define} is alias for {@link Ext.ClassManager#create Ext.ClassManager.create}. + * * @param {String} className The class name to create in string dot-namespaced format, for example: * 'My.very.awesome.Class', 'FeedViewer.plugin.CoolPager' * It is highly recommended to follow this simple convention: - -- The root and the class name are 'CamelCased' -- Everything else is lower-cased - + * + * - The root and the class name are 'CamelCased' + * - Everything else is lower-cased + * * @param {Object} data The key - value pairs of properties to apply to this class. Property names can be of any valid - * strings, except those in the reserved listed below: - -- `mixins` -- `statics` -- `config` -- `alias` -- `self` -- `singleton` -- `alternateClassName` + * strings, except those in the reserved list below: + * + * - {@link Ext.Base#self self} + * - {@link Ext.Class#alias alias} + * - {@link Ext.Class#alternateClassName alternateClassName} + * - {@link Ext.Class#config config} + * - {@link Ext.Class#extend extend} + * - {@link Ext.Class#inheritableStatics inheritableStatics} + * - {@link Ext.Class#mixins mixins} + * - {@link Ext.Class#requires requires} + * - {@link Ext.Class#singleton singleton} + * - {@link Ext.Class#statics statics} + * - {@link Ext.Class#uses uses} * * @param {Function} createdFn Optional callback to execute after the class is created, the execution scope of which * (`this`) will be the newly created class itself. * @return {Ext.Base} - * @markdown */ create: function(className, data, createdFn) { var manager = this; @@ -519,17 +522,19 @@ these convenient shorthands: }, /** - * Instantiate a class by its alias; usually invoked by the convenient shorthand {@link Ext#createByAlias Ext.createByAlias} + * Instantiate a class by its alias. + * * If {@link Ext.Loader} is {@link Ext.Loader#setConfig enabled} and the class has not been defined yet, it will * attempt to load the class via synchronous loading. - - var window = Ext.ClassManager.instantiateByAlias('widget.window', { width: 600, height: 800, ... }); - + * + * var window = Ext.ClassManager.instantiateByAlias('widget.window', { width: 600, height: 800, ... }); + * + * {@link Ext#createByAlias Ext.createByAlias} is alias for {@link Ext.ClassManager#instantiateByAlias Ext.ClassManager.instantiateByAlias}. + * * @param {String} alias * @param {Mixed} args,... Additional arguments after the alias will be passed to the * class constructor. * @return {Object} instance - * @markdown */ instantiateByAlias: function() { var alias = arguments[0], @@ -565,27 +570,27 @@ these convenient shorthands: }, /** - * Instantiate a class by either full name, alias or alternate name; usually invoked by the convenient - * shorthand {@link Ext#create Ext.create} + * Instantiate a class by either full name, alias or alternate name. * * If {@link Ext.Loader} is {@link Ext.Loader#setConfig enabled} and the class has not been defined yet, it will * attempt to load the class via synchronous loading. * * For example, all these three lines return the same result: - - // alias - var window = Ext.ClassManager.instantiate('widget.window', { width: 600, height: 800, ... }); - - // alternate name - var window = Ext.ClassManager.instantiate('Ext.Window', { width: 600, height: 800, ... }); - - // full class name - var window = Ext.ClassManager.instantiate('Ext.window.Window', { width: 600, height: 800, ... }); - + * + * // alias + * var window = Ext.ClassManager.instantiate('widget.window', { width: 600, height: 800, ... }); + * + * // alternate name + * var window = Ext.ClassManager.instantiate('Ext.Window', { width: 600, height: 800, ... }); + * + * // full class name + * var window = Ext.ClassManager.instantiate('Ext.window.Window', { width: 600, height: 800, ... }); + * + * {@link Ext#create Ext.create} is alias for {@link Ext.ClassManager#instantiate Ext.ClassManager.instantiate}. + * * @param {String} name * @param {Mixed} args,... Additional arguments after the name will be passed to the class' constructor. * @return {Object} instance - * @markdown */ instantiate: function() { var name = arguments[0], @@ -777,7 +782,7 @@ these convenient shorthands: index = Ext.Array.indexOf(defaultPostprocessors, relativeName); if (index !== -1) { - defaultPostprocessors.splice(Math.max(0, index + offset), 0, name); + Ext.Array.splice(defaultPostprocessors, Math.max(0, index + offset), 0, name); } return this; @@ -786,16 +791,16 @@ these convenient shorthands: /** * Converts a string expression to an array of matching class names. An expression can either refers to class aliases * or class names. Expressions support wildcards: - - // returns ['Ext.window.Window'] - var window = Ext.ClassManager.getNamesByExpression('widget.window'); - - // returns ['widget.panel', 'widget.window', ...] - var allWidgets = Ext.ClassManager.getNamesByExpression('widget.*'); - - // returns ['Ext.data.Store', 'Ext.data.ArrayProxy', ...] - var allData = Ext.ClassManager.getNamesByExpression('Ext.data.*'); - + * + * // returns ['Ext.window.Window'] + * var window = Ext.ClassManager.getNamesByExpression('widget.window'); + * + * // returns ['widget.panel', 'widget.window', ...] + * var allWidgets = Ext.ClassManager.getNamesByExpression('widget.*'); + * + * // returns ['Ext.data.Store', 'Ext.data.ArrayProxy', ...] + * var allData = Ext.ClassManager.getNamesByExpression('Ext.data.*'); + * * @param {String} expression * @return {Array} classNames * @markdown @@ -859,6 +864,27 @@ these convenient shorthands: } }; + /** + * @cfg {[String]} alias + * @member Ext.Class + * List of short aliases for class names. Most useful for defining xtypes for widgets: + * + * Ext.define('MyApp.CoolPanel', { + * extend: 'Ext.panel.Panel', + * alias: ['widget.coolpanel'], + * title: 'Yeah!' + * }); + * + * // Using Ext.create + * Ext.widget('widget.coolpanel'); + * // Using the shorthand for widgets and in xtypes + * Ext.widget('panel', { + * items: [ + * {xtype: 'coolpanel', html: 'Foo'}, + * {xtype: 'coolpanel', html: 'Bar'} + * ] + * }); + */ Manager.registerPostprocessor('alias', function(name, cls, data) { var aliases = data.alias, widgetPrefix = 'widget.', @@ -896,11 +922,43 @@ these convenient shorthands: } }); + /** + * @cfg {Boolean} singleton + * @member Ext.Class + * When set to true, the class will be instanciated as singleton. For example: + * + * Ext.define('Logger', { + * singleton: true, + * log: function(msg) { + * console.log(msg); + * } + * }); + * + * Logger.log('Hello'); + */ Manager.registerPostprocessor('singleton', function(name, cls, data, fn) { fn.call(this, name, new cls(), data); return false; }); + /** + * @cfg {String/[String]} alternateClassName + * @member Ext.Class + * Defines alternate names for this class. For example: + * + * Ext.define('Developer', { + * alternateClassName: ['Coder', 'Hacker'], + * code: function(msg) { + * alert('Typing... ' + msg); + * } + * }); + * + * var joe = Ext.create('Developer'); + * joe.code('stackoverflow'); + * + * var rms = Ext.create('Hacker'); + * rms.code('hack hack'); + */ Manager.registerPostprocessor('alternateClassName', function(name, cls, data) { var alternates = data.alternateClassName, i, ln, alternate; @@ -930,9 +988,9 @@ these convenient shorthands: Ext.apply(Ext, { /** - * Convenient shorthand, see {@link Ext.ClassManager#instantiate} + * @method * @member Ext - * @method create + * @alias Ext.ClassManager#instantiate */ create: alias(Manager, 'instantiate'), @@ -984,13 +1042,14 @@ these convenient shorthands: /** * Convenient shorthand to create a widget by its xtype, also see {@link Ext.ClassManager#instantiateByAlias} - - var button = Ext.widget('button'); // Equivalent to Ext.create('widget.button') - var panel = Ext.widget('panel'); // Equivalent to Ext.create('widget.panel') - + * + * var button = Ext.widget('button'); // Equivalent to Ext.create('widget.button') + * var panel = Ext.widget('panel'); // Equivalent to Ext.create('widget.panel') + * + * @method * @member Ext - * @method widget - * @markdown + * @param {String} name xtype of the widget to create. + * @return {Object} widget instance */ widget: function(name) { var args = slice.call(arguments); @@ -1000,23 +1059,23 @@ these convenient shorthands: }, /** - * Convenient shorthand, see {@link Ext.ClassManager#instantiateByAlias} + * @method * @member Ext - * @method createByAlias + * @alias Ext.ClassManager#instantiateByAlias */ createByAlias: alias(Manager, 'instantiateByAlias'), /** - * Convenient shorthand for {@link Ext.ClassManager#create}, see detailed {@link Ext.Class explanation} + * @method * @member Ext - * @method define + * @alias Ext.ClassManager#create */ define: alias(Manager, 'create'), /** - * Convenient shorthand, see {@link Ext.ClassManager#getName} + * @method * @member Ext - * @method getClassName + * @alias Ext.ClassManager#getName */ getClassName: alias(Manager, 'getName'), @@ -1040,44 +1099,50 @@ these convenient shorthands: return 'Anonymous'; }, - /** - * Convenient shorthand, see {@link Ext.ClassManager#getClass} + /** + * @method * @member Ext - * @method getClassName + * @alias Ext.ClassManager#getClass */ getClass: alias(Manager, 'getClass'), /** * 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: - - Ext.namespace('Company', 'Company.data'); - - // equivalent and preferable to the above syntax - Ext.namespace('Company.data'); - - Company.Widget = function() { ... }; - - Company.data.CustomStore = function(config) { ... }; - + * + * Ext.namespace('Company', 'Company.data'); + * + * // equivalent and preferable to the above syntax + * Ext.namespace('Company.data'); + * + * Company.Widget = function() { ... }; + * + * Company.data.CustomStore = function(config) { ... }; + * + * @method + * @member Ext * @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) - * @function - * @member Ext - * @method namespace - * @markdown */ namespace: alias(Manager, 'createNamespaces') }); + /** + * Old name for {@link Ext#widget}. + * @deprecated 4.0.0 Use {@link Ext#widget} instead. + * @method + * @member Ext + * @alias Ext#widget + */ Ext.createWidget = Ext.widget; /** * Convenient alias for {@link Ext#namespace Ext.namespace} + * @method * @member Ext - * @method ns + * @alias Ext#namespace */ Ext.ns = Ext.namespace;