Clear Up
SharpKit Reference

ModelManager Class

The ModelManager keeps track of all Ext.data.Model types defined in your application.

Creating Model Instances

Model instances can be created by using the Ext.create method. Ext.create replaces the deprecated Ext.ModelManager.create method. It is also possible to create a model instance this by using the Model type directly. The following 3 snippets are equivalent:

  
    Ext.define('User', {
            extend: 'Ext.data.Model',
            fields: ['first', 'last']
            });
            // method 1, create using Ext.create (recommended)
            Ext.create('User', {
            first: 'Ed',
            last: 'Spencer'
            });
            // method 2, create through the manager (deprecated)
            Ext.ModelManager.create({
            first: 'Ed',
            last: 'Spencer'
            }, 'User');
            // method 3, create on the type directly
            new User({
            first: 'Ed',
            last: 'Spencer'
            });
            

Accessing Model Types

A reference to a Model type can be obtained by using the getModel function. Since models types are normal classes, you can access the type directly. The following snippets are equivalent:

  
    Ext.define('User', {
            extend: 'Ext.data.Model',
            fields: ['first', 'last']
            });
            // method 1, access model type through the manager
            var UserType = Ext.ModelManager.getModel('User');
            // method 2, reference the type directly
            var UserType = User;
            

Namespace: Ext

Properties

Name Description
all Contains all of the items currently managed
associationStack Private stack of associations that must be created once their associated model has been defined Defaults to: []

Methods

Name Description
callOverridden(object) Call the original method that was previously overridden with override
  Ext.define('My.Cat', {
            constructor: function() {
            alert("I'm a cat!");
            }
            });
            My.Cat.override({
            constructor: function() {
            alert("I'm going to be a cat!");
            this.callOverridden();
            alert("Meeeeoooowwww");
            }
            });
            var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
            // alerts "I'm a cat!"
            // alerts "Meeeeoooowwww"
            

This method has been deprecated

as of 4.1. Use callParent instead.

callParent(object) Call the "parent" method of the current method. That is the method previously overridden by derivation or by an override (see Ext.define).
  Ext.define('My.Base', {
            constructor: function (x) {
            this.x = x;
            },
            statics: {
            method: function (x) {
            return x;
            }
            }
            });
            Ext.define('My.Derived', {
            extend: 'My.Base',
            constructor: function () {
            this.callParent([21]);
            }
            });
            var obj = new My.Derived();
            alert(obj.x);  // alerts 21
            
This can be used with an override as follows:
  Ext.define('My.DerivedOverride', {
            override: 'My.Derived',
            constructor: function (x) {
            this.callParent([x*2]); // calls original My.Derived constructor
            }
            });
            var obj = new My.Derived();
            alert(obj.x);  // now alerts 42
            
This also works with static methods.
  Ext.define('My.Derived2', {
            extend: 'My.Base',
            statics: {
            method: function (x) {
            return this.callParent([x*2]); // calls My.Base.method
            }
            }
            });
            alert(My.Base.method(10);     // alerts 10
            alert(My.Derived2.method(10); // alerts 20
            
Lastly, it also works with overridden static methods.
  Ext.define('My.Derived2Override', {
            override: 'My.Derived2',
            statics: {
            method: function (x) {
            return this.callParent([x*2]); // calls My.Derived2.method
            }
            }
            });
            alert(My.Derived2.method(10); // now alerts 40
            
create(object, JsString, object) Creates a new instance of a Model using the given data. Deprecated, instead use Ext.create:
  Ext.create('User', {
            first: 'Ed',
            last: 'Spencer'
            });
            

This method has been deprecated since 4.1

Use Ext.create instead.

each(Delegate, object) Executes the specified function once for each item in the collection.
get(JsString) Returns an item by id. For additional details see Ext.util.HashMap.get.
getCount() Gets the number of items in the collection.
getInitialConfig(object) Returns the initial configuration passed to constructor when instantiating this class.
getModel(object) Returns the Ext.data.Model for a given model name
initConfig(object) 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);
            }
            });
            var awesome = new My.awesome.Class({
            name: 'Super Awesome'
            });
            alert(awesome.getName()); // 'Super Awesome'
            
isRegistered(JsString) Checks if an item type is registered.
onAvailable(JsString, Delegate, object) Registers a function that will be called when an item with the specified id is added to the manager. This will happen on instantiation.
register(object) Registers an item to be managed
statics() Get the reference to the class from which this object was instantiated. Note that unlike 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++;
            },
            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
            
unregister(object) Unregisters an item by removing it from this manager
© Copyright 2005-2011 SharpKit. All rights reserved.