docs/source/AbstractManager.html

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