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

(function() {

/**

 * Simulate user interaction by generating native DOM events.

 *

 * @module event-simulate

 * @requires event

 */

//shortcuts

var L   = Y.Lang,

    win = Y.config.win,

    isFunction  = L.isFunction,

    isString    = L.isString,

    isBoolean   = L.isBoolean,

    isObject    = L.isObject,

    isNumber    = L.isNumber,

    //mouse events supported

    mouseEvents = {

        click:      1,

        dblclick:   1,

        mouseover:  1,

        mouseout:   1,

        mousedown:  1,

        mouseup:    1,

        mousemove:  1,

        contextmenu:1

    },

    pointerEvents = (win && win.PointerEvent) ? {

        pointerover:  1,

        pointerout:   1,

        pointerdown:  1,

        pointerup:    1,

        pointermove:  1

    } : {

        MSPointerOver:  1,

        MSPointerOut:   1,

        MSPointerDown:  1,

        MSPointerUp:    1,

        MSPointerMove:  1

    },

    //key events supported

    keyEvents   = {

        keydown:    1,

        keyup:      1,

        keypress:   1

    },

    //HTML events supported

    uiEvents  = {

        submit:     1,

        blur:       1,

        change:     1,

        focus:      1,

        resize:     1,

        scroll:     1,

        select:     1

    },

    //events that bubble by default

    bubbleEvents = {

        scroll:     1,

        resize:     1,

        reset:      1,

        submit:     1,

        change:     1,

        select:     1,

        error:      1,

        abort:      1

    },

    //touch events supported

    touchEvents = {

        touchstart: 1,

        touchmove: 1,

        touchend: 1,

        touchcancel: 1

    },

    gestureEvents = {

        gesturestart: 1,

        gesturechange: 1,

        gestureend: 1

    };

//all key, mouse and touch events bubble

Y.mix(bubbleEvents, mouseEvents);

Y.mix(bubbleEvents, keyEvents);

Y.mix(bubbleEvents, touchEvents);

/*

 * Note: Intentionally not for YUIDoc generation.

 * Simulates a key event using the given event information to populate

 * the generated event object. This method does browser-equalizing

 * calculations to account for differences in the DOM and IE event models

 * as well as different browser quirks. Note: keydown causes Safari 2.x to

 * crash.

 * @method simulateKeyEvent

 * @private

 * @static

 * @param {HTMLElement} target The target of the given event.

 * @param {String} type The type of event to fire. This can be any one of

 *      the following: keyup, keydown, and keypress.

 * @param {Boolean} [bubbles=true] Indicates if the event can be

 *      bubbled up. DOM Level 3 specifies that all key events bubble by

 *      default.

 * @param {Boolean} [cancelable=true] Indicates if the event can be

 *      canceled using preventDefault(). DOM Level 3 specifies that all

 *      key events can be cancelled.

 * @param {Window} [view=window] The view containing the target. This is

 *      typically the window object.

 * @param {Boolean} [ctrlKey=false] Indicates if one of the CTRL keys

 *      is pressed while the event is firing.

 * @param {Boolean} [altKey=false] Indicates if one of the ALT keys

 *      is pressed while the event is firing.

 * @param {Boolean} [shiftKey=false] Indicates if one of the SHIFT keys

 *      is pressed while the event is firing.

 * @param {Boolean} [metaKey=false] Indicates if one of the META keys

 *      is pressed while the event is firing.

 * @param {Number} [keyCode=0] The code for the key that is in use.

 * @param {Number} [charCode=0] The Unicode code for the character

 *      associated with the key being used.

 */

function simulateKeyEvent(target /*:HTMLElement*/, type /*:String*/,

                             bubbles /*:Boolean*/,  cancelable /*:Boolean*/,

                             view /*:Window*/,

                             ctrlKey /*:Boolean*/,    altKey /*:Boolean*/,

                             shiftKey /*:Boolean*/,   metaKey /*:Boolean*/,

                             keyCode /*:int*/,        charCode /*:int*/) /*:Void*/

{

    //check target

    if (!target){

        Y.error("simulateKeyEvent(): Invalid target.");

    }

    //check event type

    if (isString(type)){

        type = type.toLowerCase();

        switch(type){

            case "textevent": //DOM Level 3

                type = "keypress";

                break;

            case "keyup":

            case "keydown":

            case "keypress":

                break;

            default:

                Y.error("simulateKeyEvent(): Event type '" + type + "' not supported.");

        }

    } else {

        Y.error("simulateKeyEvent(): Event type must be a string.");

    }

    //setup default values

    if (!isBoolean(bubbles)){

        bubbles = true; //all key events bubble

    }

    if (!isBoolean(cancelable)){

        cancelable = true; //all key events can be cancelled

    }

    if (!isObject(view)){

        view = Y.config.win; //view is typically window

    }

    if (!isBoolean(ctrlKey)){

        ctrlKey = false;

    }

    if (!isBoolean(altKey)){

        altKey = false;

    }

    if (!isBoolean(shiftKey)){

        shiftKey = false;

    }

    if (!isBoolean(metaKey)){

        metaKey = false;

    }

    if (!isNumber(keyCode)){

        keyCode = 0;

    }

    if (!isNumber(charCode)){

        charCode = 0;

    }

    //try to create a mouse event

    var customEvent /*:MouseEvent*/ = null;

    //check for DOM-compliant browsers first

    if (isFunction(Y.config.doc.createEvent)){

        try {

            //try to create key event

            customEvent = Y.config.doc.createEvent("KeyEvents");

            /*

             * Interesting problem: Firefox implemented a non-standard

             * version of initKeyEvent() based on DOM Level 2 specs.

             * Key event was removed from DOM Level 2 and re-introduced

             * in DOM Level 3 with a different interface. Firefox is the

             * only browser with any implementation of Key Events, so for

             * now, assume it's Firefox if the above line doesn't error.

             */

            // @TODO: Decipher between Firefox's implementation and a correct one.

            customEvent.initKeyEvent(type, bubbles, cancelable, view, ctrlKey,

                altKey, shiftKey, metaKey, keyCode, charCode);

        } catch (ex /*:Error*/){

            /*

             * If it got here, that means key events aren't officially supported.

             * Safari/WebKit is a real problem now. WebKit 522 won't let you

             * set keyCode, charCode, or other properties if you use a

             * UIEvent, so we first must try to create a generic event. The

             * fun part is that this will throw an error on Safari 2.x. The

             * end result is that we need another try...catch statement just to

             * deal with this mess.

             */

            try {

                //try to create generic event - will fail in Safari 2.x

                customEvent = Y.config.doc.createEvent("Events");

            } catch (uierror /*:Error*/){

                //the above failed, so create a UIEvent for Safari 2.x

                customEvent = Y.config.doc.createEvent("UIEvents");

            } finally {

                customEvent.initEvent(type, bubbles, cancelable);

                //initialize

                customEvent.view = view;

                customEvent.altKey = altKey;

                customEvent.ctrlKey = ctrlKey;

                customEvent.shiftKey = shiftKey;

                customEvent.metaKey = metaKey;

                customEvent.keyCode = keyCode;

                customEvent.charCode = charCode;

            }

        }

        //fire the event

        target.dispatchEvent(customEvent);

    } else if (isObject(Y.config.doc.createEventObject)){ //IE

        //create an IE event object

        customEvent = Y.config.doc.createEventObject();

        //assign available properties

        customEvent.bubbles = bubbles;

        customEvent.cancelable = cancelable;

        customEvent.view = view;

        customEvent.ctrlKey = ctrlKey;

        customEvent.altKey = altKey;

        customEvent.shiftKey = shiftKey;

        customEvent.metaKey = metaKey;

        /*

         * IE doesn't support charCode explicitly. CharCode should

         * take precedence over any keyCode value for accurate

         * representation.

         */

        customEvent.keyCode = (charCode > 0) ? charCode : keyCode;

        //fire the event

        target.fireEvent("on" + type, customEvent);

    } else {

        Y.error("simulateKeyEvent(): No event simulation framework present.");

    }

}

/*

 * Note: Intentionally not for YUIDoc generation.

 * Simulates a mouse event using the given event information to populate

 * the generated event object. This method does browser-equalizing

 * calculations to account for differences in the DOM and IE event models

 * as well as different browser quirks.

 * @method simulateMouseEvent

 * @private

 * @static

 * @param {HTMLElement} target The target of the given event.

 * @param {String} type The type of event to fire. This can be any one of

 *      the following: click, dblclick, mousedown, mouseup, mouseout,

 *      mouseover, and mousemove.

 * @param {Boolean} bubbles (Optional) Indicates if the event can be

 *      bubbled up. DOM Level 2 specifies that all mouse events bubble by

 *      default. The default is true.

 * @param {Boolean} cancelable (Optional) Indicates if the event can be

 *      canceled using preventDefault(). DOM Level 2 specifies that all

 *      mouse events except mousemove can be cancelled. The default

 *      is true for all events except mousemove, for which the default

 *      is false.

 * @param {Window} view (Optional) The view containing the target. This is

 *      typically the window object. The default is window.

 * @param {Number} detail (Optional) The number of times the mouse button has

 *      been used. The default value is 1.

 * @param {Number} screenX (Optional) The x-coordinate on the screen at which

 *      point the event occured. The default is 0.

 * @param {Number} screenY (Optional) The y-coordinate on the screen at which

 *      point the event occured. The default is 0.

 * @param {Number} clientX (Optional) The x-coordinate on the client at which

 *      point the event occured. The default is 0.

 * @param {Number} clientY (Optional) The y-coordinate on the client at which

 *      point the event occured. The default is 0.

 * @param {Boolean} ctrlKey (Optional) Indicates if one of the CTRL keys

 *      is pressed while the event is firing. The default is false.

 * @param {Boolean} altKey (Optional) Indicates if one of the ALT keys

 *      is pressed while the event is firing. The default is false.

 * @param {Boolean} shiftKey (Optional) Indicates if one of the SHIFT keys

 *      is pressed while the event is firing. The default is false.

 * @param {Boolean} metaKey (Optional) Indicates if one of the META keys

 *      is pressed while the event is firing. The default is false.

 * @param {Number} button (Optional) The button being pressed while the event

 *      is executing. The value should be 0 for the primary mouse button

 *      (typically the left button), 1 for the terciary mouse button

 *      (typically the middle button), and 2 for the secondary mouse button

 *      (typically the right button). The default is 0.

 * @param {HTMLElement} relatedTarget (Optional) For mouseout events,

 *      this is the element that the mouse has moved to. For mouseover

 *      events, this is the element that the mouse has moved from. This

 *      argument is ignored for all other events. The default is null.

 */

function simulateMouseEvent(target /*:HTMLElement*/, type /*:String*/,

                               bubbles /*:Boolean*/,  cancelable /*:Boolean*/,

                               view /*:Window*/,        detail /*:int*/,

                               screenX /*:int*/,        screenY /*:int*/,

                               clientX /*:int*/,        clientY /*:int*/,

                               ctrlKey /*:Boolean*/,    altKey /*:Boolean*/,

                               shiftKey /*:Boolean*/,   metaKey /*:Boolean*/,

                               button /*:int*/,         relatedTarget /*:HTMLElement*/) /*:Void*/

{

    //check target

    if (!target){

        Y.error("simulateMouseEvent(): Invalid target.");

    }

    if (isString(type)){

        //make sure it's a supported mouse event or an msPointerEvent.

        if (!mouseEvents[type.toLowerCase()] && !pointerEvents[type]){

            Y.error("simulateMouseEvent(): Event type '" + type + "' not supported.");

        }

    }

    else {

        Y.error("simulateMouseEvent(): Event type must be a string.");

    }

    //setup default values

    if (!isBoolean(bubbles)){

        bubbles = true; //all mouse events bubble

    }

    if (!isBoolean(cancelable)){

        cancelable = (type !== "mousemove"); //mousemove is the only one that can't be cancelled

    }

    if (!isObject(view)){

        view = Y.config.win; //view is typically window

    }

    if (!isNumber(detail)){

        detail = 1;  //number of mouse clicks must be at least one

    }

    if (!isNumber(screenX)){

        screenX = 0;

    }

    if (!isNumber(screenY)){

        screenY = 0;

    }

    if (!isNumber(clientX)){

        clientX = 0;

    }

    if (!isNumber(clientY)){

        clientY = 0;

    }

    if (!isBoolean(ctrlKey)){

        ctrlKey = false;

    }

    if (!isBoolean(altKey)){

        altKey = false;

    }

    if (!isBoolean(shiftKey)){

        shiftKey = false;

    }

    if (!isBoolean(metaKey)){

        metaKey = false;

    }

    if (!isNumber(button)){

        button = 0;

    }

    relatedTarget = relatedTarget || null;

    //try to create a mouse event

    var customEvent /*:MouseEvent*/ = null;

    //check for DOM-compliant browsers first

    if (isFunction(Y.config.doc.createEvent)){

        customEvent = Y.config.doc.createEvent("MouseEvents");

        //Safari 2.x (WebKit 418) still doesn't implement initMouseEvent()

        if (customEvent.initMouseEvent){

            customEvent.initMouseEvent(type, bubbles, cancelable, view, detail,