芝麻web文件管理V1.00

编辑当前文件:/home2/sdektunc/.trash/cepali/lib/yuilib/3.17.2/base-observable/base-observable.js

/*
YUI 3.17.2 (build 9c3c78e)
Copyright 2014 Yahoo! Inc. All rights reserved.
Licensed under the BSD License.
http://yuilibrary.com/license/
*/

YUI.add('base-observable', function (Y, NAME) {

/**
    The `base-observable` submodule adds observability to Base's lifecycle and
    attributes, and also make it an `EventTarget`.

@module base
    @submodule base-observable
    **/
    var L = Y.Lang,

DESTROY = "destroy",
        INIT = "init",

BUBBLETARGETS = "bubbleTargets",
        _BUBBLETARGETS = "_bubbleTargets",

AttributeObservable = Y.AttributeObservable,
        BaseCore            = Y.BaseCore;

/**
    Provides an augmentable implementation of lifecycle and attribute events for
    `BaseCore`.

@class BaseObservable
    @extensionfor BaseCore
    @uses AttributeObservable
    @uses EventTarget
    @since 3.8.0
    **/
    function BaseObservable() {}

BaseObservable._ATTR_CFG      = AttributeObservable._ATTR_CFG.concat();
    BaseObservable._NON_ATTRS_CFG = ["on", "after", "bubbleTargets"];

BaseObservable.prototype = {

/**
         * Initializes Attribute
         *
         * @method _initAttribute
         * @private
         */
        _initAttribute: function() {
            BaseCore.prototype._initAttribute.apply(this, arguments);
            AttributeObservable.call(this);

this._eventPrefix = this.constructor.EVENT_PREFIX || this.constructor.NAME;
            this._yuievt.config.prefix = this._eventPrefix;
        },

/**
         * Init lifecycle method, invoked during construction.
         * Fires the init event prior to setting up attributes and
         * invoking initializers for the class hierarchy.
         *
         * @method init
         * @chainable
         * @param {Object} config Object with configuration property name/value pairs
         * @return {Base} A reference to this object
         */
        init: function(config) {

/**
 * 
 * Lifecycle event for the init phase, fired prior to initialization.
 * Invoking the preventDefault() method on the event object provided
 * to subscribers will prevent initialization from occuring.
 * 
 * 
 * Subscribers to the "after" momemt of this event, will be notified
 * after initialization of the object is complete (and therefore
 * cannot prevent initialization).
 * 
 *
 * @event init
 * @preventable _defInitFn
 * @param {EventFacade} e Event object, with a cfg property which
 * refers to the configuration object passed to the constructor.
 */

// PERF: Using lower level _publish() for
            // critical path performance

var type = this._getFullType(INIT),
                e = this._publish(type);

e.emitFacade = true;
            e.fireOnce = true;
            e.defaultTargetOnly = true;
            e.defaultFn = this._defInitFn;

this._preInitEventCfg(config);

if (e._hasPotentialSubscribers()) {
                this.fire(type, {cfg: config});
            } else {

this._baseInit(config);

// HACK. Major hack actually. But really fast for no-listeners.
                // Since it's fireOnce, subscribers may come along later, so since we're
                // bypassing the event stack the first time, we need to tell the published
                // event that it's been "fired". Could extract it into a CE method?
                e.fired = true;
                e.firedWith = [{cfg:config}];
            }

return this;
        },

/**
         * Handles the special on, after and target properties which allow the user to
         * easily configure on and after listeners as well as bubble targets during
         * construction, prior to init.
         *
         * @private
         * @method _preInitEventCfg
         * @param {Object} config The user configuration object
         */
        _preInitEventCfg : function(config) {
            if (config) {
                if (config.on) {
                    this.on(config.on);
                }
                if (config.after) {
                    this.after(config.after);
                }
            }

var i, l, target,
                userTargets = (config && BUBBLETARGETS in config);

if (userTargets || _BUBBLETARGETS in this) {
                target = userTargets ? (config && config.bubbleTargets) : this._bubbleTargets;

if (L.isArray(target)) {
 for (i = 0, l = target.length; i < l; i++) {
 this.addTarget(target[i]);
 }
 } else if (target) {
 this.addTarget(target);
 }
 }
 },

/**
 * 
 * Destroy lifecycle method. Fires the destroy
 * event, prior to invoking destructors for the
 * class hierarchy.
 * 
 * 
 * Subscribers to the destroy
 * event can invoke preventDefault on the event object, to prevent destruction
 * from proceeding.
 * 
 * @method destroy
 * @return {Base} A reference to this object
 * @chainable
 */
 destroy: function() {

/**
 * 
 * Lifecycle event for the destroy phase,
 * fired prior to destruction. Invoking the preventDefault
 * method on the event object provided to subscribers will
 * prevent destruction from proceeding.
 * 
 * 
 * Subscribers to the "after" moment of this event, will be notified
 * after destruction is complete (and as a result cannot prevent
 * destruction).
 * 
 * @event destroy
 * @preventable _defDestroyFn
 * @param {EventFacade} e Event object
 */
 this.publish(DESTROY, {
 fireOnce:true,
 defaultTargetOnly:true,
 defaultFn: this._defDestroyFn
 });
 this.fire(DESTROY);

this.detachAll();
            return this;
        },

/**
         * Default init event handler
         *
         * @method _defInitFn
         * @param {EventFacade} e Event object, with a cfg property which
         * refers to the configuration object passed to the constructor.
         * @protected
         */
        _defInitFn : function(e) {
            this._baseInit(e.cfg);
        },

/**
         * Default destroy event handler
         *
         * @method _defDestroyFn
         * @param {EventFacade} e Event object
         * @protected
         */
        _defDestroyFn : function(e) {
            this._baseDestroy(e.cfg);
        }
    };

Y.mix(BaseObservable, AttributeObservable, false, null, 1);

Y.BaseObservable = BaseObservable;

}, '3.17.2', {"requires": ["attribute-observable", "base-core"]});