Clear Up
SharpKit Reference

ClassConfig Class

Namespace: Ext

Base Types

System.Object

Constructors

Name Description
ClassConfig(Object[])

Fields

Name Description
alias 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.createExt.create('widget.coolpanel');
            // Using the shorthand for defining widgets by xtype
            Ext.widget('panel', {
            items: [
            {xtype: 'coolpanel', html: 'Foo'},
            {xtype: 'coolpanel', html: 'Bar'}
            ]
            });
            
Besides "widget" for xtype there are alias namespaces like "feature" for ftype and "plugin" for ptype.
alternateClassName 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');
            
config List of configuration options with their default values, for which automatically accessor methods are generated. For example:
  Ext.define('SmartPhone', {
            config: {
            hasTouchScreen: false,
            operatingSystem: 'Other',
            price: 500
            },
            constructor: function(cfg) {
            this.initConfig(cfg);
            }
            });
            var iPhone = new SmartPhone({
            hasTouchScreen: true,
            operatingSystem: 'iOS'
            });
            iPhone.getPrice(); // 500;
            iPhone.getOperatingSystem(); // 'iOS'
            iPhone.getHasTouchScreen(); // true;
            
extend The parent class that this class extends. For example:
  Ext.define('Person', {
            say: function(text) { alert(text); }
            });
            Ext.define('Developer', {
            extend: 'Person',
            say: function(text) { this.callParent(["print "+text]); }
            });
            
inheritableStatics List of inheritable static methods for this class. Otherwise just like statics but subclasses inherit these methods.
mixins List of classes to mix into this class. For example:
  Ext.define('CanSing', {
            sing: function() {
            alert("I'm on the highway to hell...")
            }
            });
            Ext.define('Musician', {
            mixins: ['CanSing']
            })
            
In this case the Musician class will get a sing method from CanSing mixin. But what if the Musician already has a sing method? Or you want to mix in two classes, both of which define sing? In such a cases it's good to define mixins as an object, where you assign a name to each mixin:
  Ext.define('Musician', {
            mixins: {
            canSing: 'CanSing'
            },
            sing: function() {
            // delegate singing operation to mixin
            this.mixins.canSing.sing.call(this);
            }
            })
            
In this case the sing method of Musician will overwrite the mixed in sing method. But you can access the original mixed in method through special mixins property.
requires List of classes that have to be loaded before instantiating this class. For example:
  Ext.define('Mother', {
            requires: ['Child'],
            giveBirth: function() {
            // we can be sure that child class is available.
            return new Child();
            }
            });
            
singleton When set to true, the class will be instantiated as singleton. For example:
  Ext.define('Logger', {
            singleton: true,
            log: function(msg) {
            console.log(msg);
            }
            });
            Logger.log('Hello');
            
statics List of static methods for this class. For example:
  Ext.define('Computer', {
            statics: {
            factory: function(brand) {
            // 'this' in static methods refer to the class itself
            return new this(brand);
            }
            },
            constructor: function() { ... }
            });
            var dellComputer = Computer.factory('Dell');
            
uses List of optional classes to load together with this class. These aren't neccessarily loaded before this class is created, but are guaranteed to be available before Ext.onReady listeners are invoked. For example:
  Ext.define('Mother', {
            uses: ['Child'],
            giveBirth: function() {
            // This code might, or might not work:
            // return new Child();
            // Instead use Ext.create() to load the class at the spot if not loaded already:
            return Ext.create('Child');
            }
            });
            
© Copyright 2005-2011 SharpKit. All rights reserved.