WB 2.08.x

    /**

     * The type of event, returned to subscribers when the event fires

     */

    this.type = type;

    /**

     * The context the event will fire from by default. Defaults to the window obj.

     */

    this.scope = context || window;

    /**

     * By default all custom events are logged in the debug build. Set silent to true 

     * to disable debug output for this event.

     */

    this.silent = silent;

     * a single time regardless of how many times the event is fired.  In addition,

     * new subscribers will be notified immediately if the event has already been

     * fired.

     */

    this.fireOnce = fireOnce;

    /**

     * Indicates whether or not this event has ever been fired.

     */

    this.fired = false;

    /**

     * For fireOnce events the arguments the event was fired with are stored

     * so that new subscribers get the proper payload.

     */

    this.firedWith = null;

    /**

     * The subscribers to this event

     */

    this.subscribers = [];

         * handle the case where there is a non-repeating event that has

         * already fired has a new subscriber.  

         *

         * Defaults to the custom event.

         * execution context of the listener. If an object, that object becomes 

         * the execution context. Defaults to the custom event.

         */

     * In order to make it possible to execute the rest of the subscriber

     * stack when one thows an exception, the subscribers exceptions are

     * caught.  The most recent exception is stored in this property

     */

    this.lastError = null;

};

    /**

     * Subscribes the caller to this event

     * overrideContext <boolean|Object> If true, the obj passed in becomes the execution 

     * context of the listener. If an object, that object becomes the execution context.

     */

    /**

     * Unsubscribes subscribers.

     *                       all will be removed

     *                        optional, but if supplied will be used to

     *                        disambiguate multiple listeners that are the same

     *                        (e.g., you subscribe many object using a function

     *                        that lives on the prototype)

     */

    unsubscribe: function(fn, obj) {

     *   <li>The custom object (if any) that was passed into the subscribe() 

     *       method</li>

     *   </ul>

     *                            the handler.

     *                   true otherwise

     */

    fire: function() {

    /**

     * Removes all listeners

     */

    unsubscribeAll: function() {

        var l = this.subscribers.length, i;

    },

    /**

     */

    _delete: function(index) {

        var s = this.subscribers[index];

    },

    /**

     */

    toString: function() {

         return "CustomEvent: " + "'" + this.type  + "', " + 

    /**

     * The callback that will be execute when the event fires

     */

    this.fn = fn;

    /**

     * An optional custom object that will passed to the callback when

     * the event fires

     */

    this.obj = YAHOO.lang.isUndefined(obj) ? null : obj;

     * By setting overrideContext to true, the execution context becomes the custom

     * object passed in by the subscriber.  If overrideContext is an object, that 

     * object becomes the context.

     */

    this.overrideContext = overrideContext;

        /**

         * True after the onload event has fired

         */

        var loadComplete =  false,

        /**

         * Cache of wrapped listeners

         */

        listeners = [],

        /**

         * User-defined unload function that will be fired before all events

         * are detached

         */

        unloadListeners = [],

         * The number of times to poll after window.onload.  This number is

         * increased if additional late-bound handlers are requested after

         * the page load.

         */

        retryCount = 0,

        /**

         * onAvailable listeners

         */

        onAvailStack = [],

        /**

         * Counter for auto id generation

         */

        counter = 0,

        /**

         * Normalized keycodes for webkit/safari

         */

         webkitKeymap = {

            63232: 38, // up

             * has been loaded.  The default is 500@amp;40 ms, so it will poll

             * for 20 seconds or until all outstanding handlers are bound

             * (whichever comes first).

             */

            POLL_RETRYS: 500,

            /**

             * The poll interval in milliseconds

             */

            POLL_INTERVAL: 40,

            /**

             * Element to bind, int constant

             */

            EL: 0,

            /**

             * Type of event, int constant

             */

            TYPE: 1,

            /**

             * Function to execute, int constant

             */

            FN: 2,

            /**

             * Function wrapped for context correction and cleanup, int constant

             */

            WFN: 3,

             * Object passed in by the user that will be returned as a 

             * parameter to the callback, int constant.  Specific to

             * unload listeners

             */

            UNLOAD_OBJ: 3,

            /**

             * Adjusted context, either the element we are registering the event

             * on or the custom object passed in by the listener, int constant

             */

            ADJ_SCOPE: 4,

            /**

             * The original obj passed into addListener

             */

            OBJ: 5,

            /**

             * The original context parameter passed into addListener

             */

            OVERRIDE: 6,

            /**

             * The original capture parameter passed into addListener

             */

			CAPTURE: 7,

             * addListener/removeListener can throw errors in unexpected scenarios.

             * These errors are suppressed, the method returns false, and this property

             * is set

             */

            lastError: null,

            /**

             * Safari detection

             */

            isSafari: YAHOO.env.ua.webkit,

            /**

             * webkit version

             */

            webkit: YAHOO.env.ua.webkit,

            /**

             * IE detection 

             */

            isIE: isIE,

            /**

             * poll handle

             */

            _interval: null,

            /**

             * document readystate poll handle

             */

             _dri: null,

            /**

             * Map of special event types

             */

			_specialTypes: {

				focusin: (isIE ? "focusin" : "focus"),

            /**

             * True when the document is initially usable

             */

            DOMReady: false,

             * and the error message is written to the debug console.  If

             * this property is set to true, it will also re-throw the

             * error.

             */

            throwErrors: false,

            /**

             */

            startInterval: function() {

                if (!this._interval) {

             * <p>The callback is executed with a single parameter:

             * the custom object parameter, if provided.</p>

             *

             *

             * of ids to look for.

             *                   a parameter to fn.

             *                   in the context of obj, if set to an object it

             *                   will execute in the context of that object

             */

            onAvailable: function(id, fn, obj, overrideContext, checkContent) {

             * <p>The callback is executed with a single parameter:

             * the custom object parameter, if provided.</p>

             *

             *

             *                   a parameter to fn.

             *                   in the context of obj.  If an object, fn will

             *                   exectute in the context of that object

             *

             */

            onContentReady: function(id, fn, obj, overrideContext) {

                this.onAvailable(id, fn, obj, overrideContext, true);

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

             *

             *

             *

             *                   a parameter to fn.

             *                   in the context of obj, if set to an object it

             *                   will execute in the context of that object

             *

             */

            // onDOMReady: function(fn, obj, overrideContext) {

            onDOMReady: function() {

            /**

             * Appends an event handler

             *

             *

             *  reference, or a collection of ids and/or elements to assign the 

             *  listener to.

             *                             passed as a parameter to the handler

             *                             the execution context of the listener. If an

             *                             object, this object becomes the execution

             *                             context.

             *                        false if one or more of the elements 

             *                        could not have the listener attached,

             *                        or if the operation throws an exception.

             */

            _addListener: function(el, sType, fn, obj, overrideContext, bCapture) {

			 * (as defined by the _specialTypes hash), and (if so) returns 

			 * the special type name.

             *

             *

             */

			_getType: function (type) {

            /**

             * Appends an event handler

             *

             *

             *  reference, or a collection of ids and/or elements to assign the 

             *  listener to.

             *                             passed as a parameter to the handler

             *                             the execution context of the listener. If an

             *                             object, this object becomes the execution

             *                             context.

             *                        false if one or more of the elements 

             *                        could not have the listener attached,

             *                        or if the operation throws an exception.

             */

            addListener: function (el, sType, fn, obj, overrideContext) {

             * Attaches a focusin event listener to the specified element for 

 			 * the purpose of listening for the focus event on the element's 

             * descendants.

             *

             *  reference, or a collection of ids and/or elements to assign the 

             *  listener to.

             *                             passed as a parameter to the handler

             *                             the execution context of the listener. If an

             *                             object, this object becomes the execution

             *                             context.

             *                        false if one or more of the elements 

             *                        could not have the listener attached,

             *                        or if the operation throws an exception.

			* @deprecated use YAHOO.util.Event.on and specify "focusin" as the event type.

             */

            addFocusListener: function (el, fn, obj, overrideContext) {

			 * the purpose of listening for the focus event on the element's 

             * descendants.

             *

             *

             *  reference, or a collection of ids and/or elements to remove

             *  the listener from.

             *  undefined, then all event handlers for the type of event are 

             *  removed.

             *  otherwise.

         	 * @deprecated use YAHOO.util.Event.removeListener and specify "focusin" as the event type.

             */

            removeFocusListener: function (el, fn) { 

			 * the purpose of listening for the blur event on the element's 

			 * descendants.

             *

             *

             *  reference, or a collection of ids and/or elements to assign the 

             *  listener to.

             *                             passed as a parameter to the handler

             *                             the execution context of the listener. If an

             *                             object, this object becomes the execution

             *                             context.

             *                        false if one or more of the elements 

             *                        could not have the listener attached,

             *                        or if the operation throws an exception.

         	 * @deprecated use YAHOO.util.Event.on and specify "focusout" as the event type.

             */

            addBlurListener: function (el, fn, obj, overrideContext) {

			 * the purpose of listening for the blur event on the element's 

			 * descendants.

             *

             *

             *  reference, or a collection of ids and/or elements to remove

             *  the listener from.

             *  undefined, then all event handlers for the type of event are 

             *  removed.

             *  otherwise.

         	 * @deprecated use YAHOO.util.Event.removeListener and specify "focusout" as the event type.

             */

            removeBlurListener: function (el, fn) { 

            /**

             * Removes an event listener

             *

             *

             *  reference, or a collection of ids and/or elements to remove

             *  the listener from.

             *  undefined, then all event handlers for the type of event are 

             *  removed.

             *  otherwise.

             */

            removeListener: function(el, sType, fn) {

                var i, len, li;

             * Returns the event's target element.  Safari sometimes provides

             * a text node, and this is automatically resolved to the text

             * node's parent so that it behaves like other browsers.

             *                  parent will be returned if the target is a 

             *                  text node.  @deprecated, the text node is

             *                  now resolved automatically

             */

            getTarget: function(ev, resolveTextNode) {

                var t = ev.target || ev.srcElement;

             * In some cases, some browsers will return a text node inside

             * the actual element that was targeted.  This normalizes the

             * return value for getTarget and getRelatedTarget.

             */

            resolveTextNode: function(n) {

                try {

            /**

             * Returns the event's pageX

             */

            getPageX: function(ev) {

                var x = ev.pageX;

            /**

             * Returns the event's pageY

             */

            getPageY: function(ev) {

                var y = ev.pageY;

            /**

             * Returns the pageX and pageY properties as an indexed array.

             */

            getXY: function(ev) {

                return [this.getPageX(ev), this.getPageY(ev)];

            /**

             * Returns the event's related target 

             */

            getRelatedTarget: function(ev) {

                var t = ev.relatedTarget;

            /**

             * Returns the time of the event.  If the time is not included, the

             * event is modified using the current time.

             */

            getTime: function(ev) {

                if (!ev.time) {

            /**

             * Convenience method for stopPropagation + preventDefault

             */

            stopEvent: function(ev) {

                this.stopPropagation(ev);

            /**

             * Stops event propagation

             */

            stopPropagation: function(ev) {

                if (ev.stopPropagation) {

            /**

             * Prevents the default behavior of the event

             */

            preventDefault: function(ev) {

                if (ev.preventDefault) {

             * executed automatically for events registered through the event

             * manager, so the implementer should not normally need to execute

             * this function at all.

             */

            getEvent: function(e, boundEl) {

                var ev = e || window.event;

            /**

             * Returns the charcode for an event

             */

            getCharCode: function(ev) {

                var code = ev.keyCode || ev.charCode || 0;

            /**

             * Locating the saved event handler data by function ref

             *

             */

            _getCacheIndex: function(a, el, sType, fn) {

                for (var i=0, l=a.length; i<l; i=i+1) {

            /**

             * Generates an unique ID for the element if it does not already 

             * have one.

             */

            generateId: function(el) {

                var id = el.id;

             * browsers return different types of collections.  This function

             * tests to determine if the object is array-like.  It will also 

             * fail if the object is an array, but is empty.

             */

            _isValidCollection: function(o) {

                try {

            },

            /**

             * DOM element cache

             * elements are removed and re-added

             */

            elCache: {},

            /**

             * We cache elements bound by id because when the unload event 

             * fires, we can no longer use document.getElementById

             */

            getEl: function(id) {

                return (typeof id === "string") ? document.getElementById(id) : id;

            /**

             * Clears the element cache

             */

            clearCache: function() { },

            /**

             * Custom event the fires when the dom is initially usable

             */

            DOMReadyEvent: new YAHOO.util.CustomEvent("DOMReady", YAHOO, 0, 0, 1),

            /**

             * hook up any deferred listeners

             */

            _load: function(e) {

            /**

             * Fires the DOMReady event listeners the first time the document is

             * usable.

             */

            _ready: function(e) {

                var EU = YAHOO.util.Event;

             * Polling function that runs before the onload event fires, 

             * attempting to attach to DOM Nodes as soon as they are 

             * available

             */

            _tryPreloadAttach: function() {

             * Removes all listeners attached to the given element via addListener.

             * Optionally, the node's children can also be purged.

             * Optionally, you can specify a specific type of event to remove.

             * as well.  Use with caution.

             * left out, all listeners will be removed

             */

            purgeElement: function(el, recurse, sType) {

                var oEl = (YAHOO.lang.isString(el)) ? this.getEl(el) : el;

            /**

             * Returns all listeners attached to the given element via addListener.

             * Optionally, you can specify a specific type of event to return.

             * left out, all listeners will be returned

             *   type:   (string)   the type of event

             *   fn:     (function) the callback supplied to addListener

             *   obj:    (object)   the custom object supplied to addListener

             *   adjust: (boolean|object)  whether or not to adjust the default context

             *   scope: (boolean)  the derived context based on the adjust parameter

             *   index:  (int)      its position in the Event util listener cache

             */           

            getListeners: function(el, sType) {

                var results=[], searchLists;

            /**

             * Removes all listeners registered by pe.event.  Called 

             * automatically during the unload event.

             */

            _unload: function(e) {

            /**

             * Returns scrollLeft

             */

            _getScrollLeft: function() {

                return this._getScroll()[1];

            /**

             * Returns scrollTop

             */

            _getScrollTop: function() {

                return this._getScroll()[0];

            /**

             * Returns the scrollTop and scrollLeft.  Used to calculate the 

             * pageX and pageY in Internet Explorer

             */

            _getScroll: function() {

                var dd = document.documentElement, db = document.body;

            /**

             * Used by old versions of CustomEvent, restored for backwards

             * compatibility

             */

            regCE: function() {},

            /**

             * Adds a DOM event directly without the caching, cleanup, context adj, etc

             *

             */

            _simpleAdd: function () {

                if (window.addEventListener) {

            /**

             * Basic remove listener

             *

             */

            _simpleRemove: function() {

                if (window.removeEventListener) {

        /**

         * YAHOO.util.Event.on is an alias for addListener

         */

        EU.on = EU.addListener;

        /**

         * YAHOO.util.Event.onFocus is an alias for addFocusListener

		 * @deprecated use YAHOO.util.Event.on and specify "focusin" as the event type.

         */

        EU.onFocus = EU.addFocusListener;

        /**

         * YAHOO.util.Event.onBlur is an alias for addBlurListener

		 * @deprecated use YAHOO.util.Event.on and specify "focusout" as the event type.

         */     

        EU.onBlur = EU.addBlurListener;

    /**

     * Private storage of custom events

     */

    __yui_events: null,

    /**

     * Private storage of custom event subscribers

     */

    __yui_subscribers: null,

    /**

     * Subscribe to a CustomEvent by event type

     *

     *                              fires

     *                              execution scope of the listener

     */

    subscribe: function(p_type, p_fn, p_obj, overrideContext) {

    /**

     * Unsubscribes one or more listeners the from the specified event

     *                          is not specified, it will attempt to remove

     *                          the listener from all hosted events.

     *                          supplied, all subscribers will be removed.

     *                        optional, but if supplied will be used to

     *                        disambiguate multiple listeners that are the same

     *                        (e.g., you subscribe many object using a function

     *                        that lives on the prototype)

     */

    unsubscribe: function(p_type, p_fn, p_obj) {

        this.__yui_events = this.__yui_events || {};

     * Removes all listeners from the specified event.  If the event type

     * is not specified, all listeners from all hosted custom events will

     * be removed.

     */