/*

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

*/

/**

 * DOM event listener abstraction layer

 * @module event

 */

(function() {

// Unlike most of the library, this code has to be executed as soon as it is

// introduced into the page -- and it should only be executed one time

// regardless of the number of instances that use it.

var GLOBAL_ENV = YUI.Env, 

    C = YUI.config, 

    D = C.doc, 

    POLL_INTERVAL = C.pollInterval || 40,

    _ready = function(e) {

        GLOBAL_ENV._ready();

    };

    if (!GLOBAL_ENV._ready) {

        GLOBAL_ENV._ready = function() {

            if (!GLOBAL_ENV.DOMReady) {

                GLOBAL_ENV.DOMReady=true;

                // Remove the DOMContentLoaded (FF/Opera/Safari)

                if (D.removeEventListener) {

                    D.removeEventListener("DOMContentLoaded", _ready, false);

                }

            }

        };

        // create custom event

/*! DOMReady: based on work by: Dean Edwards/John Resig/Matthias Miller/Diego Perini */

        // Internet Explorer: use the readyState of a defered script.

        // This isolates what appears to be a safe moment to manipulate

        // the DOM prior to when the document's readyState suggests

        // it is safe to do so.

        if (navigator.userAgent.match(/MSIE/)) {

            GLOBAL_ENV._dri = setInterval(function() {

                try {

                    // throws an error if doc is not ready

                    document.documentElement.doScroll('left');

                    clearInterval(GLOBAL_ENV._dri);

                    GLOBAL_ENV._dri = null;

                    _ready();

                } catch (ex) { 

                }

            }, POLL_INTERVAL); 

        // FireFox, Opera, Safari 3+: These browsers provide a event for this

        // moment.

        } else {

            D.addEventListener("DOMContentLoaded", _ready, false);

        }

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

    }

})();

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

(function() {

/**

 * DOM event listener abstraction layer

 * @module event

 */

var GLOBAL_ENV = YUI.Env,

    adapt = Y.Env.evt.plugins,

    yready = function() {

        Y.fire('domready');

    };

Y.mix(adapt, {

    /**

     * Executes the supplied callback when the DOM is first usable.  This

     * will execute immediately if called after the DOMReady event has

     * fired.   @todo the DOMContentReady event does not fire when the

     * script is dynamically injected into the page.  This means the

     * DOMReady custom event will never fire in FireFox or Opera when the

     * library is injected.  It _will_ fire in Safari, and the IE 

     * implementation would allow for us to fire it if the defered script

     * is not available.  We want this to behave the same in all browsers.

     * Is there a way to identify when the script has been injected 

     * instead of included inline?  Is there a way to know whether the 

     * window onload event has fired without having had a listener attached 

     * to it when it did so?

     *

     * <p>The callback is a Event.Custom, so the signature is:</p>

     * <p>type &lt;string&gt;, args &lt;array&gt;, customobject &lt;object&gt;</p>

     * <p>For DOMReady events, there are no fire argments, so the

     * signature is:</p>

     * <p>"DOMReady", [], obj</p>

     *

     *

     * @event domready

     * @for YUI

     *

     * @param {function} fn what to execute when the element is found.

     * @optional context execution context

     * @optional args 0..n arguments to send to the listener

     *

     */

    domready: {},

    /**

     * Use domready event instead. @see domready

     * @event event:ready

     * @for YUI

     * @deprecated use 'domready' instead

     */

    'event:ready': {

        on: function() {

            var a = Y.Array(arguments, 0, true);

            a[0] = 'domready';

            return Y.subscribe.apply(Y, a);

        },

        detach: function() {

            var a = Y.Array(arguments, 0, true);

            a[0] = 'domready';

            return Y.unsubscribe.apply(Y, a);

        }

    }

});

Y.publish('domready', {

    fireOnce: true

});

if (GLOBAL_ENV.DOMReady) {

    // console.log('DOMReady already fired', 'info', 'event');

    yready();

} else {

    // console.log('setting up before listener', 'info', 'event');

    // console.log('env: ' + YUI.Env.windowLoaded, 'info', 'event');

    Y.before(yready, GLOBAL_ENV, "_ready");

}

})();

(function() {

/**

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

 * events.

 * @module event

 */

/**

 * Wraps a DOM event, properties requiring browser abstraction are

 * fixed here.  Provids a security layer when required.

 * @class DOMEventFacade

 * @param ev {Event} the DOM event

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

 * @param wrapper {Event.Custom} the custom event wrapper for this DOM event

 */

/*

 * @TODO constants? LEFTBUTTON, MIDDLEBUTTON, RIGHTBUTTON, keys

 */

/*

var whitelist = {

    altKey          : 1,

    // "button"          : 1, // we supply

    // "bubbles"         : 1, // needed?

    // "cancelable"      : 1, // needed? 

    // "charCode"        : 1, // we supply

    cancelBubble    : 1,

    // "currentTarget"   : 1, // we supply

    ctrlKey         : 1,

    clientX         : 1, // needed?

    clientY         : 1, // needed?

    detail          : 1, // not fully implemented

    // "fromElement"     : 1,

    keyCode         : 1,

    // "height"          : 1, // needed?

    // "initEvent"       : 1, // need the init events?

    // "initMouseEvent"  : 1,

    // "initUIEvent"     : 1,

    // "layerX"          : 1, // needed?

    // "layerY"          : 1, // needed?

    metaKey         : 1,

    // "modifiers"       : 1, // needed?

    // "offsetX"         : 1, // needed?

    // "offsetY"         : 1, // needed?

    // "preventDefault"  : 1, // we supply

    // "reason"          : 1, // IE proprietary

    // "relatedTarget"   : 1,

    // "returnValue"     : 1, // needed?

    shiftKey        : 1,

    // "srcUrn"          : 1, // IE proprietary

    // "srcElement"      : 1,

    // "srcFilter"       : 1, IE proprietary

    // "stopPropagation" : 1, // we supply

    // "target"          : 1,

    // "timeStamp"       : 1, // needed?

    // "toElement"       : 1,

    type            : 1,

    // "view"            : 1,

    // "which"           : 1, // we supply

    // "width"           : 1, // needed?

    x               : 1,

    y               : 1

},

*/

    var ua = Y.UA,

    /**

     * webkit key remapping required for Safari < 3.1

     * @property webkitKeymap

     * @private

     */

    webkitKeymap = {

        63232: 38, // up

        63233: 40, // down

        63234: 37, // left

        63235: 39, // right

        63276: 33, // page up

        63277: 34, // page down

        25: 9      // SHIFT-TAB (Safari provides a different key code in

                   // this case, even though the shiftKey modifier is set)

    },

    /**

     * Returns a wrapped node.  Intended to be used on event targets,

     * so it will return the node's parent if the target is a text

     * node

     * @method resolve

     * @private

     */

    resolve = function(n) {

        if (!n) {

            return null;

        }

        try {

            if (ua.webkit && 3 == n.nodeType) {

                n = n.parentNode;

            } 

        } catch(ex) { }

        return Y.Node.get(n);

    };

// provide a single event with browser abstractions resolved

//

// include all properties for both browers?

// include only DOM2 spec properties?

// provide browser-specific facade?

Y.DOMEventFacade = function(ev, currentTarget, wrapper) {

    var e = ev, ot = currentTarget, d = Y.config.doc, b = d.body,

        x = e.pageX, y = e.pageY, c, t;

    this.altKey   = e.altKey;

    this.ctrlKey  = e.ctrlKey;

    this.metaKey  = e.metaKey;

    this.shiftKey = e.shiftKey;

    this.type     = e.type;

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

    if (!x && 0 !== x) {

        x = e.clientX || 0;

        y = e.clientY || 0;

        if (ua.ie) {

            x += Math.max(d.documentElement.scrollLeft, b.scrollLeft);

            y += Math.max(d.documentElement.scrollTop, b.scrollTop);

        }

    }

    this._yuifacade = true;

    /**

     * The X location of the event on the page (including scroll)

     * @property pageX

     * @type int

     */

    this.pageX = x;

    /**

     * The Y location of the event on the page (including scroll)

     * @property pageY

     * @type int

     */

    this.pageY = y;

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

    c = e.keyCode || e.charCode || 0;

    if (ua.webkit && (c in webkitKeymap)) {

        c = webkitKeymap[c];

    }

    /**

     * The keyCode for key events.  Uses charCode if keyCode is not available

     * @property keyCode

     * @type int

     */

    this.keyCode = c;

    /**

     * The charCode for key events.  Same as keyCode

     * @property charCode

     * @type int

     */

    this.charCode = c;

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

    /**

     * The button that was pushed.

     * @property button

     * @type int

     */

    this.button = e.which || e.button;

    /**

     * The button that was pushed.  Same as button.

     * @property which

     * @type int

     */

    this.which = this.button;

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

    /**

     * Node reference for the targeted element

     * @propery target

     * @type Node

     */

    this.target = resolve(e.target || e.srcElement);

    /**

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

     * @propery currentTarget

     * @type Node

     */

    this.currentTarget = resolve(ot);

    t = e.relatedTarget;

    if (!t) {

        if (e.type == "mouseout") {

            t = e.toElement;

        } else if (e.type == "mouseover") {

            t = e.fromElement;

        }

    }

    /**

     * Node reference to the relatedTarget

     * @propery relatedTarget

     * @type Node

     */

    this.relatedTarget = resolve(t);

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

    // methods

    /**

     * Stops the propagation to the next bubble target

     * @method stopPropagation

     */

    this.stopPropagation = function() {

        if (e.stopPropagation) {

            e.stopPropagation();

        } else {

            e.cancelBubble = true;

        }

        if (wrapper) {

            wrapper.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() {

        if (e.stopImmediatePropagation) {

            e.stopImmediatePropagation();

        } else {

            this.stopPropagation();

        }

        if (wrapper) {

            wrapper.stopImmediatePropagation();

        }

    };

    /**

     * Prevents the event's default behavior

     * @method preventDefault

     */

    this.preventDefault = function() {

        if (e.preventDefault) {