yui-rails-asset 2.8.1

data/vendor/assets/javascripts/yui-2.8.1/build/event-mouseenter/event-mouseenter-debug.js

@@ -0,0 +1,219 @@
+/*
+Copyright (c) 2010, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.com/yui/license.html
+version: 2.8.1
+*/
+/**
+ * Augments the Event Utility with support for the mouseenter and mouseleave 
+ * events:  A mouseenter event fires the first time the mouse enters an 
+ * element; a mouseleave event first the first time the mouse leaves an 
+ * element.
+ * 
+ * @module event-mouseenter
+ * @title Event Utility mouseenter and mouseout Module
+ * @namespace YAHOO.util
+ * @requires event
+ */
+
+(function () {
+
+	var Event = YAHOO.util.Event,
+		Lang = YAHOO.lang,
+
+		addListener = Event.addListener,
+		removeListener = Event.removeListener,
+		getListeners = Event.getListeners,
+
+		delegates = [],
+		
+		specialTypes = {
+			mouseenter: "mouseover",
+			mouseleave: "mouseout"
+		}, 
+
+		remove = function(el, type, fn) {
+
+			var index = Event._getCacheIndex(delegates, el, type, fn),
+				cacheItem,
+				returnVal;
+
+		    if (index >= 0) {
+		        cacheItem = delegates[index];
+		    }
+
+		    if (el && cacheItem) {
+
+				//	removeListener will translate the value of type				
+		        returnVal = removeListener.call(Event, cacheItem[0], type, cacheItem[3]);
+		
+				if (returnVal) {
+	                delete delegates[index][2];
+	                delete delegates[index][3];
+	                delegates.splice(index, 1);
+				}
+		
+		    }
+
+			return returnVal;
+
+		};		
+
+
+	Lang.augmentObject(Event._specialTypes, specialTypes); 
+
+	Lang.augmentObject(Event, {
+
+		/**
+		 * Creates a delegate function used to call mouseover and mouseleave 
+		 * event listeners specified via the 
+		 * <code>YAHOO.util.Event.addListener</code> 
+		 * or <code>YAHOO.util.Event.on</code> method.
+		 *
+		 * @method _createMouseDelegate
+		 *
+		 * @param {Function} fn        The method (event listener) to call
+		 * @param {Object}   obj    An arbitrary object that will be 
+		 *                             passed as a parameter to the listener
+		 * @param {Boolean|object}  overrideContext  If true, the value of the 
+		 * 							obj parameter becomes the execution context
+		 *                          of the listener. If an object, this object
+		 *                          becomes the execution context. 
+		 * @return {Function} Function that will call the event listener 
+		 * specified by either the <code>YAHOO.util.Event.addListener</code> 
+		 * or <code>YAHOO.util.Event.on</code> method.
+	     * @private
+		 * @static
+	     * @for Event
+		 */
+		_createMouseDelegate: function (fn, obj, overrideContext) {
+
+			return function (event, container) {
+
+				var el = this,
+					relatedTarget = Event.getRelatedTarget(event),
+					context,
+					args;
+
+				if (el != relatedTarget && !YAHOO.util.Dom.isAncestor(el, relatedTarget)) {
+
+					context = el;
+
+			        if (overrideContext) {
+			            if (overrideContext === true) {
+			                context = obj;
+			            } else {
+			                context = overrideContext;
+			            }
+			        }
+
+					//	The default args passed back to a mouseenter or 
+					//	mouseleave listener are: the event, the element 
+					//	to which the listener is bound, and any object the  
+					//	user passed when subscribing
+
+					args = [event, el, obj];
+
+					//	Add the delegation container as an argument when 
+					//	delegating mouseenter and mouseleave
+
+					if (container) {
+						args.splice(2, 0, container);
+					}
+
+					return fn.apply(context, args);
+
+				}
+
+			};
+
+		},
+		
+		addListener: function (el, type, fn, obj, overrideContext) {
+
+			var fnDelegate,
+				returnVal;
+
+			if (specialTypes[type]) {
+
+				fnDelegate = Event._createMouseDelegate(fn, obj, overrideContext);
+				
+				fnDelegate.mouseDelegate = true;
+
+				delegates.push([el, type, fn, fnDelegate]);
+
+				//	addListener will translate the value of type
+				returnVal = addListener.call(Event, el, type, fnDelegate);
+
+			}
+			else {
+				returnVal = addListener.apply(Event, arguments);
+			}
+
+			return returnVal;
+
+		},
+		
+		removeListener: function (el, type, fn) {
+
+			var returnVal;
+
+			if (specialTypes[type]) {
+				returnVal = remove.apply(Event, arguments);
+			}
+			else {
+				returnVal = removeListener.apply(Event, arguments);
+			}
+
+			return returnVal;
+
+		},
+		
+		getListeners: function (el, type) {
+
+			//	If the user specified the type as mouseover or mouseout, 
+			//	need to filter out those used by mouseenter and mouseleave.
+			//	If the user specified the type as mouseenter or mouseleave, 
+			//	need to filter out the true mouseover and mouseout listeners.
+
+			var listeners = [],
+				elListeners,
+				bMouseOverOrOut = (type === "mouseover" || type === "mouseout"),
+				bMouseDelegate,
+				i,
+				l;
+			
+			if (type && (bMouseOverOrOut || specialTypes[type])) {
+				
+				elListeners = getListeners.call(Event, el, this._getType(type));
+
+	            if (elListeners) {
+
+	                for (i=elListeners.length-1; i>-1; i--) {
+
+	                    l = elListeners[i];
+						bMouseDelegate = l.fn.mouseDelegate;
+
+						if ((specialTypes[type] && bMouseDelegate) || (bMouseOverOrOut && !bMouseDelegate)) {
+							listeners.push(l);
+						}
+
+	                }
+
+	            }
+				
+			}
+			else {
+				listeners = getListeners.apply(Event, arguments);
+			}
+
+            return (listeners && listeners.length) ? listeners : null;
+			
+		}
+		
+	}, true);
+	
+	Event.on = Event.addListener;
+
+}());
+YAHOO.register("event-mouseenter", YAHOO.util.Event, {version: "2.8.1", build: "19"});

data/vendor/assets/javascripts/yui-2.8.1/build/event-mouseenter/event-mouseenter-min.js

@@ -0,0 +1,7 @@
+/*
+Copyright (c) 2010, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.com/yui/license.html
+version: 2.8.1
+*/
+(function(){var B=YAHOO.util.Event,G=YAHOO.lang,E=B.addListener,F=B.removeListener,C=B.getListeners,D=[],H={mouseenter:"mouseover",mouseleave:"mouseout"},A=function(N,M,L){var J=B._getCacheIndex(D,N,M,L),I,K;if(J>=0){I=D[J];}if(N&&I){K=F.call(B,I[0],M,I[3]);if(K){delete D[J][2];delete D[J][3];D.splice(J,1);}}return K;};G.augmentObject(B._specialTypes,H);G.augmentObject(B,{_createMouseDelegate:function(I,J,K){return function(Q,M){var P=this,L=B.getRelatedTarget(Q),O,N;if(P!=L&&!YAHOO.util.Dom.isAncestor(P,L)){O=P;if(K){if(K===true){O=J;}else{O=K;}}N=[Q,P,J];if(M){N.splice(2,0,M);}return I.apply(O,N);}};},addListener:function(M,L,K,N,O){var I,J;if(H[L]){I=B._createMouseDelegate(K,N,O);I.mouseDelegate=true;D.push([M,L,K,I]);J=E.call(B,M,L,I);}else{J=E.apply(B,arguments);}return J;},removeListener:function(L,K,J){var I;if(H[K]){I=A.apply(B,arguments);}else{I=F.apply(B,arguments);}return I;},getListeners:function(N,M){var L=[],P,K=(M==="mouseover"||M==="mouseout"),O,J,I;if(M&&(K||H[M])){P=C.call(B,N,this._getType(M));if(P){for(J=P.length-1;J>-1;J--){I=P[J];O=I.fn.mouseDelegate;if((H[M]&&O)||(K&&!O)){L.push(I);}}}}else{L=C.apply(B,arguments);}return(L&&L.length)?L:null;}},true);B.on=B.addListener;}());YAHOO.register("event-mouseenter",YAHOO.util.Event,{version:"2.8.1",build:"19"});

data/vendor/assets/javascripts/yui-2.8.1/build/event-mouseenter/event-mouseenter.js

@@ -0,0 +1,219 @@
+/*
+Copyright (c) 2010, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.com/yui/license.html
+version: 2.8.1
+*/
+/**
+ * Augments the Event Utility with support for the mouseenter and mouseleave 
+ * events:  A mouseenter event fires the first time the mouse enters an 
+ * element; a mouseleave event first the first time the mouse leaves an 
+ * element.
+ * 
+ * @module event-mouseenter
+ * @title Event Utility mouseenter and mouseout Module
+ * @namespace YAHOO.util
+ * @requires event
+ */
+
+(function () {
+
+	var Event = YAHOO.util.Event,
+		Lang = YAHOO.lang,
+
+		addListener = Event.addListener,
+		removeListener = Event.removeListener,
+		getListeners = Event.getListeners,
+
+		delegates = [],
+		
+		specialTypes = {
+			mouseenter: "mouseover",
+			mouseleave: "mouseout"
+		}, 
+
+		remove = function(el, type, fn) {
+
+			var index = Event._getCacheIndex(delegates, el, type, fn),
+				cacheItem,
+				returnVal;
+
+		    if (index >= 0) {
+		        cacheItem = delegates[index];
+		    }
+
+		    if (el && cacheItem) {
+
+				//	removeListener will translate the value of type				
+		        returnVal = removeListener.call(Event, cacheItem[0], type, cacheItem[3]);
+		
+				if (returnVal) {
+	                delete delegates[index][2];
+	                delete delegates[index][3];
+	                delegates.splice(index, 1);
+				}
+		
+		    }
+
+			return returnVal;
+
+		};		
+
+
+	Lang.augmentObject(Event._specialTypes, specialTypes); 
+
+	Lang.augmentObject(Event, {
+
+		/**
+		 * Creates a delegate function used to call mouseover and mouseleave 
+		 * event listeners specified via the 
+		 * <code>YAHOO.util.Event.addListener</code> 
+		 * or <code>YAHOO.util.Event.on</code> method.
+		 *
+		 * @method _createMouseDelegate
+		 *
+		 * @param {Function} fn        The method (event listener) to call
+		 * @param {Object}   obj    An arbitrary object that will be 
+		 *                             passed as a parameter to the listener
+		 * @param {Boolean|object}  overrideContext  If true, the value of the 
+		 * 							obj parameter becomes the execution context
+		 *                          of the listener. If an object, this object
+		 *                          becomes the execution context. 
+		 * @return {Function} Function that will call the event listener 
+		 * specified by either the <code>YAHOO.util.Event.addListener</code> 
+		 * or <code>YAHOO.util.Event.on</code> method.
+	     * @private
+		 * @static
+	     * @for Event
+		 */
+		_createMouseDelegate: function (fn, obj, overrideContext) {
+
+			return function (event, container) {
+
+				var el = this,
+					relatedTarget = Event.getRelatedTarget(event),
+					context,
+					args;
+
+				if (el != relatedTarget && !YAHOO.util.Dom.isAncestor(el, relatedTarget)) {
+
+					context = el;
+
+			        if (overrideContext) {
+			            if (overrideContext === true) {
+			                context = obj;
+			            } else {
+			                context = overrideContext;
+			            }
+			        }
+
+					//	The default args passed back to a mouseenter or 
+					//	mouseleave listener are: the event, the element 
+					//	to which the listener is bound, and any object the  
+					//	user passed when subscribing
+
+					args = [event, el, obj];
+
+					//	Add the delegation container as an argument when 
+					//	delegating mouseenter and mouseleave
+
+					if (container) {
+						args.splice(2, 0, container);
+					}
+
+					return fn.apply(context, args);
+
+				}
+
+			};
+
+		},
+		
+		addListener: function (el, type, fn, obj, overrideContext) {
+
+			var fnDelegate,
+				returnVal;
+
+			if (specialTypes[type]) {
+
+				fnDelegate = Event._createMouseDelegate(fn, obj, overrideContext);
+				
+				fnDelegate.mouseDelegate = true;
+
+				delegates.push([el, type, fn, fnDelegate]);
+
+				//	addListener will translate the value of type
+				returnVal = addListener.call(Event, el, type, fnDelegate);
+
+			}
+			else {
+				returnVal = addListener.apply(Event, arguments);
+			}
+
+			return returnVal;
+
+		},
+		
+		removeListener: function (el, type, fn) {
+
+			var returnVal;
+
+			if (specialTypes[type]) {
+				returnVal = remove.apply(Event, arguments);
+			}
+			else {
+				returnVal = removeListener.apply(Event, arguments);
+			}
+
+			return returnVal;
+
+		},
+		
+		getListeners: function (el, type) {
+
+			//	If the user specified the type as mouseover or mouseout, 
+			//	need to filter out those used by mouseenter and mouseleave.
+			//	If the user specified the type as mouseenter or mouseleave, 
+			//	need to filter out the true mouseover and mouseout listeners.
+
+			var listeners = [],
+				elListeners,
+				bMouseOverOrOut = (type === "mouseover" || type === "mouseout"),
+				bMouseDelegate,
+				i,
+				l;
+			
+			if (type && (bMouseOverOrOut || specialTypes[type])) {
+				
+				elListeners = getListeners.call(Event, el, this._getType(type));
+
+	            if (elListeners) {
+
+	                for (i=elListeners.length-1; i>-1; i--) {
+
+	                    l = elListeners[i];
+						bMouseDelegate = l.fn.mouseDelegate;
+
+						if ((specialTypes[type] && bMouseDelegate) || (bMouseOverOrOut && !bMouseDelegate)) {
+							listeners.push(l);
+						}
+
+	                }
+
+	            }
+				
+			}
+			else {
+				listeners = getListeners.apply(Event, arguments);
+			}
+
+            return (listeners && listeners.length) ? listeners : null;
+			
+		}
+		
+	}, true);
+	
+	Event.on = Event.addListener;
+
+}());
+YAHOO.register("event-mouseenter", YAHOO.util.Event, {version: "2.8.1", build: "19"});

data/vendor/assets/javascripts/yui-2.8.1/build/event-simulate/event-simulate-debug.js

@@ -0,0 +1,622 @@
+/*
+Copyright (c) 2010, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.com/yui/license.html
+version: 2.8.1
+*/
+
+/**
+ * DOM event simulation utility
+ * @module event-simulate
+ * @namespace YAHOO.util
+ * @requires yahoo,dom,event
+ */
+
+/**
+ * The UserAction object provides functions that simulate events occurring in
+ * the browser. Since these are simulated events, they do not behave exactly
+ * as regular, user-initiated events do, but can be used to test simple
+ * user interactions safely.
+ *
+ * @namespace YAHOO.util
+ * @class UserAction
+ * @static
+ */
+YAHOO.util.UserAction = {
+
+    //--------------------------------------------------------------------------
+    // Generic event methods
+    //--------------------------------------------------------------------------
+
+    /**
+     * 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 (Optional) Indicates if the event can be
+     *      bubbled up. DOM Level 3 specifies that all key events bubble by
+     *      default. The default is true.
+     * @param {Boolean} cancelable (Optional) Indicates if the event can be
+     *      canceled using preventDefault(). DOM Level 3 specifies that all
+     *      key events can be cancelled. The default 
+     *      is true.
+     * @param {Window} view (Optional) The view containing the target. This is
+     *      typically the window object. The default is window.
+     * @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 {int} keyCode (Optional) The code for the key that is in use. 
+     *      The default is 0.
+     * @param {int} charCode (Optional) The Unicode code for the character
+     *      associated with the key being used. The default is 0.
+     */
+    simulateKeyEvent : function (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
+        target = YAHOO.util.Dom.get(target);        
+        if (!target){
+            throw new Error("simulateKeyEvent(): Invalid target.");
+        }
+        
+        //check event type
+        if (YAHOO.lang.isString(type)){
+            type = type.toLowerCase();
+            switch(type){
+                case "keyup":
+                case "keydown":
+                case "keypress":
+                    break;
+                case "textevent": //DOM Level 3
+                    type = "keypress";
+                    break;
+                    // @TODO was the fallthrough intentional, if so throw error
+                default:
+                    throw new Error("simulateKeyEvent(): Event type '" + type + "' not supported.");
+            }
+        } else {
+            throw new Error("simulateKeyEvent(): Event type must be a string.");
+        }
+        
+        //setup default values
+        if (!YAHOO.lang.isBoolean(bubbles)){
+            bubbles = true; //all key events bubble
+        }
+        if (!YAHOO.lang.isBoolean(cancelable)){
+            cancelable = true; //all key events can be cancelled
+        }
+        if (!YAHOO.lang.isObject(view)){
+            view = window; //view is typically window
+        }
+        if (!YAHOO.lang.isBoolean(ctrlKey)){
+            ctrlKey = false;
+        }
+        if (!YAHOO.lang.isBoolean(altKey)){
+            altKey = false;
+        }
+        if (!YAHOO.lang.isBoolean(shiftKey)){
+            shiftKey = false;
+        }
+        if (!YAHOO.lang.isBoolean(metaKey)){
+            metaKey = false;
+        }
+        if (!YAHOO.lang.isNumber(keyCode)){
+            keyCode = 0;
+        }
+        if (!YAHOO.lang.isNumber(charCode)){
+            charCode = 0; 
+        }
+
+        //try to create a mouse event
+        var customEvent /*:MouseEvent*/ = null;
+            
+        //check for DOM-compliant browsers first
+        if (YAHOO.lang.isFunction(document.createEvent)){
+        
+            try {
+                
+                //try to create key event
+                customEvent = document.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 = document.createEvent("Events");
+
+                } catch (uierror /*:Error*/){
+
+                    //the above failed, so create a UIEvent for Safari 2.x
+                    customEvent = document.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 (YAHOO.lang.isObject(document.createEventObject)){ //IE
+        
+            //create an IE event object
+            customEvent = document.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 {
+            throw new Error("simulateKeyEvent(): No event simulation framework present.");
+        }
+    },
+
+    /**
+     * 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 {int} detail (Optional) The number of times the mouse button has
+     *      been used. The default value is 1.
+     * @param {int} screenX (Optional) The x-coordinate on the screen at which
+     *      point the event occured. The default is 0.
+     * @param {int} screenY (Optional) The y-coordinate on the screen at which
+     *      point the event occured. The default is 0.
+     * @param {int} clientX (Optional) The x-coordinate on the client at which
+     *      point the event occured. The default is 0.
+     * @param {int} 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 {int} 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.
+     */
+    simulateMouseEvent : function (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
+        target = YAHOO.util.Dom.get(target);        
+        if (!target){
+            throw new Error("simulateMouseEvent(): Invalid target.");
+        }
+        
+        //check event type
+        if (YAHOO.lang.isString(type)){
+            type = type.toLowerCase();
+            switch(type){
+                case "mouseover":
+                case "mouseout":
+                case "mousedown":
+                case "mouseup":
+                case "click":
+                case "dblclick":
+                case "mousemove":
+                    break;
+                default:
+                    throw new Error("simulateMouseEvent(): Event type '" + type + "' not supported.");
+            }
+        } else {
+            throw new Error("simulateMouseEvent(): Event type must be a string.");
+        }
+        
+        //setup default values
+        if (!YAHOO.lang.isBoolean(bubbles)){
+            bubbles = true; //all mouse events bubble
+        }
+        if (!YAHOO.lang.isBoolean(cancelable)){
+            cancelable = (type != "mousemove"); //mousemove is the only one that can't be cancelled
+        }
+        if (!YAHOO.lang.isObject(view)){
+            view = window; //view is typically window
+        }
+        if (!YAHOO.lang.isNumber(detail)){
+            detail = 1;  //number of mouse clicks must be at least one
+        }
+        if (!YAHOO.lang.isNumber(screenX)){
+            screenX = 0; 
+        }
+        if (!YAHOO.lang.isNumber(screenY)){
+            screenY = 0; 
+        }
+        if (!YAHOO.lang.isNumber(clientX)){
+            clientX = 0; 
+        }
+        if (!YAHOO.lang.isNumber(clientY)){
+            clientY = 0; 
+        }
+        if (!YAHOO.lang.isBoolean(ctrlKey)){
+            ctrlKey = false;
+        }
+        if (!YAHOO.lang.isBoolean(altKey)){
+            altKey = false;
+        }
+        if (!YAHOO.lang.isBoolean(shiftKey)){
+            shiftKey = false;
+        }
+        if (!YAHOO.lang.isBoolean(metaKey)){
+            metaKey = false;
+        }
+        if (!YAHOO.lang.isNumber(button)){
+            button = 0; 
+        }
+
+        //try to create a mouse event
+        var customEvent /*:MouseEvent*/ = null;
+            
+        //check for DOM-compliant browsers first
+        if (YAHOO.lang.isFunction(document.createEvent)){
+        
+            customEvent = document.createEvent("MouseEvents");
+        
+            //Safari 2.x (WebKit 418) still doesn't implement initMouseEvent()
+            if (customEvent.initMouseEvent){
+                customEvent.initMouseEvent(type, bubbles, cancelable, view, detail,
+                                     screenX, screenY, clientX, clientY, 
+                                     ctrlKey, altKey, shiftKey, metaKey, 
+                                     button, relatedTarget);
+            } else { //Safari
+            
+                //the closest thing available in Safari 2.x is UIEvents
+                customEvent = document.createEvent("UIEvents");
+                customEvent.initEvent(type, bubbles, cancelable);
+                customEvent.view = view;
+                customEvent.detail = detail;
+                customEvent.screenX = screenX;
+                customEvent.screenY = screenY;
+                customEvent.clientX = clientX;
+                customEvent.clientY = clientY;
+                customEvent.ctrlKey = ctrlKey;
+                customEvent.altKey = altKey;
+                customEvent.metaKey = metaKey;
+                customEvent.shiftKey = shiftKey;
+                customEvent.button = button;
+                customEvent.relatedTarget = relatedTarget;
+            }
+            
+            /*
+             * Check to see if relatedTarget has been assigned. Firefox
+             * versions less than 2.0 don't allow it to be assigned via
+             * initMouseEvent() and the property is readonly after event
+             * creation, so in order to keep YAHOO.util.getRelatedTarget()
+             * working, assign to the IE proprietary toElement property
+             * for mouseout event and fromElement property for mouseover
+             * event.
+             */
+            if (relatedTarget && !customEvent.relatedTarget){
+                if (type == "mouseout"){
+                    customEvent.toElement = relatedTarget;
+                } else if (type == "mouseover"){
+                    customEvent.fromElement = relatedTarget;
+                }
+            }
+            
+            //fire the event
+            target.dispatchEvent(customEvent);
+
+        } else if (YAHOO.lang.isObject(document.createEventObject)){ //IE
+        
+            //create an IE event object
+            customEvent = document.createEventObject();
+            
+            //assign available properties
+            customEvent.bubbles = bubbles;
+            customEvent.cancelable = cancelable;
+            customEvent.view = view;
+            customEvent.detail = detail;
+            customEvent.screenX = screenX;
+            customEvent.screenY = screenY;
+            customEvent.clientX = clientX;
+            customEvent.clientY = clientY;
+            customEvent.ctrlKey = ctrlKey;
+            customEvent.altKey = altKey;
+            customEvent.metaKey = metaKey;
+            customEvent.shiftKey = shiftKey;
+
+            //fix button property for IE's wacky implementation
+            switch(button){
+                case 0:
+                    customEvent.button = 1;
+                    break;
+                case 1:
+                    customEvent.button = 4;
+                    break;
+                case 2:
+                    //leave as is
+                    break;
+                default:
+                    customEvent.button = 0;                    
+            }    
+
+            /*
+             * Have to use relatedTarget because IE won't allow assignment
+             * to toElement or fromElement on generic events. This keeps
+             * YAHOO.util.customEvent.getRelatedTarget() functional.
+             */
+            customEvent.relatedTarget = relatedTarget;
+            
+            //fire the event
+            target.fireEvent("on" + type, customEvent);
+                    
+        } else {
+            throw new Error("simulateMouseEvent(): No event simulation framework present.");
+        }
+    },
+   
+    //--------------------------------------------------------------------------
+    // Mouse events
+    //--------------------------------------------------------------------------
+
+    /**
+     * Simulates a mouse event on a particular element.
+     * @param {HTMLElement} target The element to click on.
+     * @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 {Object} options Additional event options (use DOM standard names).
+     * @method mouseEvent
+     * @static
+     */
+    fireMouseEvent : function (target /*:HTMLElement*/, type /*:String*/, 
+                           options /*:Object*/) /*:Void*/
+    {
+        options = options || {};
+        this.simulateMouseEvent(target, type, options.bubbles,
+            options.cancelable, options.view, options.detail, options.screenX,        
+            options.screenY, options.clientX, options.clientY, options.ctrlKey,
+            options.altKey, options.shiftKey, options.metaKey, options.button,         
+            options.relatedTarget);        
+    },
+
+    /**
+     * Simulates a click on a particular element.
+     * @param {HTMLElement} target The element to click on.
+     * @param {Object} options Additional event options (use DOM standard names).
+     * @method click
+     * @static     
+     */
+    click : function (target /*:HTMLElement*/, options /*:Object*/) /*:Void*/ {
+        this.fireMouseEvent(target, "click", options);
+    },
+    
+    /**
+     * Simulates a double click on a particular element.
+     * @param {HTMLElement} target The element to double click on.
+     * @param {Object} options Additional event options (use DOM standard names).
+     * @method dblclick
+     * @static
+     */
+    dblclick : function (target /*:HTMLElement*/, options /*:Object*/) /*:Void*/ {
+        this.fireMouseEvent( target, "dblclick", options);
+    },
+    
+    /**
+     * Simulates a mousedown on a particular element.
+     * @param {HTMLElement} target The element to act on.
+     * @param {Object} options Additional event options (use DOM standard names).
+     * @method mousedown
+     * @static
+     */
+    mousedown : function (target /*:HTMLElement*/, options /*Object*/) /*:Void*/ {
+        this.fireMouseEvent(target, "mousedown", options);
+    },
+    
+    /**
+     * Simulates a mousemove on a particular element.
+     * @param {HTMLElement} target The element to act on.
+     * @param {Object} options Additional event options (use DOM standard names).
+     * @method mousemove
+     * @static
+     */
+    mousemove : function (target /*:HTMLElement*/, options /*Object*/) /*:Void*/ {
+        this.fireMouseEvent(target, "mousemove", options);
+    },
+    
+    /**
+     * Simulates a mouseout event on a particular element. Use "relatedTarget"
+     * on the options object to specify where the mouse moved to.
+     * Quirks: Firefox less than 2.0 doesn't set relatedTarget properly, so
+     * toElement is assigned in its place. IE doesn't allow toElement to be
+     * be assigned, so relatedTarget is assigned in its place. Both of these
+     * concessions allow YAHOO.util.Event.getRelatedTarget() to work correctly
+     * in both browsers.
+     * @param {HTMLElement} target The element to act on.
+     * @param {Object} options Additional event options (use DOM standard names).
+     * @method mouseout
+     * @static
+     */
+    mouseout : function (target /*:HTMLElement*/, options /*Object*/) /*:Void*/ {
+        this.fireMouseEvent(target, "mouseout", options);
+    },
+    
+    /**
+     * Simulates a mouseover event on a particular element. Use "relatedTarget"
+     * on the options object to specify where the mouse moved from.
+     * Quirks: Firefox less than 2.0 doesn't set relatedTarget properly, so
+     * fromElement is assigned in its place. IE doesn't allow fromElement to be
+     * be assigned, so relatedTarget is assigned in its place. Both of these
+     * concessions allow YAHOO.util.Event.getRelatedTarget() to work correctly
+     * in both browsers.
+     * @param {HTMLElement} target The element to act on.
+     * @param {Object} options Additional event options (use DOM standard names).
+     * @method mouseover
+     * @static
+     */
+    mouseover : function (target /*:HTMLElement*/, options /*Object*/) /*:Void*/ {
+        this.fireMouseEvent(target, "mouseover", options);
+    },
+    
+    /**
+     * Simulates a mouseup on a particular element.
+     * @param {HTMLElement} target The element to act on.
+     * @param {Object} options Additional event options (use DOM standard names).
+     * @method mouseup
+     * @static
+     */
+    mouseup : function (target /*:HTMLElement*/, options /*Object*/) /*:Void*/ {
+        this.fireMouseEvent(target, "mouseup", options);
+    },
+    
+    //--------------------------------------------------------------------------
+    // Key events
+    //--------------------------------------------------------------------------
+
+    /**
+     * Fires an event that normally would be fired by the keyboard (keyup,
+     * keydown, keypress). Make sure to specify either keyCode or charCode as
+     * an option.
+     * @private
+     * @param {String} type The type of event ("keyup", "keydown" or "keypress").
+     * @param {HTMLElement} target The target of the event.
+     * @param {Object} options Options for the event. Either keyCode or charCode
+     *                         are required.
+     * @method fireKeyEvent
+     * @static
+     */     
+    fireKeyEvent : function (type /*:String*/, target /*:HTMLElement*/,
+                             options /*:Object*/) /*:Void*/ 
+    {
+        options = options || {};
+        this.simulateKeyEvent(target, type, options.bubbles,
+            options.cancelable, options.view, options.ctrlKey,
+            options.altKey, options.shiftKey, options.metaKey, 
+            options.keyCode, options.charCode);    
+    },
+    
+    /**
+     * Simulates a keydown event on a particular element.
+     * @param {HTMLElement} target The element to act on.
+     * @param {Object} options Additional event options (use DOM standard names).
+     * @method keydown
+     * @static
+     */
+    keydown : function (target /*:HTMLElement*/, options /*:Object*/) /*:Void*/ {
+        this.fireKeyEvent("keydown", target, options);
+    },
+    
+    /**
+     * Simulates a keypress on a particular element.
+     * @param {HTMLElement} target The element to act on.
+     * @param {Object} options Additional event options (use DOM standard names).
+     * @method keypress
+     * @static
+     */
+    keypress : function (target /*:HTMLElement*/, options /*:Object*/) /*:Void*/ {
+        this.fireKeyEvent("keypress", target, options);
+    },
+    
+    /**
+     * Simulates a keyup event on a particular element.
+     * @param {HTMLElement} target The element to act on.
+     * @param {Object} options Additional event options (use DOM standard names).
+     * @method keyup
+     * @static
+     */
+    keyup : function (target /*:HTMLElement*/, options /*Object*/) /*:Void*/ {
+        this.fireKeyEvent("keyup", target, options);
+    }
+    
+
+};
+YAHOO.register("event-simulate", YAHOO.util.UserAction, {version: "2.8.1", build: "19"});