← Back to branch summary

~loggerhead-team/loggerhead/trunk-rich

« back to all changes in this revision

Viewing changes to loggerhead/static/javascript/yui/build/base/base.js

  • Committer: Martin Albisetti
  • Date: 2008-12-30 19:20:39 UTC
  • Revision ID: argentina@gmail.com-20081230192039-kc2spvli08fo09sx
Upgrade YUI3 to PR2

Show diffs side-by-side

added added

removed removed

Lines of Context:
loggerhead/static/javascript/yui/build/base/base.js
2
2
Copyright (c) 2008, Yahoo! Inc. All rights reserved.
3
3
Code licensed under the BSD License:
4
4
http://developer.yahoo.net/yui/license.txt
5
 
version: 3.0.0pr1
 
5
version: 3.0.0pr2
6
6
*/
7
7
YUI.add('base', function(Y) {
8
8
 
12
12
     *
13
13
     * @module base
14
14
     */
15
 
 
16
15
    var L = Y.Lang,
17
16
        O = Y.Object,
18
17
        SEP = ":",
85
84
         * @default false
86
85
         * @type boolean
87
86
         */
88
 
        intialized: {
 
87
        initialized: {
89
88
            readOnly:true,
90
89
            value:false
91
90
        },
105
104
        }
106
105
    };
107
106
 
 
107
    /**
 
108
     * The build configuration for the Base class.
 
109
     * Defines the static fields which need to be aggregated,
 
110
     * when this class is used as the main class passed to 
 
111
     * the <a href="#method_build">Base.build</a> method.
 
112
     *
 
113
     * @property _buildCfg
 
114
     * @type Object
 
115
     * @static
 
116
     * @final
 
117
     * @private
 
118
     */    
 
119
    Base._buildCfg = {
 
120
        aggregates : ["ATTRS"]
 
121
    };
 
122
 
108
123
    var _instances = {};
109
124
 
110
125
    /**
119
134
     * <dl>
120
135
     *    <dt>dynamic &#60;boolean&#62;</dt>
121
136
     *    <dd>
122
 
     *    <p>If true, a completely new class
 
137
     *    <p>If true (default), a completely new class
123
138
     *    is created which extends the main class, and acts as the 
124
139
     *    host on which the extension classes are augmented.</p>
125
140
     *    <p>If false, the extensions classes are augmented directly to
127
142
     *    </dd>
128
143
     *    <dt>aggregates &#60;String[]&#62;</dt>
129
144
     *    <dd>An array of static property names, which will get aggregated
130
 
     *    on to the built class in addition to the default properties build 
131
 
     *    will always aggregate - "ATTRS" and "PLUGINS", as defined by 
132
 
     *    Base.build.AGGREGATES</dd>
 
145
     *    on to the built class, in addition to the default properties build 
 
146
     *    will always aggregate as defined by the main class' _buildCfg
 
147
     *    property.
 
148
     *    </dd>
133
149
     * </dl>
134
150
     *
135
151
     * @method build
143
159
    Base.build = function(main, extensions, cfg) {
144
160
 
145
161
        var build = Base.build,
146
 
            builtClass,
147
 
            extClass,
148
 
            aggregates,
149
 
            dynamic,
150
 
            key = main.NAME;
151
 
 
152
 
        if (cfg) {
153
 
            aggregates = cfg.aggregates;
154
 
            dynamic = cfg.dynamic;
155
 
        }
156
 
 
157
 
        // Create dynamic class or just modify main class
158
 
        builtClass = (dynamic) ? build._template(main) : main;
159
 
 
160
 
        builtClass._yuibuild = {
161
 
            id: null,
162
 
            exts : [],
163
 
            dynamic : dynamic
164
 
        };
165
 
 
166
 
        aggregates = (aggregates) ? build.AGGREGATES.concat(aggregates) : build.AGGREGATES;
167
 
 
168
 
        var el = extensions.length,
169
 
            al = aggregates.length,
170
 
            i;
 
162
 
 
163
            builtClass = build._getClass(main, cfg),
 
164
            aggregates = build._getAggregates(main, cfg),
 
165
            dynamic = builtClass._yuibuild.dynamic,
 
166
 
 
167
            key = main.NAME,
 
168
 
 
169
            i, l;
171
170
 
172
171
        // Shallow isolate aggregates
173
 
        if (dynamic && aggregates) {
174
 
            for (i = 0; i < al; i++) {
175
 
                var val = aggregates[i];
176
 
                if (O.owns(main, val)) {
177
 
                    builtClass[val] = L.isArray(main[val]) ? [] : {};
 
172
        if (dynamic) {
 
173
            if (aggregates) {
 
174
                for (i = 0, l = aggregates.length; i < l; ++i) {
 
175
                    var val = aggregates[i];
 
176
                    if (O.owns(main, val)) {
 
177
                        builtClass[val] = L.isArray(main[val]) ? [] : {};
 
178
                    }
178
179
                }
 
180
                Y.aggregate(builtClass, main, true, aggregates);
179
181
            }
180
 
            Y.aggregate(builtClass, main, true, aggregates);
181
182
        }
182
183
 
183
184
        // Augment/Aggregate
184
 
        for (i = 0; i < el; i++) {
185
 
            extClass = extensions[i];
 
185
        for (i = 0, l = extensions.length; i < l; i++) {
 
186
            var extClass = extensions[i];
186
187
 
187
188
            if (aggregates) {
188
189
                Y.aggregate(builtClass, extClass, true, aggregates);
205
206
 
206
207
        return builtClass;
207
208
    };
208
 
 
 
209
    
209
210
    Y.mix(Base.build, {
210
211
 
211
 
        AGGREGATES : ["ATTRS", "PLUGINS"],
212
 
 
213
212
        _template: function(main) {
214
213
 
215
214
            function BuiltClass() {
 
215
 
216
216
                BuiltClass.superclass.constructor.apply(this, arguments);
217
217
 
218
218
                var f = BuiltClass._yuibuild.exts, 
221
221
                for (var i = 0; i < l; i++) {
222
222
                    f[i].apply(this, arguments);
223
223
                }
 
224
 
224
225
                return this;
225
226
            }
226
 
 
227
227
            Y.extend(BuiltClass, main);
228
 
 
229
228
            return BuiltClass;
230
229
        },
231
230
 
243
242
            }
244
243
 
245
244
            return false;
 
245
        },
 
246
 
 
247
        _getClass : function(main, cfg) {
 
248
 
 
249
            // Create dynamic class or just modify main class
 
250
            var dynamic = (cfg && false === cfg.dynamic) ? false : true,
 
251
                builtClass = (dynamic) ? Base.build._template(main) : main;
 
252
 
 
253
            builtClass._yuibuild = {
 
254
                id: null,
 
255
                exts : [],
 
256
                dynamic : dynamic
 
257
            };
 
258
 
 
259
            return builtClass;
 
260
        },
 
261
 
 
262
        _getAggregates : function(main, cfg) {
 
263
            var aggr = [],
 
264
                cfgAggr = (cfg && cfg.aggregates),
 
265
                c = main;
 
266
 
 
267
            while (c && c.prototype) {
 
268
                var classAggr = c._buildCfg && c._buildCfg.aggregates;
 
269
                if (classAggr) {
 
270
                    aggr = aggr.concat(classAggr);
 
271
                }
 
272
                c = c.superclass ? c.superclass.constructor : null;
 
273
            }
 
274
 
 
275
            if (cfgAggr) {
 
276
                aggr = aggr.concat(cfgAggr);
 
277
            }
 
278
 
 
279
            return aggr;
246
280
        }
247
281
    });
248
282
 
252
286
     * The custom class is created from the main class passed in as the first parameter 
253
287
     * along with the list of extension classes passed in
254
288
     * as the second parameter using <a href="#method_build">Base.build</a> 
255
 
     * with "dynamic" set to true. See the documentation for this method 
 
289
     * with "dynamic" set to true. See the documentation for Base.build method 
256
290
     * to see how the main class and extension classes are used.
257
291
     * </p>
258
 
     * 
 
292
     *
259
293
     * <p>Any arguments following the 2nd argument are passed as arguments to the 
260
294
     * constructor of the newly created class used to create the instance.</p>
261
295
     * 
271
305
     * @return {Object} An instance of the custom class
272
306
     */
273
307
    Base.create = function(main, extensions, args) {
274
 
        var c = Base.build(main, extensions, {dynamic:true}),
 
308
        var c = Base.build(main, extensions),
275
309
            cArgs = Y.Array(arguments, 2, true);
276
310
 
277
311
        function F(){}
305
339
 
306
340
            /**
307
341
             * <p>
308
 
             * Init event, fired prior to initialization. Invoking
309
 
             * the preventDefault method on the event object provided 
 
342
             * Lifecycle event for the init phase, fired prior to initialization. 
 
343
             * Invoking the preventDefault method on the event object provided 
310
344
             * to subscribers will prevent initialization from occuring.
311
345
             * </p>
312
346
             * <p>
324
358
                queuable:false,
325
359
                defaultFn:this._defInitFn
326
360
            });
327
 
            this.fire(INIT, config);
 
361
            this.fire(INIT, null, config);
328
362
 
329
363
            return this;
330
364
        },
349
383
 
350
384
            /**
351
385
             * <p>
352
 
             * Destroy event, fired prior to destruction. Invoking
353
 
             * the preventDefault method on the event object provided 
354
 
             * to subscribers will prevent destruction from proceeding.
 
386
             * Lifecycle event for the destroy phase, 
 
387
             * fired prior to destruction. Invoking the preventDefault 
 
388
             * method on the event object provided to subscribers will 
 
389
             * prevent destruction from proceeding.
355
390
             * </p>
356
391
             * <p>
357
392
             * Subscribers to the "after" moment of this event, will be notified
374
409
         * Default init event handler
375
410
         *
376
411
         * @method _defInitFn
 
412
         * @param {Event.Facade} e Event object
377
413
         * @param {Object} config Object literal of configuration property name/value pairs
378
414
         * @protected
379
415
         */
380
 
        _defInitFn : function(config) {
 
416
        _defInitFn : function(e, config) {
381
417
            _instances[Y.stamp(this)] = this;
382
418
            this._initHierarchy(config);
383
419
 
384
 
            this._conf.remove(INITIALIZED, VALUE);
385
 
            this.set(INITIALIZED, true);
 
420
            this._set(INITIALIZED, true);
386
421
        },
387
422
 
388
423
        /**
389
424
         * Default destroy event handler
390
425
         *
391
426
         * @method _defDestroyFn
 
427
         * @param {Event.Facade} e Event object
392
428
         * @protected
393
429
         */
394
 
        _defDestroyFn : function() {
 
430
        _defDestroyFn : function(e) {
395
431
            this._destroyHierarchy();
396
432
            delete _instances[this._yuid];
397
433
 
398
 
            this._conf.remove(DESTROYED, VALUE);
399
 
            this.set(DESTROYED, true);
 
434
            this._set(DESTROYED, true);
400
435
        },
401
436
 
402
437
        /**
659
694
 
660
695
    Y.mix(Base, Y.Attribute, false, null, 1);
661
696
 
 
697
    Base.prototype.constructor = Base;
662
698
    Y.Base = Base;
663
699
 
664
700
 
665
701
 
666
 
}, '3.0.0pr1' ,{requires:['attribute']});
 
702
}, '3.0.0pr2' ,{requires:['attribute']});