Upgrade to ExtJS 4.0.7 - Released 10/19/2011
[extjs.git] / 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>