/** * Base Manager class * @private * @deprecated 5.0.0 Will be removed in 7.0. */Ext.define('Ext.AbstractManager', { /* Begin Definitions */ requires: ['Ext.util.HashMap'], /* End Definitions */ typeName: 'type', constructor: function(config) { Ext.apply(this, config || {}); /** * @property {Ext.util.HashMap} all * Contains all of the items currently managed */ this.all = new Ext.util.HashMap(); this.types = {}; }, /** * Returns an item by id. * For additional details see {@link Ext.util.HashMap#get}. * @param {String} id The id of the item * @return {Object} The item, undefined if not found. */ get : function(id) { return this.all.get(id); }, /** * Registers an item to be managed * @param {Object} item The item to register */ register: function(item) { //<debug> var key = this.all.getKey(item); if (key === undefined) { Ext.raise('Key is undefined. Please ensure the item has a key before registering the item.'); } if (this.all.containsKey(key)) { Ext.raise('Registering duplicate id "' + key + '" with ' + this.$className); } //</debug> this.all.add(item); }, /** * Unregisters an item by removing it from this manager * @param {Object} item The item to unregister */ unregister: function(item) { this.all.remove(item); }, /** * Registers a new item constructor, keyed by a type key. * @param {String} type The mnemonic string by which the class may be looked up. * @param {Function} cls The new instance class. */ registerType : function(type, cls) { this.types[type] = cls; cls[this.typeName] = type; }, /** * Checks if an item type is registered. * @param {String} type The mnemonic string by which the class may be looked up * @return {Boolean} Whether the type is registered. */ isRegistered : function(type){ return this.types[type] !== undefined; }, /** * Creates and returns an instance of whatever this manager manages, based on the supplied type and * config object. * @param {Object} config The config object * @param {String} defaultType If no type is discovered in the config object, we fall back to this type * @return {Object} The instance of whatever this manager is managing */ create: function(config, defaultType) { var type = config[this.typeName] || config.type || defaultType, Constructor = this.types[type]; //<debug> if (Constructor === undefined) { Ext.raise("The '" + type + "' type has not been registered with this manager"); } //</debug> return new Constructor(config); }, /** * Registers a function that will be called when an item with the specified id is added to the manager. * This will happen on instantiation. * @param {String} id The item id * @param {Function} fn The callback function. Called with a single parameter, the item. * @param {Object} scope The scope (this reference) in which the callback is executed. * Defaults to the item. */ onAvailable : function(id, fn, scope){ var all = this.all, item, callback; if (all.containsKey(id)) { item = all.get(id); fn.call(scope || item, item); } else { callback = function(map, key, item){ if (key == id) { fn.call(scope || item, item); all.un('add', callback); } }; all.on('add', callback); } }, /** * Executes the specified function once for each item in the collection. * @param {Function} fn The function to execute. * @param {String} fn.key The key of the item * @param {Number} fn.value The value of the item * @param {Number} fn.length The total number of items in the collection * @param {Boolean} fn.return False to cease iteration. * @param {Object} scope The scope to execute in. Defaults to `this`. */ each: function(fn, scope){ this.all.each(fn, scope || this); }, /** * Gets the number of items in the collection. * @return {Number} The number of items in the collection. */ getCount: function(){ return this.all.getCount(); }});