/*

Copyright (c) 2009, Yahoo! Inc. All rights reserved.

Code licensed under the BSD License:

http://developer.yahoo.net/yui/license.txt

version: 3.0.0b1

build: 1163

*/

YUI.add('event-custom', function(Y) {

Y.Env.evt = {

    handles: {},

    plugins: {}

};

(function() {

/**

 * Allows for the insertion of methods that are executed before or after

 * a specified method

 * @class Do

 * @static

 */

var BEFORE = 0,

    AFTER = 1;

Y.Do = {

    /**

     * Cache of objects touched by the utility

     * @property objs

     * @static

     */

    objs: {},

    /**

     * Execute the supplied method before the specified function

     * @method before

     * @param fn {Function} the function to execute

     * @param obj the object hosting the method to displace

     * @param sFn {string} the name of the method to displace

     * @param c The execution context for fn

     * @return {string} handle for the subscription

     * @static

     */

    before: function(fn, obj, sFn, c) {

        var f = fn, a;

        if (c) {

            a = [fn, c].concat(Y.Array(arguments, 4, true));

            f = Y.rbind.apply(Y, a);

        }

        return this._inject(BEFORE, f, obj, sFn);

    },

    /**

     * Execute the supplied method after the specified function

     * @method after

     * @param fn {Function} the function to execute

     * @param obj the object hosting the method to displace

     * @param sFn {string} the name of the method to displace

     * @param c The execution context for fn

     * @return {string} handle for the subscription

     * @static

     */

    after: function(fn, obj, sFn, c) {

        var f = fn, a;

        if (c) {

            a = [fn, c].concat(Y.Array(arguments, 4, true));

            f = Y.rbind.apply(Y, a);

        }

        return this._inject(AFTER, f, obj, sFn);

    },

    /**

     * Execute the supplied method after the specified function

     * @method _inject

     * @param when {string} before or after

     * @param fn {Function} the function to execute

     * @param obj the object hosting the method to displace

     * @param sFn {string} the name of the method to displace

     * @param c The execution context for fn

     * @return {string} handle for the subscription

     * @private

     * @static

     */

    _inject: function(when, fn, obj, sFn) {

        // object id

        var id = Y.stamp(obj), o, sid;

        if (! this.objs[id]) {

            // create a map entry for the obj if it doesn't exist

            this.objs[id] = {};

        }

        o = this.objs[id];

        if (! o[sFn]) {

            // create a map entry for the method if it doesn't exist

            o[sFn] = new Y.Do.Method(obj, sFn);

            // re-route the method to our wrapper

            obj[sFn] = 

                function() {

                    return o[sFn].exec.apply(o[sFn], arguments);

                };

        }

        // subscriber id

        sid = id + Y.stamp(fn) + sFn;

        // register the callback

        o[sFn].register(sid, fn, when);

        return new Y.EventHandle(o[sFn], sid);

    },

    /**

     * Detach a before or after subscription

     * @method detach

     * @param handle {string} the subscription handle

     */

    detach: function(handle) {

        if (handle.detach) {

            handle.detach();

        }

    },

    _unload: function(e, me) {

    }

};

//////////////////////////////////////////////////////////////////////////

/**

 * Wrapper for a displaced method with aop enabled

 * @class Do.Method

 * @constructor

 * @param obj The object to operate on

 * @param sFn The name of the method to displace

 */

Y.Do.Method = function(obj, sFn) {

    this.obj = obj;

    this.methodName = sFn;

    this.method = obj[sFn];

    // this.before = [];

    // this.after = [];

    this.before = {};

    this.after = {};

};

/**

 * Register a aop subscriber

 * @method register

 * @param sid {string} the subscriber id

 * @param fn {Function} the function to execute

 * @param when {string} when to execute the function

 */

Y.Do.Method.prototype.register = function (sid, fn, when) {

    if (when) {

        // this.after.push(fn);

        this.after[sid] = fn;

    } else {

        // this.before.push(fn);

        this.before[sid] = fn;

    }

};

/**

 * Unregister a aop subscriber

 * @method delete

 * @param sid {string} the subscriber id

 * @param fn {Function} the function to execute

 * @param when {string} when to execute the function

 */

Y.Do.Method.prototype._delete = function (sid) {

    delete this.before[sid];

    delete this.after[sid];

};

/**

 * Execute the wrapped method

 * @method exec

 */

Y.Do.Method.prototype.exec = function () {

    var args = Y.Array(arguments, 0, true), 

        i, ret, newRet, 

        bf = this.before,

        af = this.after,

        prevented = false;

    // execute before

    for (i in bf) {

        if (bf.hasOwnProperty(i)) {

            ret = bf[i].apply(this.obj, args);

            if (ret) {

                switch (ret.constructor) {

                    case Y.Do.Halt:

                        return ret.retVal;

                    case Y.Do.AlterArgs:

                        args = ret.newArgs;

                        break;

                    case Y.Do.Prevent:

                        prevented = true;

                        break;

                    default:

                }

            }

        }

    }

    // execute method

    if (!prevented) {

        ret = this.method.apply(this.obj, args);

    }

    // execute after methods.

    for (i in af) {

        if (af.hasOwnProperty(i)) {

            newRet = af[i].apply(this.obj, args);

            // Stop processing if a Halt object is returned

            if (newRet && newRet.constructor == Y.Do.Halt) {

                return newRet.retVal;

            // Check for a new return value

            } else if (newRet && newRet.constructor == Y.Do.AlterReturn) {

                ret = newRet.newRetVal;

            }

        }

    }

    return ret;

};

//////////////////////////////////////////////////////////////////////////

/**

 * Return an AlterArgs object when you want to change the arguments that

 * were passed into the function.  An example would be a service that scrubs

 * out illegal characters prior to executing the core business logic.

 * @class Do.AlterArgs

 */

Y.Do.AlterArgs = function(msg, newArgs) {

    this.msg = msg;

    this.newArgs = newArgs;

};

/**

 * Return an AlterReturn object when you want to change the result returned

 * from the core method to the caller

 * @class Do.AlterReturn

 */

Y.Do.AlterReturn = function(msg, newRetVal) {

    this.msg = msg;

    this.newRetVal = newRetVal;

};

/**

 * Return a Halt object when you want to terminate the execution

 * of all subsequent subscribers as well as the wrapped method

 * if it has not exectued yet.

 * @class Do.Halt

 */

Y.Do.Halt = function(msg, retVal) {

    this.msg = msg;

    this.retVal = retVal;

};

/**

 * Return a Prevent object when you want to prevent the wrapped function

 * from executing, but want the remaining listeners to execute

 * @class Do.Prevent

 */

Y.Do.Prevent = function(msg) {

    this.msg = msg;

};

/**

 * Return an Error object when you want to terminate the execution

 * of all subsequent method calls.

 * @class Do.Error

 * @deprecated use Y.Do.Halt or Y.Do.Prevent

 */

Y.Do.Error = Y.Do.Halt;

//////////////////////////////////////////////////////////////////////////

// Y["Event"] && Y.Event.addListener(window, "unload", Y.Do._unload, Y.Do);

})();

(function() {

/**

 * Wraps and protects a custom event for use when emitFacade is set to true.

 * @class EventFacade

 * @param e {Event} the custom event

 * @param currentTarget {HTMLElement} the element the listener was attached to

 */

/*

var PROPS = {

    details: 1,

    type: 1,

    target: 1,

    currentTarget: 1,

    stopPropagation: 2,

    stopImmediatePropagation: 2,

    preventDefault: 2,

    halt: 2

};

Y.EventFacade = function(e, currentTarget) {

    if (e) {

        Y.Object.each(PROPS, function(v, k) {

            //this[k] = (v == 2) ? e[k].apply(e, arguments) : e[k];

            var val = e[k];

            if (val) {

                this[k] = (v == 2) ? function() {

                    if (val) {

                        val.apply(e, arguments);

                    }

                } : val;

            } else {

                console.log('missing ' + k);

            }

        });

    }

};

*/

Y.EventFacade = function(e, currentTarget) {

    e = e || {};

    /**

     * The arguments passed to fire 

     * @property details

     * @type Array

     */

    this.details = e.details;

    /**

     * The event type

     * @property type

     * @type string

     */

    this.type = e.type;

    //////////////////////////////////////////////////////

    /**

     * Node reference for the targeted eventtarget

     * @propery target

     * @type Node

     */

    this.target = e.target;

    /**

     * Node reference for the element that the listener was attached to.

     * @propery currentTarget

     * @type Node

     */

    this.currentTarget = currentTarget;

    /**

     * Node reference to the relatedTarget

     * @propery relatedTarget

     * @type Node

     */

    this.relatedTarget = e.relatedTarget;

    /**

     * Stops the propagation to the next bubble target

     * @method stopPropagation

     */

    this.stopPropagation = function() {

        e.stopPropagation();

    };

    /**

     * Stops the propagation to the next bubble target and

     * prevents any additional listeners from being exectued

     * on the current target.

     * @method stopImmediatePropagation

     */

    this.stopImmediatePropagation = function() {

        e.stopImmediatePropagation();

    };

    /**

     * Prevents the event's default behavior

     * @method preventDefault

     */

    this.preventDefault = function() {

        e.preventDefault();

    };

    /**

     * Stops the event propagation and prevents the default

     * event behavior.

     * @method halt

     * @param immediate {boolean} if true additional listeners

     * on the current target will not be executed

     */

    this.halt = function(immediate) {

        e.halt(immediate);

    };

};

})();

/**

 * Custom event engine, DOM event listener abstraction layer, synthetic DOM 

 * events.

 * @module event-custom

 */