docs/source/AbstractManager.html

   1 <!DOCTYPE html><html><head><title>Sencha Documentation Project</title><link rel="stylesheet" href="../reset.css" type="text/css"><link rel="stylesheet" href="../prettify.css" type="text/css"><link rel="stylesheet" href="../prettify_sa.css" type="text/css"><script type="text/javascript" src="../prettify.js"></script></head><body onload="prettyPrint()"><pre class="prettyprint"><pre><span id='Ext-AbstractManager'>/**
   2 </span> * @class Ext.AbstractManager
   3  * @extends Object
   4  * @ignore
   5  * Base Manager class
   6  */
   7
   8 Ext.define('Ext.AbstractManager', {
   9
  10     /* Begin Definitions */
  11
  12     requires: ['Ext.util.HashMap'],
  13
  14     /* End Definitions */
  15
  16     typeName: 'type',
  17
  18     constructor: function(config) {
  19         Ext.apply(this, config || {});
  20
  21 <span id='Ext-AbstractManager-property-all'>        /**
  22 </span>         * Contains all of the items currently managed
  23          * @property all
  24          * @type Ext.util.MixedCollection
  25          */
  26         this.all = Ext.create('Ext.util.HashMap');
  27
  28         this.types = {};
  29     },
  30
  31 <span id='Ext-AbstractManager-method-get'>    /**
  32 </span>     * Returns an item by id.
  33      * For additional details see {@link Ext.util.HashMap#get}.
  34      * @param {String} id The id of the item
  35      * @return {Mixed} The item, &lt;code&gt;undefined&lt;/code&gt; if not found.
  36      */
  37     get : function(id) {
  38         return this.all.get(id);
  39     },
  40
  41 <span id='Ext-AbstractManager-method-register'>    /**
  42 </span>     * Registers an item to be managed
  43      * @param {Mixed} item The item to register
  44      */
  45     register: function(item) {
  46         this.all.add(item);
  47     },
  48
  49 <span id='Ext-AbstractManager-method-unregister'>    /**
  50 </span>     * Unregisters an item by removing it from this manager
  51      * @param {Mixed} item The item to unregister
  52      */
  53     unregister: function(item) {
  54         this.all.remove(item);
  55     },
  56
  57 <span id='Ext-AbstractManager-method-registerType'>    /**
  58 </span>     * &lt;p&gt;Registers a new item constructor, keyed by a type key.
  59      * @param {String} type The mnemonic string by which the class may be looked up.
  60      * @param {Constructor} cls The new instance class.
  61      */
  62     registerType : function(type, cls) {
  63         this.types[type] = cls;
  64         cls[this.typeName] = type;
  65     },
  66
  67 <span id='Ext-AbstractManager-method-isRegistered'>    /**
  68 </span>     * Checks if an item type is registered.
  69      * @param {String} type The mnemonic string by which the class may be looked up
  70      * @return {Boolean} Whether the type is registered.
  71      */
  72     isRegistered : function(type){
  73         return this.types[type] !== undefined;
  74     },
  75
  76 <span id='Ext-AbstractManager-method-create'>    /**
  77 </span>     * Creates and returns an instance of whatever this manager manages, based on the supplied type and config object
  78      * @param {Object} config The config object
  79      * @param {String} defaultType If no type is discovered in the config object, we fall back to this type
  80      * @return {Mixed} The instance of whatever this manager is managing
  81      */
  82     create: function(config, defaultType) {
  83         var type        = config[this.typeName] || config.type || defaultType,
  84             Constructor = this.types[type];
  85
  86         //&lt;debug&gt;
  87         if (Constructor == undefined) {
  88             Ext.Error.raise(&quot;The '&quot; + type + &quot;' type has not been registered with this manager&quot;);
  89         }
  90         //&lt;/debug&gt;
  91
  92         return new Constructor(config);
  93     },
  94
  95 <span id='Ext-AbstractManager-method-onAvailable'>    /**
  96 </span>     * Registers a function that will be called when an item with the specified id is added to the manager. This will happen on instantiation.
  97      * @param {String} id The item id
  98      * @param {Function} fn The callback function. Called with a single parameter, the item.
  99      * @param {Object} scope The scope (&lt;code&gt;this&lt;/code&gt; reference) in which the callback is executed. Defaults to the item.
 100      */
 101     onAvailable : function(id, fn, scope){
 102         var all = this.all,
 103             item;
 104
 105         if (all.containsKey(id)) {
 106             item = all.get(id);
 107             fn.call(scope || item, item);
 108         } else {
 109             all.on('add', function(map, key, item){
 110                 if (key == id) {
 111                     fn.call(scope || item, item);
 112                     all.un('add', fn, scope);
 113                 }
 114             });
 115         }
 116     },
 117
 118 <span id='Ext-AbstractManager-method-each'>    /**
 119 </span>     * Executes the specified function once for each item in the collection.
 120      * Returning false from the function will cease iteration.
 121      *
 122      * The paramaters passed to the function are:
 123      * &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
 124      * &lt;li&gt;&lt;b&gt;key&lt;/b&gt; : String&lt;p class=&quot;sub-desc&quot;&gt;The key of the item&lt;/p&gt;&lt;/li&gt;
 125      * &lt;li&gt;&lt;b&gt;value&lt;/b&gt; : Number&lt;p class=&quot;sub-desc&quot;&gt;The value of the item&lt;/p&gt;&lt;/li&gt;
 126      * &lt;li&gt;&lt;b&gt;length&lt;/b&gt; : Number&lt;p class=&quot;sub-desc&quot;&gt;The total number of items in the collection&lt;/p&gt;&lt;/li&gt;
 127      * &lt;/ul&gt;&lt;/div&gt;
 128      * @param {Object} fn The function to execute.
 129      * @param {Object} scope The scope to execute in. Defaults to &lt;tt&gt;this&lt;/tt&gt;.
 130      */
 131     each: function(fn, scope){
 132         this.all.each(fn, scope || this);
 133     },
 134
 135 <span id='Ext-AbstractManager-method-getCount'>    /**
 136 </span>     * Gets the number of items in the collection.
 137      * @return {Number} The number of items in the collection.
 138      */
 139     getCount: function(){
 140         return this.all.getCount();
 141     }
 142 });
 143 </pre></pre></body></html>