/as3/trunk/src/org/papervision3d/core/utils/virtualmouse/VirtualMouse.as

/**

* @author Trevor McCauley

* @link www.senocular.com

*/



package org.papervision3d.core.utils.virtualmouse

{	



	

	import flash.display.DisplayObject;

	import flash.display.DisplayObjectContainer;

	import flash.display.InteractiveObject;

	import flash.display.SimpleButton;

	import flash.display.Sprite;

	import flash.display.Stage;

	import flash.events.Event;

	import flash.events.EventDispatcher;

	import flash.events.KeyboardEvent;

	import flash.events.MouseEvent;

	import flash.geom.Point;

	import flash.utils.Dictionary;

	

	import org.papervision3d.core.log.PaperLogger;

	

    /**

     * Dispatched when the virtual mouse state is updated.

     * @eventType flash.events.Event

     */

	[Event(name="update", type="flash.events.Event")]

	

    /**

     * Dispatched when the virtual mouse fires an

	 * Event.MOUSE_LEAVE event.

     * @eventType flash.events.Event

     */

	[Event(name="mouseLeave", type="flash.events.Event")]

	

    /**

     * Dispatched when the virtual mouse fires an

	 * MouseEvent.MOUSE_MOVE event.

     * @eventType flash.events.MouseEvent

     */

	[Event(name="mouseMove", type="flash.events.MouseEvent")]

	

    /**

     * Dispatched when the virtual mouse fires an

	 * MouseEvent.MOUSE_OUT event.

     * @eventType flash.events.MouseEvent

     */

	[Event(name="mouseOut", type="flash.events.MouseEvent")]

    /**

     * Dispatched when the virtual mouse fires an

	 * MouseEvent.ROLL_OUT event.

     * @eventType flash.events.MouseEvent

     */

	[Event(name="rollOut", type="flash.events.MouseEvent")]

	

    /**

     * Dispatched when the virtual mouse fires an

	 * MouseEvent.MOUSE_OVER event.

     * @eventType flash.events.MouseEvent

     */

	[Event(name="mouseOver", type="flash.events.MouseEvent")]

	

    /**

     * Dispatched when the virtual mouse fires an

	 * MouseEvent.ROLL_OVER event.

     * @eventType flash.events.MouseEvent

     */

	[Event(name="rollOver", type="flash.events.MouseEvent")]

	

    /**

     * Dispatched when the virtual mouse fires an

	 * MouseEvent.MOUSE_DOWN event.

     * @eventType flash.events.MouseEvent

     */

	[Event(name="mouseDown", type="flash.events.MouseEvent")]

	

    /**

     * Dispatched when the virtual mouse fires an

	 * MouseEvent.MOUSE_UP event.

     * @eventType flash.events.MouseEvent

     */

	[Event(name="mouseUp", type="flash.events.MouseEvent")]

	

    /**

     * Dispatched when the virtual mouse fires an

	 * MouseEvent.CLICK event.

     * @eventType flash.events.MouseEvent

     */

	[Event(name="click", type="flash.events.MouseEvent")]

	

    /**

     * Dispatched when the virtual mouse fires an

	 * MouseEvent.DOUBLE_CLICK event.

     * @eventType flash.events.MouseEvent

     */

	[Event(name="doubleClick", type="flash.events.MouseEvent")]

	

	/**

	 * The VirtualMouse class is used to create a programmatic 

	 * version of the users mouse that can be moved about the

	 * Flash player stage firing off mouse events of the display

	 * objects it interacts with.  This can allow you to simulate

	 * interaction with buttons and movie clips through ActionScript.

	 * <br />

	 * Handled events include:

	 * 		Event.MOUSE_LEAVE,

	 * 		MouseEvent.MOUSE_MOVE,

	 * 		MouseEvent.MOUSE_OUT,

	 * 		MouseEvent.ROLL_OUT,

	 * 		MouseEvent.MOUSE_OVER,

	 * 		MouseEvent.ROLL_OVER,

	 * 		MouseEvent.MOUSE_DOWN,

	 * 		MouseEvent.MOUSE_UP.

	 * 		MouseEvent.CLICK, and,

	 * 		MouseEvent.DOUBLE_CLICK.

	 * Along with dispatching those events for their respective

	 * targets, the VirtualMouse instance will also dispatch the

	 * event on itself allowing to capture which events are being

	 * fired by the virtual mouse.  The last event fired can also

	 * be referenced in the lastEvent property.

	 * <br />

	 * VirtualMouse mouse cannot:

	 * 		activate states of SimpleButton instances, 

	 * 		change object focus, 

	 * 		handle mouseWheel related events,

	 * 		change the system's cursor location, or 

	 * 		spoof the location of the mouseX and mouseY properties

	 * 			(which some components rely on).

	 */

	public class VirtualMouse extends EventDispatcher {

		

		public static const UPDATE:String = "update";

		

		private var altKey:Boolean = false;

		private var ctrlKey:Boolean = false;

		private var shiftKey:Boolean = false;

		private var delta:int = 0; // mouseWheel unsupported

		

		private var _stage:Stage;

		private var _container:Sprite;

		private var target:InteractiveObject;

		

		private var location:Point;

		

		private var isLocked:Boolean = false;

		private var isDoubleClickEvent:Boolean = false;

		private static var _mouseIsDown:Boolean = false;

		

		private var disabledEvents:Object = new Object();

		private var ignoredInstances:Dictionary = new Dictionary(true);

		

		private var _lastEvent:Event;

		private var lastMouseDown:Boolean = false;

		private var updateMouseDown:Boolean = false;

		private var lastLocation:Point;

		private var lastDownTarget:DisplayObject;

		private var lastWithinStage:Boolean = true;

			

		private var _useNativeEvents:Boolean = false;

		private var eventEvent:Class = VirtualMouseEvent;

		private var mouseEventEvent:Class = VirtualMouseMouseEvent;

		

		

		

		/**

		 * A reference to the Stage instance. This

		 * reference needs to be passed to the 

		 * VirtualMouse instance either in its constructor

		 * or through assigning it's stage property.

		 * Without a valid reference to the stage, the

		 * virtual mouse will not function.

		 * @see VirtualMouse()

		 */

		public function get stage():Stage {

			return _stage;

		}

		public function set stage(s:Stage):void {

			var hadStage:Boolean;

			if (_stage){

				hadStage = true;

				_stage.removeEventListener(KeyboardEvent.KEY_DOWN, keyHandler);

				_stage.removeEventListener(KeyboardEvent.KEY_UP, keyHandler);

			}else{

				hadStage = false;

			}

			_stage = s;

			if (_stage) {

				_stage.addEventListener(KeyboardEvent.KEY_DOWN, keyHandler);

				_stage.addEventListener(KeyboardEvent.KEY_UP, keyHandler);

				target = _stage;

				if (!hadStage) update();

			}

		}

		

		/**

		* 

		* @param	value Sprite container you want VirtualMouse to use with its testing of sub containers

		* @return

		*/

		public function set container(value:Sprite):void

		{

			_container = value;

		}

		public function get container():Sprite { return _container; }

		

		/**

		 * The last event dispatched by the VirtualMouse

		 * instance.  This can be useful for preventing

		 * event recursion if performing VirtualMouse

		 * operations within MouseEvent handlers.

		 */

		public function get lastEvent():Event {

			return _lastEvent;

		}

		

		/**

		 * True if the virtual mouse is being

		 * pressed, false if not.  The mouse is

		 * down for the virtual mouse if press()

		 * was called.

		 * @see press()

		 * @see release()

		 */

		public function get mouseIsDown():Boolean {

			return _mouseIsDown;

		}

		

		/**

		 * The x location of the virtual mouse. If you are

		 * setting both the x and y properties of the

		 * virtual mouse at the same time, you would probably

		 * want to lock the VirtualMouse instance to prevent

		 * additional events from firing.

		 * @see lock

		 * @see unlock

		 * @see y

		 * @see setLocation()

		 * @see getLocation()

		 */

		public function get x():Number {

			return location.x;

		}

		public function set x(n:Number):void {

			location.x = n;

			if (!isLocked) update();

		}

		

		/**

		 * The y location of the virtual mouse.  If you are

		 * setting both the x and y properties of the

		 * virtual mouse at the same time, you would probably

		 * want to lock the VirtualMouse instance to prevent

		 * additional events from firing.

		 * @see lock

		 * @see unlock

		 * @see x

		 * @see setLocation()

		 * @see getLocation()

		 */

		public function get y():Number {

			return location.y;

		}

		public function set y(n:Number):void {

			location.y = n;

			if (!isLocked) update();

		}

		

		/**

		 * Determines if the events dispatched by the

		 * VirtualMouse instance are IVirualMouseEvent

		 * Events (wrapping Event and MouseEvent) or events

		 * of the native Event and MouseEvent type. When using

		 * non-native events, you can check to see if the

		 * events originated from VirtualMouse by seeing if

		 * the events are of the type IVirualMouseEvent.

		 * @see lastEvent

		 */

		public function get useNativeEvents():Boolean {

			return _useNativeEvents;

		}

		public function set useNativeEvents(b:Boolean):void {

			if (b == _useNativeEvents) return;

			_useNativeEvents = b;

			if (_useNativeEvents){

				eventEvent = VirtualMouseEvent;

				mouseEventEvent = VirtualMouseMouseEvent;

			}else{

				eventEvent = Event;

				mouseEventEvent = MouseEvent;

			}

		}

		

		/** 

		 * Initializes a new VirtualMouse instance. 

		 * @param stage A reference to the stage instance.

		 * @param startX The initial x location of

		 * 		the virtual mouse.

		 * @param startY The initial y location of

		 * 		the virtual mouse.

		 */

		public function VirtualMouse(stage:Stage = null, container:Sprite = null, startX:Number = 0, startY:Number = 0) {

			this.stage = stage;

			this.container = container;

			location = new Point(startX, startY);

			lastLocation = location.clone();

			addEventListener(UPDATE, handleUpdate);

			update();

		}

		

		/**

		 * Returns the location (x and y) of the current

		 * VirtualMouse instance. The location of the

		 * virtual mouse is based in the global

		 * coordinate space.

		 * @return A Point instance representing the 

		 * 		location of the virtual mouse in

		 * 		global coordinate space.

		 * @see x

		 * @see y

		 * @see setLocation()

		 */

		public function getLocation():Point {

			return location.clone();

		}

		

		/**

		 * Sets the location (x and y) of the current

		 * VirtualMouse instance.  There are two ways to

		 * call setLocation, either passing in a single

		 * Point instance, or by passing in two Number

		 * instances representing x and y coordinates.

		 * The location of the virtual mouse is based in

		 * the global coordinate space.

		 * @param a A Point instance or x Number value.

		 * @param b A y Number value if a is a Number.

		 * @see x

		 * @see y

		 * @see getLocation()

		 */

		public function setLocation(a:*, b:* = null):void 

		{

			//log.debug("VM setLocation", a, b);

			if (a is Point) {

				var loc:Point = a as Point;

				location.x = loc.x;

				location.y = loc.y;

			}else{

				location.x = Number(a);

				location.y = Number(b);

			}



			if (!isLocked) update();

		}

		

		/**

		 * Locks the current VirtualMouse instance

		 * preventing updates from being made as 

		 * properties change within the instance.

		 * To release and allow an update, call unlock().

		 * @see lock()

		 * @see update()

		 */

		public function lock():void {

			isLocked = true;

		}

		

		/**

		 * Unlocks the current VirtualMouse instance

		 * allowing updates to be made for the

		 * dispatching of virtual mouse events. After

		 * unlocking the instance, it will update and

		 * additional calls to press(), release(), or

		 * changing the location of the virtual mouse

		 * will also invoke updates.

		 * @see lock()

		 * @see update()

		 */

		public function unlock():void {

			isLocked = false;

			update();

		}

		

		/**

		 * Allows you to disable an event by type

		 * preventing the virtual mouse from 

		 * dispatching that event during an update.

		 * @param type The type for the event to

		 * 		disable, e.g. MouseEvent.CLICK

		 * @see enableEvent()

		 */

		public function disableEvent(type:String):void {

			disabledEvents[type] = true;

		}

		

		/**

		 * Re-enables an event disabled with

		 * disableEvent.

		 * @param type The type for the event to

		 * 		enable, e.g. MouseEvent.CLICK

		 * @see disableEvent()

		 */

		public function enableEvent(type:String):void {

			if (type in disabledEvents) {

				delete disabledEvents[type];

			}

		}

		

		/**

		 * Ignores a display object preventing that

		 * object from recieving events from the

		 * virtual mouse.  This is useful for instances

		 * used for cursors which may always be under

		 * the virtual mouse's location.

		 * @param instance A reference to the

		 * 		DisplayObject instance to ignore.

		 * @see unignore()

		 */

		public function ignore(instance:DisplayObject):void {

			ignoredInstances[instance] = true;

		}

		

		/**

		 * Removes an instance from the ignore list

		 * defined by ignore().  When an ingored

		 * object is passed into unignore(), it will

		 * be able to receive events from the virtual

		 * mouse.

		 * @param instance A reference to the

		 * 		DisplayObject instance to unignore.

		 * @see ignore()

		 */

		public function unignore(instance:DisplayObject):void {

			if (instance in ignoredInstances){

				delete ignoredInstances[instance];

			}

		}

		

		/**

		 * Simulates the pressing of the left

		 * mouse button. To release the mouse

		 * button, use release().

		 * @see release()

		 * @see click()

		 */

		public function press():void {

			//if (_mouseIsDown) return;

			updateMouseDown = true;

			_mouseIsDown = true;

			if (!isLocked) update();

		}

		

		/**

		 * Simulates the release of the left

		 * mouse button.  This method has no

		 * effect unless press() was called first.

		 * @see press()

		 * @see click()

		 */

		public function release():void {

			//if (!_mouseIsDown) return;

			updateMouseDown = true;

			_mouseIsDown = false;

			if (!isLocked) update();

		}

		

		/**

		 * Simulates a click of the left

		 * mouse button (press and release)

		 * @see press()

		 * @see release()

		 * @see click()

		 * @see doubleClick()

		 */

		public function click():void {

			press();

			release();

		}

		

		/**

		 * Simulates a double-click of the left

		 * mouse button (press and release twice).

		 * Calling this command is the only way to

		 * simulate a double-click for the virtual

		 * mouse.  Calling press() and release() or

		 * click() is rapid succession will not

		 * invoke a double-click event. The double-click

		 * event will also only fire for an instance

		 * if it's doubleClickEnabled property is

		 * set to true.

		 * @see click()

		 */

		public function doubleClick():void {

			// if locked, doubleClick will

			// not fire but the mouse will 

			// be released if not already

			if (isLocked) {

				release();

			}else{



				// call update with a click, press, then release

				// and double-click notification for release

				click();

				press();

				isDoubleClickEvent = true;

				release();

				isDoubleClickEvent = false;

			}

		}

		

		/*Added by Jim Kremens kremens@gmail.com 08/16/07 */

		public function exitContainer():void {

			if( !container ) return;

			var targetLocal:Point = target.globalToLocal(location);

			//log.debug("Targetlocal", target != container);

			if (!disabledEvents[MouseEvent.MOUSE_OUT]) {

				_lastEvent = new mouseEventEvent(MouseEvent.MOUSE_OUT, true, false, targetLocal.x, targetLocal.y, container, ctrlKey, altKey, shiftKey, _mouseIsDown, delta);

				container.dispatchEvent(new mouseEventEvent(MouseEvent.MOUSE_OUT, true, false, targetLocal.x, targetLocal.y, container, ctrlKey, altKey, shiftKey, _mouseIsDown, delta));

				dispatchEvent(new mouseEventEvent(MouseEvent.MOUSE_OUT, true, false, targetLocal.x, targetLocal.y, container, ctrlKey, altKey, shiftKey, _mouseIsDown, delta));

			}

			if (!disabledEvents[MouseEvent.ROLL_OUT]) { // rolls do not propagate

				_lastEvent = new mouseEventEvent(MouseEvent.ROLL_OUT, false, false, targetLocal.x, targetLocal.y, container, ctrlKey, altKey, shiftKey, _mouseIsDown, delta);

				container.dispatchEvent(new mouseEventEvent(MouseEvent.ROLL_OUT, false, false, targetLocal.x, targetLocal.y, container, ctrlKey, altKey, shiftKey, _mouseIsDown, delta));

				dispatchEvent(new mouseEventEvent(MouseEvent.ROLL_OUT, false, false, targetLocal.x, targetLocal.y, container, ctrlKey, altKey, shiftKey, _mouseIsDown, delta));

			}

			if (target != container) {

				if (!disabledEvents[MouseEvent.MOUSE_OUT]) {

					_lastEvent = new mouseEventEvent(MouseEvent.MOUSE_OUT, true, false, targetLocal.x, targetLocal.y, container, ctrlKey, altKey, shiftKey, _mouseIsDown, delta);

					target.dispatchEvent(new mouseEventEvent(MouseEvent.MOUSE_OUT, true, false, targetLocal.x, targetLocal.y, container, ctrlKey, altKey, shiftKey, _mouseIsDown, delta));

					dispatchEvent(new mouseEventEvent(MouseEvent.MOUSE_OUT, true, false, targetLocal.x, targetLocal.y, container, ctrlKey, altKey, shiftKey, _mouseIsDown, delta));

				}

				if (!disabledEvents[MouseEvent.ROLL_OUT]) { // rolls do not propagate

					_lastEvent = new mouseEventEvent(MouseEvent.ROLL_OUT, false, false, targetLocal.x, targetLocal.y, container, ctrlKey, altKey, shiftKey, _mouseIsDown, delta);

					target.dispatchEvent(new mouseEventEvent(MouseEvent.ROLL_OUT, false, false, targetLocal.x, targetLocal.y, container, ctrlKey, altKey, shiftKey, _mouseIsDown, delta));

					dispatchEvent(new mouseEventEvent(MouseEvent.ROLL_OUT, false, false, targetLocal.x, targetLocal.y, container, ctrlKey, altKey, shiftKey, _mouseIsDown, delta));

				}

			}

			//reset the target to the stage, which is the value it starts at.

			target = _stage;

		}

		

		/**

		 * Updates the VirtualMouse instance's state

		 * to reflect a change in the virtual mouse.

		 * Within this method all events will be dispatched.

		 * update() is called any time a VirtualMouse

		 * property is changed unless lock() was used to

		 * lock the instance.  update() will then not be

		 * called until unlock() is used to unlock

		 * the instance. Typically you would never call

		 * update() directly; it is called automatically

		 * by the VirtualMouse class. Calling update()

		 * manually will override lock(). Whenever update()

		 * is called, the UPDATE event is dispatched.

		 * @see lock()

		 * @see unlock()

		 */

		public function update():void {

			// dispatch an update event indicating that 

			// an update has occured

			dispatchEvent(new Event(UPDATE, false, false));

		}

		

		private function handleUpdate(event:Event):void 

		{

			if (!container) return;

				

			// go through each objectsUnderPoint checking:

			// 		1) is not ignored

			//		2) is InteractiveObject

			//		3) mouseEnabled

			// 		4) all parents have mouseChildren

			// if not interactive object, defer interaction to next object in list

			// if is interactive and enabled, give interaction and ignore rest

			

			// var p:Point = CoordinateTools.localToLocal(container, stage, location);

			//var objectsUnderPoint:Array = container.getObjectsUnderPoint(p); 

			

			if( container.scrollRect ){

				PaperLogger.warning("The container that virtualMouse is trying to test against has a scrollRect defined, and may cause an issue with finding objects under a defined point.  Use MovieMaterial.rect to set a rectangle area instead");

			}

			var originalPoint:Point = new Point();

			originalPoint.x = container.x;

			originalPoint.y = container.y;

			container.x = container.y = 0;

			

			var objectsUnderPoint:Array = container.getObjectsUnderPoint(location);

			

			container.x = originalPoint.x;

			container.y = originalPoint.y;

			

			var currentTarget:InteractiveObject;

			var currentParent:DisplayObject;

			

			var i:int = objectsUnderPoint.length;

			

			while (i--) {

				currentParent = objectsUnderPoint[i];

				

				// go through parent hierarchy

				while (currentParent) {

					

					// don't use ignored instances as the target

					if (ignoredInstances[currentParent]

					) {

						currentTarget = null;

						break;

					}

					

					// invalid target if in a SimpleButton

					if (currentTarget && currentParent is SimpleButton) 

					{

						//log.debug("found SimpleButton - setting currentTarget to null");

						currentTarget = null;

						

					// invalid target if a parent has a

					// false mouseChildren

					} else if (currentTarget && !DisplayObjectContainer(currentParent).mouseChildren) 

					{

						//log.debug("parent false mouseChildren - setting currentTarget to null");

						currentTarget = null;

					}

					

					// define target if an InteractiveObject

					// and mouseEnabled is true

					if (!currentTarget && currentParent is InteractiveObject && InteractiveObject(currentParent).mouseEnabled) 

					{

						//log.debug("found InteractiveObject && mouseEnabled = true - setting currentTarget");

						currentTarget = InteractiveObject(currentParent);

					}

					

					// next parent in hierarchy

					currentParent = currentParent.parent;

				}

				

				// if a currentTarget was found

				// ignore all other objectsUnderPoint

				if (currentTarget){

					break;

				}

			}

			

			

			

			// if a currentTarget was not found

			// the currentTarget is the stage

			if (!currentTarget)

			{

				//trace("no CurrentTarget", container.hitTestPoint(location.x, location.y));

				currentTarget = container;

				//currentTarget = _stage;

				//log.debug("no new target found, using stage");

			}

			

			// get local coordinate locations

			var targetLocal:Point = target.globalToLocal(location);

			var currentTargetLocal:Point = currentTarget.globalToLocal(location);

			

			

			// move event

			if (lastLocation.x != location.x || lastLocation.y != location.y) 

			{				

				var withinStage:Boolean = false;

				if(stage) withinStage = (location.x >= 0 && location.y >= 0 && location.x <= stage.stageWidth && location.y <= stage.stageHeight);

				

				// mouse leave if left stage

				if (!withinStage && lastWithinStage && !disabledEvents[Event.MOUSE_LEAVE]){

					_lastEvent = new eventEvent(Event.MOUSE_LEAVE, false, false);

					stage.dispatchEvent(_lastEvent);

					dispatchEvent(_lastEvent);

				}

				

				// only mouse move if within stage

				if (withinStage && !disabledEvents[MouseEvent.MOUSE_MOVE]){

					_lastEvent = new mouseEventEvent(MouseEvent.MOUSE_MOVE, true, false, currentTargetLocal.x, currentTargetLocal.y, currentTarget, ctrlKey, altKey, shiftKey, _mouseIsDown, delta);

					currentTarget.dispatchEvent(_lastEvent);

					dispatchEvent(_lastEvent);

				}

				

				// remember if within stage

				lastWithinStage = withinStage;

			}

			

			// roll/mouse (out and over) events 

			

			if (currentTarget != target) 

			{	

				// off of last target

				if (!disabledEvents[MouseEvent.MOUSE_OUT]){

					_lastEvent = new mouseEventEvent(MouseEvent.MOUSE_OUT, true, false, targetLocal.x, targetLocal.y, currentTarget, ctrlKey, altKey, shiftKey, _mouseIsDown, delta);

					target.dispatchEvent(_lastEvent);

					dispatchEvent(_lastEvent);

				}

				if (!disabledEvents[MouseEvent.ROLL_OUT]){ // rolls do not propagate

					_lastEvent = new mouseEventEvent(MouseEvent.ROLL_OUT, false, false, targetLocal.x, targetLocal.y, currentTarget, ctrlKey, altKey, shiftKey, _mouseIsDown, delta);

					target.dispatchEvent(_lastEvent);

					dispatchEvent(_lastEvent);

				}

				

				// on to current target

				if (!disabledEvents[MouseEvent.MOUSE_OVER]){

					//log.debug("*** MOUSEOVER****");

					_lastEvent = new mouseEventEvent(MouseEvent.MOUSE_OVER, true, false, currentTargetLocal.x, currentTargetLocal.y, target, ctrlKey, altKey, shiftKey, _mouseIsDown, delta);

					currentTarget.dispatchEvent(_lastEvent);

					dispatchEvent(_lastEvent);

				}

				if (!disabledEvents[MouseEvent.ROLL_OVER]){ // rolls do not propagate

					//log.debug("*** ROLLOVER****");

					_lastEvent = new mouseEventEvent(MouseEvent.ROLL_OVER, false, false, currentTargetLocal.x, currentTargetLocal.y, target, ctrlKey, altKey, shiftKey, _mouseIsDown, delta);

					currentTarget.dispatchEvent(_lastEvent);

					dispatchEvent(_lastEvent);

				}

			

			

			}

			

			// click/up/down events

			if (updateMouseDown) {

				if (_mouseIsDown) {

					

					if (!disabledEvents[MouseEvent.MOUSE_DOWN]){

						_lastEvent = new mouseEventEvent(MouseEvent.MOUSE_DOWN, true, false, currentTargetLocal.x, currentTargetLocal.y, currentTarget, ctrlKey, altKey, shiftKey, _mouseIsDown, delta);

						currentTarget.dispatchEvent(_lastEvent);

						dispatchEvent(_lastEvent);

					}

					

					// remember last down

					lastDownTarget = currentTarget;

					updateMouseDown = false;

				// mouse is up

				}else{

					if (!disabledEvents[MouseEvent.MOUSE_UP]){

						_lastEvent = new mouseEventEvent(MouseEvent.MOUSE_UP, true, false, currentTargetLocal.x, currentTargetLocal.y, currentTarget, ctrlKey, altKey, shiftKey, _mouseIsDown, delta);

						currentTarget.dispatchEvent(_lastEvent);

						dispatchEvent(_lastEvent);

					}

					

					if (!disabledEvents[MouseEvent.CLICK] && currentTarget == lastDownTarget) {

						_lastEvent = new mouseEventEvent(MouseEvent.CLICK, true, false, currentTargetLocal.x, currentTargetLocal.y, currentTarget, ctrlKey, altKey, shiftKey, _mouseIsDown, delta);

						currentTarget.dispatchEvent(_lastEvent);

						dispatchEvent(_lastEvent);

					}

					

					// clear last down

					lastDownTarget = null;

					updateMouseDown = false;

				}

			}

			

			// explicit call to doubleClick()

			if (isDoubleClickEvent && !disabledEvents[MouseEvent.DOUBLE_CLICK] && currentTarget.doubleClickEnabled) {

				_lastEvent = new mouseEventEvent(MouseEvent.DOUBLE_CLICK, true, false, currentTargetLocal.x, currentTargetLocal.y, currentTarget, ctrlKey, altKey, shiftKey, _mouseIsDown, delta);

				currentTarget.dispatchEvent(_lastEvent);

				dispatchEvent(_lastEvent);

			}

			

			// remember last values

			lastLocation = location.clone();

			lastMouseDown = _mouseIsDown;

			target = currentTarget;

		}

		

		private function keyHandler(event:KeyboardEvent):void {

			// update properties used in MouseEvents

			altKey = event.altKey;

			ctrlKey = event.ctrlKey;

			shiftKey = event.shiftKey;

		}

	}

}