mako 0.0.0

data/lib/mako/data/flash_widget_dev_core/src/nm/ui/ToolTip.as

@@ -0,0 +1,930 @@
+/* See the file "LICENSE.txt" for the full license governing this code. */
+package nm.ui {
+import flash.display.DisplayObject;
+import flash.display.Sprite;
+import flash.events.Event;
+import flash.events.EventDispatcher;
+import flash.events.MouseEvent;
+import flash.events.TimerEvent;
+import flash.geom.Point;
+import flash.utils.Timer;
+public class ToolTip
+{
+	/**
+	 * Constant for determining showDelay in the showToolTip function
+	 */
+	private static const AUTO:int = -1;
+	/**
+	 * Constant for timerState when timer is inactive
+	 */
+	private static const INACTIVE:int = 0;
+	/**
+	 * Constant for timerState when timer is preparing to hide the tooltip
+	 */
+	private static const HIDE:int = 2;
+	/**
+	 * Constant for timerState when timer is preparing to show the tooltip
+	 */
+	private static const SHOW:int = 1;
+	/**
+	 * True when an item with a tooltip is being dragged.
+	 * Tooltips are usually disabled when this is true.
+	 */
+	private static var _draggingToolTipItem:Boolean = false;
+	/**
+	 * List of references to items with tooltips attached to them.
+	 */
+	private static var itemList:Array = new Array();
+	/**
+	 * The actual toolTip bubble that shows when a tooltip is made visible.
+	 * Yes, there is only one. That's all we need to display tooltips universally.
+	 */
+	private static var tipBubble:TipBubble;
+	/**
+	 * Timer used to enforce showDelay and hideDelay
+	 */
+	private static var bubbleTimer:Timer;
+	/**
+	 * Keeps track of what the timer is being used for.
+	 * Possibilities are 0 - INACTIVE, 1 - SHOW, 2 - HIDE
+	 */
+	private static var timerState:int = INACTIVE;
+	/**
+	 * Keeps track of the point where the mouse was pressed. Used to detect if
+	 * the user is dragging an object or not (in which case, the bubble fades away
+	 */
+	private static var mouseDownPoint:Point;
+	/**
+	 * This class acts as a singleton. Use Tooltip.add()
+	 * @see add()
+	 */
+	public function ToolTip(doNotInstantiate:SingletonEnforcer):void {}
+	/**
+	 * Creates a tooltip that is shown whenever user hovers mouse over given target.
+	 * Make sure to always remove tooltips when you're done with them using ToolTip.remove()
+	 *
+	 * @param target
+	 * @param text
+	 * @param options Object containing options that control the given tooltip
+	 * 			direction:String - ["auto"|"up"|"down"|"left"|"right"|"center"]; default is "auto"
+	 *          directionPriority:String - ["up"|"down"|"left"|"right"|"center"]; first direction to try when direction is auto; default is "up";
+	 * 			anchor:String - ["mouse"|"object"]; base position off mouse or object; default is "object"
+	 * 			width:Number - the width of the bubble; default: 200
+	 * 			xOffset:Number - number of fudge bubble's position along the x-axis
+	 * 			yOffset:Number - number of fudge bubble's position along the y-axis
+	 * 			fadeTime:int - fade delay in milliseconds; default: 150
+	 * 			showDelay:int - time to wait before showing tooltip; default: 300
+	 * 			hideDelay:int - time to wait before hiding tooltip; default: 200
+	 * 			showCallback:Function - function to call whenever tip bubble is shown
+	 * 			hideCallback:Function - function to call whenever tip bubble is hidden
+	 * @param style Object containing styling options for customizing the tooltip's appearance
+	 * 			textColor:Number - the color of the text displayed in this tooltip; default: 0xffffff
+	 * 			htmlText:Boolean - if true, the tooltip will display text as html; default: false
+	 * 			fontFamily:String - name of font to be used (i.e. 'Verdana'); default: 'Verdana'
+	 * 			fontSize:int - the size of the font to be used; default: 12
+	 * 			fontStyle:int - [normal|bold|italic|bold-italic]; default: normal
+	 * 			textAlign:String - alignment style for text: [left|right|center|justify]; default: center
+	 * 			padding:Number - padding between edge of bubble and text (all directions); default: 5
+	 * 			backgroundColor:Number - a color to paint the background of this tooltip; default: 0x232323
+	 * 			backgroundAlpha:Number - a number between 0 and 1 (inclusive) that determines transparency; default: 0.3
+	 * 			borderThickness:Number - the desired size (in pixels) of the tooltip's border; default: 5
+	 * 			borderColor:Number - the color to be used for the border of this tooltip; default: 0xffffff;
+	 * 			borderAlpha:Number - a number between 0 and 1 (inclusive) that determines transparency of the border; default: 0.3
+	 * 			borderRadius:Number - the desired curvature for the rounded corners; default: 4
+	 */
+	public static function add(target:DisplayObject, text:String, options:Object = null, style:Object = null):void
+	{
+		if(text == null || text.length == 0) { return; }
+		target.addEventListener(MouseEvent.ROLL_OVER, onMouseOver, false, 0, true);
+		itemList.push(new TipObject(target, text, options, style));
+	}
+	/**
+	 * Removes the tooltip assigned to the given component
+	 * @param target The item to remove a tooltip for
+	 * @param cycleAll Tries to save performance by stopping the search loop as soon as target is found. Good to disable if item has only one tooltip and you're sure you didn't add more by mistake.
+	 */
+	public static function remove(target:DisplayObject, cycleAll:Boolean = true):void
+	{
+		for(var i:int = 0; i < itemList.length; i++)
+		{
+			if(itemList[i].target == target)
+			{
+				// remove the element from itemList
+				itemList.splice(i, 1);
+				// remove listeners associated with this object
+				target.removeEventListener(MouseEvent.ROLL_OVER, onMouseOver);
+				target.removeEventListener(MouseEvent.ROLL_OUT, onMouseOut);
+				target.removeEventListener(MouseEvent.MOUSE_DOWN, onMouseDown);
+				removeTimer();
+				// destroy tipBubble and remove any associated listeners
+				if(tipBubble != null && tipBubble.tipObject.target == target)
+				{
+					if(tipBubble.visible)
+					{
+						tipBubble.hide(true);
+						tipBubble.removeEventListener(MouseEvent.ROLL_OUT, onMouseOut);
+						tipBubble.removeEventListener(MouseEvent.MOUSE_DOWN, onMouseDown);
+						tipBubble.removeEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);
+						if(tipBubble.tipObject.target.stage!= null) tipBubble.tipObject.target.stage.removeEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);
+						if(tipBubble.tipObject.target.stage!= null) tipBubble.tipObject.target.stage.removeEventListener(MouseEvent.MOUSE_UP, onMouseUpStage);
+					}
+					tipBubble.parent.removeChild(tipBubble);
+					// eliminate dragging listeners (only necessary if in the middle of dragging)
+					if(_draggingToolTipItem)
+					{
+						tipBubble.tipObject.target.removeEventListener(MouseEvent.MOUSE_UP, onMouseUp);
+						_draggingToolTipItem = false;
+					}
+					tipBubble = null;
+				}
+				if(!cycleAll) break;
+			}
+		}
+	}
+	/**
+	 * Removes tooltips for all components
+	 */
+	public static function removeAll():void
+	{
+//		trace("ToolTip:removeAll()");
+		// delete pending timers if they exist
+		removeTimer();
+		// remove every item in the list
+		while(itemList.length)
+		{
+			remove(TipObject(itemList[0]).target);
+		}
+	}
+	/**
+	 * Shows the tooltip for the given target (if it exists) without the delay.
+	 */
+	public static function showNow(target:DisplayObject):void
+	{
+		showToolTip(DisplayObject(target), 0, new Point(0, 0));
+	}
+	/**
+	 * Returns a reference to the settings object for the tooltip associated
+	 * with the given target. Used for editing tooltip options.
+	 * Returns null if the given target doesn't have a tooltip associated with it.
+	 */
+	public static function getOptionsForTarget(target:DisplayObject):Object
+	{
+		// find the tipObject associated with the target and return options for it
+		for(var i:int = 0; i < itemList.length; i++)
+		{
+			var item:TipObject = TipObject(itemList[i]);
+			if(item.target == target)
+			{
+				return item.options;
+			}
+		}
+		// target does not have tooltip, return null
+		return null;
+	}
+	/**
+	 * Returns a reference to the style object for the tooltip associated
+	 * with the given target. Used for editing tooltip options.
+	 * Returns null if the given target doesn't have a tooltip associated with it.
+	 */
+	public static function getStyleForTarget(target:DisplayObject):Object
+	{
+		// find the tipObject associated with the target and return style for it
+		for(var i:int = 0; i < itemList.length; i++)
+		{
+			var item:TipObject = TipObject(itemList[i]);
+			if(item.target == target)
+			{
+				return item.style;
+			}
+		}
+		// target does not have tooltip, return null
+		return null;
+	}
+	/**
+	 * @private
+	 * Called when user moves mouse over an object with a tooltip attached to it
+	 */
+	private static function onMouseOver(e:MouseEvent):void
+	{
+		showToolTip(DisplayObject(e.currentTarget), AUTO, new Point(e.stageX, e.stageY));
+	}
+	private static function showToolTip(target:DisplayObject, delay:Number, mousePoint:Point):void
+	{
+//		trace("ToolTip::showToolTip()");
+		/* ignore tooltips if we're dragging */
+		if(_draggingToolTipItem) { return; }
+		/* create new bubble if it does not exist */
+		if(tipBubble == null)
+		{
+			tipBubble = new TipBubble();
+			target.stage.addChild(tipBubble);
+		}
+		else /* remove listeners for old bubble if we're re-assigning it */
+		{
+			removeTimer();
+			tipBubble.tipObject.target.removeEventListener(MouseEvent.ROLL_OUT, onMouseOut);
+		}
+		/* Find matcing TipObject */
+		for(var i:int = 0; i < itemList.length; i++)
+		{
+			var item:TipObject = TipObject(itemList[i]);
+			if(item.target == target)
+			{
+				tipBubble.tipObject = item;
+				tipBubble.mousePoint = mousePoint;
+				removeTimer();
+				bubbleTimer = new Timer((delay == AUTO ? tipBubble.tipObject.options.showDelay:delay), 1);
+				bubbleTimer.addEventListener(TimerEvent.TIMER_COMPLETE, onShowTimerComplete, false, 0, true);
+				timerState = SHOW;
+				bubbleTimer.start();
+				item.target.addEventListener(MouseEvent.ROLL_OUT, onMouseOut, false, 0, true);
+				item.target.addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown, false, 0, true);
+				break;
+			}
+		}
+	}
+	/**
+	 * @private
+	 * Called when user moves mouse off an object with a tooltip attached to it
+	 */
+	private static function onMouseOut(e:MouseEvent):void
+	{
+		e.currentTarget.removeEventListener(MouseEvent.ROLL_OUT, onMouseOut);
+		e.currentTarget.removeEventListener(MouseEvent.MOUSE_DOWN, onMouseDown);
+		removeTimer();
+		bubbleTimer = new Timer(tipBubble.tipObject.options.hideDelay, 1);
+		bubbleTimer.addEventListener(TimerEvent.TIMER_COMPLETE, onHideTimerComplete, false, 0, true);
+		timerState = HIDE;
+		bubbleTimer.start();
+	}
+	/**
+	 * Event triggered fucntion. Called when the mouse is pressed (assumes this
+	 * is the beginning of a drag). Disables tooltip until mouse is lifted.
+	 */
+	private static function onMouseDown(e:MouseEvent):void
+	{
+		mouseDownPoint = new Point(e.stageX, e.stageY);
+		e.currentTarget.removeEventListener(MouseEvent.MOUSE_DOWN, onMouseDown);
+		e.currentTarget.addEventListener(MouseEvent.MOUSE_UP, onMouseUp);
+		e.currentTarget.stage.addEventListener(MouseEvent.MOUSE_UP, onMouseUpStage);
+		e.currentTarget.stage.addEventListener(MouseEvent.MOUSE_MOVE, onMouseMove, false, 0, true);
+	}
+	/**
+	 * Event triggered function. Called when the mouse is moved while the mouse
+	 * button is pressed (a drag). Will be considered a drag if mouse is a certain
+	 * distance from the original mouse down point.
+	 */
+	private static function onMouseMove(e:MouseEvent):void
+	{
+		// check current mouse position
+		var currentPoint:Point = new Point(e.stageX, e.stageY);
+		// compare to mouse down position
+		var dist:Number = Math.sqrt(Math.pow(currentPoint.x - mouseDownPoint.x, 2) + Math.pow(currentPoint.y - mouseDownPoint.y, 2));
+		if(dist > 30)
+		{
+			_draggingToolTipItem = true;
+			e.currentTarget.removeEventListener(MouseEvent.ROLL_OUT, onMouseOut);
+			removeTimer();
+			/* check for and deal with stray listener */
+			if(tipBubble == null)
+			{
+				e.currentTarget.stage.removeEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);
+			}
+			else
+			{
+				/* hide the tip bubble */
+				tipBubble.hide();
+			}
+		}
+	}
+	/**
+	 * @private
+	 * Event triggered fucntion. Called when drag ends and mouse IS over target object.
+	 * Removes drag listeners, adds back Roll Over listener, and displays tooltip
+	 */
+	private static function onMouseUp(e:MouseEvent):void
+	{
+		_draggingToolTipItem = false;
+		e.currentTarget.stage.removeEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);
+		e.currentTarget.removeEventListener(MouseEvent.MOUSE_UP, onMouseUp);
+		e.currentTarget.stage.removeEventListener(MouseEvent.MOUSE_UP, onMouseUpStage);
+		if(!_draggingToolTipItem) // wasn't dragging
+		{
+			e.currentTarget.addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown, false, 0, true);
+		}
+		else // was dragging
+		{
+			e.currentTarget.addEventListener(MouseEvent.ROLL_OVER, onMouseOver, false, 0, true);
+			// Display tooltip again if we're still hovering at the end of our drag
+			onMouseOver(e);
+		}
+	}
+	/**
+	 * @private
+	 * Event triggered function. Called when drag ends and mouse is not over target object
+	 * Removes drag listeners, and adds back Roll Over listener
+	 */
+	private static function onMouseUpStage(e:MouseEvent):void
+	{
+		var stage:EventDispatcher = EventDispatcher(e.currentTarget);
+		_draggingToolTipItem = false;
+		stage.removeEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);
+		if(tipBubble == null) return;
+		tipBubble.tipObject.target.removeEventListener(MouseEvent.MOUSE_UP, onMouseUp);
+		stage.removeEventListener(MouseEvent.MOUSE_UP, onMouseUpStage);
+//		trace("ToolTip:onDragEndStage");
+		if(!_draggingToolTipItem)
+		{
+			e.currentTarget.addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown, false, 0, true);
+		}
+	}
+	/**
+	 * @private
+	 * Deletes and dereferences any timer that might be in existence as well as its listeners
+	 */
+	private static function removeTimer():void
+	{
+		if(bubbleTimer != null)
+		{
+			// Make best attempt to hide old tip ubble
+			if(tipBubble != null)
+			{
+				tipBubble.hide();
+			}
+			switch(timerState)
+			{
+				case SHOW: // waiting for timer to show bubble
+					bubbleTimer.removeEventListener(TimerEvent.TIMER_COMPLETE, onShowTimerComplete);
+					break;
+				case HIDE:
+					bubbleTimer.removeEventListener(TimerEvent.TIMER_COMPLETE, onHideTimerComplete);
+					break;
+			}
+			bubbleTimer.stop();
+			bubbleTimer = null;
+			timerState = INACTIVE;
+		}
+	}
+	/**
+	 * @private
+	 * Called when showDelay has expired and bubble needs to be shown.
+	 * Shows the tooltip.
+	 */
+	private static function onShowTimerComplete(e:Event):void
+	{
+		bubbleTimer.removeEventListener(TimerEvent.TIMER_COMPLETE, onShowTimerComplete);
+		bubbleTimer = null;
+		tipBubble.show();
+		timerState = INACTIVE;
+	}
+	/**
+	 * @private
+	 * Called when hideDelay has expired and bubble needs to be hidden.
+	 * Hides the tooltip.
+	 */
+	private static function onHideTimerComplete(e:Event):void
+	{
+		bubbleTimer.removeEventListener(TimerEvent.TIMER_COMPLETE, onHideTimerComplete);
+		bubbleTimer = null;
+		tipBubble.hide();
+		timerState = INACTIVE;
+	}
+}/* End Class */
+}/* End Package */
+///////////////////////////////////////////////////////////////////////////////
+//
+// BEGIN INTERNAL CLASSES
+//
+///////////////////////////////////////////////////////////////////////////////
+import com.gskinner.motion.GTween;
+import flash.display.CapsStyle;
+import flash.display.DisplayObject;
+import flash.display.JointStyle;
+import flash.display.Sprite;
+import flash.events.MouseEvent;
+import flash.geom.Point;
+import flash.geom.Rectangle;
+import flash.text.TextField;
+import flash.text.TextFieldAutoSize;
+import flash.text.TextFormat;
+/**
+ * TipBubble
+ * The sprite that shows up on the screen with the tip in it
+ */
+class TipBubble extends Sprite
+{
+	private const MARGIN_ANCHOR:Number = 20;
+	private const MOUSE_WIDTH:Number = 16;
+	private const MOUSE_HEIGHT:Number = 16;
+	private const TIP_WIDTH:Number = 24;
+	private const TIP_HEIGHT:Number = 16;
+	public var tipObject:TipObject;
+	public var mousePoint:Point;
+	private var tf:TextField;
+	private var fadeTween:GTween;
+	public function TipBubble()
+	{
+		this.mouseEnabled = false;
+		tf = new TextField();
+		tf.mouseEnabled = false;
+		tf.selectable = false;
+		tf.background = false;
+		tf.border = false;
+		tf.wordWrap = true;
+		addChild(tf);
+	}
+	public function show(fromMouseMove:Boolean = false):void
+	{
+		// Adjust position to account for padding
+		tf.x = tipObject.style.padding;
+		tf.y = tipObject.style.padding;
+		// Call the show callback function
+		if(tipObject.options.showCallback != null)
+		{
+			tipObject.options.showCallback.apply();
+		}
+		/* Update the Text */
+		if(tipObject.style.htmlText) tf.htmlText = tipObject.text;
+		else tf.text = tipObject.text;
+		/* Update the Options */
+		tf.width = tipObject.options.width;
+		tf.autoSize = TextFieldAutoSize.CENTER;
+		tf.setTextFormat(new TextFormat(tipObject.style.fontFamily, tipObject.style.fontSize, tipObject.style.textColor, tipObject.style.bold, tipObject.style.italic, false, null, null, tipObject.style.textAlign));
+		/* Calculate Width/Height of Box */
+		var w:Number = tf.width + tipObject.style.borderThickness * 2 + tipObject.style.padding * 2;
+		var h:Number = tf.height + tipObject.style.padding * 2;
+		graphics.clear();
+		/* Find The Anchor */
+		var anchorPoint:Point;
+		var direction:String;
+		var anchorObject:Rectangle;
+		if(tipObject.options.anchor == "mouse")
+		{
+			anchorObject = new Rectangle(mousePoint.x - MOUSE_WIDTH / 2, mousePoint.y - MOUSE_HEIGHT / 2, MOUSE_WIDTH, MOUSE_HEIGHT);
+			if(!fromMouseMove) stage.addEventListener(MouseEvent.MOUSE_MOVE, onMouseMove, false, 0, true);
+		}
+		else
+		{
+			var objPoint:Point = tipObject.target.parent.localToGlobal(new Point(tipObject.target.x, tipObject.target.y));
+			anchorObject = new Rectangle(objPoint.x, objPoint.y, tipObject.target.getBounds(tipObject.target).width, tipObject.target.getBounds(tipObject.target).height);
+		}
+		/* Determine Direction */
+		// if direction is set to auto, try to find the right direction that fits based on trial error sequence
+		// if there is no direction that fits perfectly, try to find the direction that fits best
+		if(tipObject.options.direction == null || tipObject.options.direction == "auto" || tipObject.options.direction == "")
+		{
+			var secondary:String = null;
+			var secondaryDiff:Number = -9999;
+			var leftDiff:Number = anchorObject.x - w - MARGIN_ANCHOR;
+			var topDiff:Number = anchorObject.y - h - MARGIN_ANCHOR;
+			var bottomDiff:Number = stage.stageHeight - (anchorObject.y + anchorObject.height + MARGIN_ANCHOR + h);
+			var rightDiff:Number = stage.stageWidth - (anchorObject.x + anchorObject.width + MARGIN_ANCHOR + w);
+			var centerHDiff:Number = Math.min(anchorObject.x + anchorObject.width / 2 - w / 2, stage.stageWidth - (anchorObject.x + anchorObject.width / 2 + w / 2));
+			var centerVDiff:Number = Math.min(anchorObject.y + anchorObject.height / 2 - h / 2, stage.stageHeight - (anchorObject.y + anchorObject.height / 2 + h / 2))
+			// try up
+			if(direction == null || tipObject.options.directionPriority.toLowerCase() == "up")
+			{
+				if(topDiff >= 0)
+				{
+					if(centerHDiff > 0)
+					{
+						direction = "up";
+					}
+					else if(centerHDiff > secondaryDiff)
+					{
+						secondary = "up";
+						secondaryDiff = centerHDiff;
+					}
+				}
+				else if(topDiff > secondaryDiff)
+				{
+					secondary = "up";
+					secondaryDiff = topDiff;
+				}
+			}
+			// try down
+			if(direction == null || tipObject.options.directionPriority.toLowerCase() == "down")
+			{
+				if(bottomDiff >= 0)
+				{
+					if(centerHDiff > 0)
+					{
+						direction = "down";
+					}
+					else if(centerHDiff > secondaryDiff)
+					{
+						secondary = "down";
+						secondaryDiff = centerHDiff;
+					}
+				}
+				else if(bottomDiff > secondaryDiff)
+				{
+					secondary = "down";
+					secondaryDiff = bottomDiff;
+				}
+			}
+			// try left
+			if(direction == null || tipObject.options.directionPriority.toLowerCase() == "left")
+			{
+				if(leftDiff >= 0)
+				{
+					if(centerVDiff > 0)
+					{
+						direction = "left";
+					}
+					else if(centerVDiff > secondaryDiff)
+					{
+						secondary = "left";
+						secondaryDiff = centerVDiff;
+					}
+				}
+				else if(leftDiff > secondaryDiff)
+				{
+					secondary = "left";
+					secondaryDiff = leftDiff;
+				}
+			}
+			// try right
+			if(direction == null || tipObject.options.directionPriority.toLowerCase() == "right")
+			{
+				if(rightDiff >= 0)
+				{
+					if(centerVDiff > 0)
+					{
+						direction = "right";
+					}
+					else if(centerVDiff > secondaryDiff)
+					{
+						secondary = "right";
+						secondaryDiff = centerVDiff;
+					}
+				}
+				else if(rightDiff > secondaryDiff)
+				{
+					secondary = "right";
+					secondaryDiff = rightDiff;
+				}
+			}
+			/* try diagonals (if we don't have a perfect fit yet) */
+			// try top-left
+			if(direction == null || tipObject.options.directionPriority.toLowerCase() == "top-left")
+			{
+				if(topDiff >= 0 && leftDiff>= 0)
+				{
+					direction = "top-left";
+				}
+				else if(Math.min(topDiff, leftDiff) > secondaryDiff)
+				{
+					secondary = "top-left";
+					secondaryDiff = Math.min(topDiff, leftDiff);
+				}
+			}
+			// try top-right
+			if(direction == null || tipObject.options.directionPriority.toLowerCase() == "top-right")
+			{
+				if(direction == null && topDiff >= 0 && rightDiff >= 0)
+				{
+					direction = "top-right";
+				}
+				else if(Math.min(topDiff, rightDiff) > secondaryDiff)
+				{
+					secondary = "top-right";
+					secondaryDiff = Math.min(topDiff, rightDiff);
+				}
+			}
+			// try bottom-right
+			if(direction == null || tipObject.options.directionPriority.toLowerCase() == "bottom-right")
+			{
+				if(direction == null && bottomDiff >= 0 && rightDiff >= 0)
+				{
+					direction = "bottom-right";
+				}
+				else if(Math.min(bottomDiff, rightDiff) > secondaryDiff)
+				{
+					secondary = "bottom-right";
+					secondaryDiff = Math.min(bottomDiff, rightDiff);
+				}
+			}
+			// try bottom-left
+			if(direction == null || tipObject.options.directionPriority.toLowerCase() == "bottom-left")
+			{
+				if(direction == null && bottomDiff >= 0 && leftDiff >= 0)
+				{
+					direction = "bottom-left";
+				}
+				else if(Math.min(bottomDiff, leftDiff) > secondaryDiff)
+				{
+					secondary = "bottom-left";
+					secondaryDiff = Math.min(bottomDiff, leftDiff);
+				}
+			}
+			// if there is no perfect fit, try to get the "best" possible fit fit from secondary
+			if(direction == null)
+			{
+				if(secondary != null)
+				{
+					direction = secondary;
+				}
+				// resort to center if no other fits work (should never get here)
+				else
+				{
+					direction = "center";
+				}
+			}
+		}
+		else
+		{
+			direction = tipObject.options.direction;
+		}
+		/* Draw according to direction */
+		var tipW2:Number = Math.sqrt(Math.pow(TIP_WIDTH, 2)/2); // width/height of tip at an angle (pythagorean's theorem)
+		var tipAngle:Number; // For Diagonal Bubbles, the direction the tip will be pointing
+		var tipPointX:Number; // For Diagonal Bubbles, the x position of the end-point of the tip
+		var tipPointY:Number; // For Diagonal Bubbles, the y position of the end-point of the tip
+		graphics.beginFill(tipObject.style.backgroundColor, tipObject.style.backgroundAlpha);
+		graphics.lineStyle(tipObject.style.borderThickness, tipObject.style.borderColor, tipObject.style.borderAlpha, true);
+		switch(direction)
+		{
+			case "up":
+				this.x = anchorObject.x + anchorObject.width / 2 - w / 2;
+				this.y = anchorObject.y - MARGIN_ANCHOR - h;
+				// tip must point down
+				graphics.moveTo(tipObject.style.borderRadius, 0);
+				graphics.lineTo(w - tipObject.style.borderRadius, 0);
+				graphics.curveTo(w, 0, w, tipObject.style.borderRadius);
+				graphics.lineTo(w, h - tipObject.style.borderRadius);
+				graphics.curveTo(w, h, w - tipObject.style.borderRadius, h);
+				graphics.lineTo(w / 2 + TIP_WIDTH / 2, h);
+				graphics.lineTo(w / 2, h + TIP_HEIGHT);
+				graphics.lineTo(w / 2 - TIP_WIDTH / 2, h);
+				graphics.lineTo(tipObject.style.borderRadius, h);
+				graphics.curveTo(0, h, 0, h - tipObject.style.borderRadius);
+				graphics.lineTo(0, tipObject.style.borderRadius);
+				graphics.curveTo(0, 0, tipObject.style.borderRadius, 0);
+				graphics.endFill();
+				break;
+			case "down":
+				this.x = anchorObject.x + anchorObject.width / 2 - w / 2;
+				this.y = anchorObject.y + anchorObject.height + MARGIN_ANCHOR;
+				// tip must point up
+				graphics.moveTo(tipObject.style.borderRadius, 0);
+				graphics.lineTo(w / 2 - TIP_WIDTH / 2, 0);
+				graphics.lineTo(w / 2, -TIP_HEIGHT);
+				graphics.lineTo(w / 2 + TIP_WIDTH / 2, 0);
+				graphics.lineTo(w - tipObject.style.borderRadius, 0);
+				graphics.curveTo(w, 0, w, tipObject.style.borderRadius);
+				graphics.lineTo(w, h - tipObject.style.borderRadius);
+				graphics.curveTo(w, h, w - tipObject.style.borderRadius, h);
+				graphics.lineTo(tipObject.style.borderRadius, h);
+				graphics.curveTo(0, h, 0, h - tipObject.style.borderRadius);
+				graphics.lineTo(0, tipObject.style.borderRadius);
+				graphics.curveTo(0, 0, tipObject.style.borderRadius, 0);
+				graphics.endFill();
+				break;
+			case "left":
+				this.x = anchorObject.x - MARGIN_ANCHOR - w;
+				this.y = anchorObject.y + anchorObject.height / 2 - h / 2;
+				// tip must point right
+				graphics.moveTo(tipObject.style.borderRadius, 0);
+				graphics.lineTo(w - tipObject.style.borderRadius, 0);
+				graphics.curveTo(w, 0, w, tipObject.style.borderRadius);
+				graphics.lineTo(w, h / 2 - TIP_WIDTH / 2);
+				graphics.lineTo(w + TIP_HEIGHT, h / 2);
+				graphics.lineTo(w, h / 2 + TIP_WIDTH / 2);
+				graphics.lineTo(w, h - tipObject.style.borderRadius);
+				graphics.curveTo(w, h, w - tipObject.style.borderRadius, h);
+				graphics.lineTo(tipObject.style.borderRadius, h);
+				graphics.curveTo(0, h, 0, h - tipObject.style.borderRadius);
+				graphics.lineTo(0, tipObject.style.borderRadius);
+				graphics.curveTo(0, 0, tipObject.style.borderRadius, 0);
+				graphics.endFill();
+				break;
+			case "right":
+				this.x = anchorObject.x + anchorObject.width + MARGIN_ANCHOR;
+				this.y = anchorObject.y + anchorObject.height / 2 - h / 2;
+				// tip must point left
+				graphics.moveTo(tipObject.style.borderRadius, 0);
+				graphics.lineTo(w - tipObject.style.borderRadius, 0);
+				graphics.curveTo(w, 0, w, tipObject.style.borderRadius);
+				graphics.lineTo(w, h - tipObject.style.borderRadius);
+				graphics.curveTo(w, h, w - tipObject.style.borderRadius, h);
+				graphics.lineTo(tipObject.style.borderRadius, h);
+				graphics.curveTo(0, h, 0, h - tipObject.style.borderRadius);
+				graphics.lineTo(0, h / 2 + TIP_WIDTH / 2);
+				graphics.lineTo(-TIP_HEIGHT, h / 2);
+				graphics.lineTo(0, h / 2 - TIP_WIDTH / 2);
+				graphics.lineTo(0, tipObject.style.borderRadius);
+				graphics.curveTo(0, 0, tipObject.style.borderRadius, 0);
+				graphics.endFill();
+				break;
+			case "top-left":
+				tipAngle = 7 * Math.PI / 4;
+				this.x = anchorObject.x - w - MARGIN_ANCHOR / 2 * Math.cos(tipAngle + Math.PI);
+				this.y = anchorObject.y - h - MARGIN_ANCHOR / 2 * (-Math.sin(tipAngle + Math.PI));
+				// tip must point bottom right
+				tipPointX = w + TIP_HEIGHT / 2 * Math.cos(tipAngle);
+				tipPointY = h + TIP_HEIGHT / 2 * (-Math.sin(tipAngle));
+				graphics.moveTo(tipObject.style.borderRadius, 0);
+				graphics.lineTo(w - tipObject.style.borderRadius, 0);
+				graphics.curveTo(w, 0, w, tipObject.style.borderRadius);
+				graphics.lineTo(w, h - tipW2);
+				graphics.lineTo(tipPointX, tipPointY);
+				graphics.lineTo(w - tipW2, h);
+				graphics.lineTo(tipObject.style.borderRadius, h);
+				graphics.curveTo(0, h, 0, h - tipObject.style.borderRadius);
+				graphics.lineTo(0, tipObject.style.borderRadius);
+				graphics.curveTo(0, 0, tipObject.style.borderRadius, 0);
+				graphics.endFill();
+				break;
+			case "top-right":
+				tipAngle = 5 * Math.PI / 4;
+				this.x = anchorObject.x + anchorObject.width + MARGIN_ANCHOR / 2 * Math.cos(tipAngle + Math.PI);
+				this.y = anchorObject.y - h + MARGIN_ANCHOR / 2 * (-Math.sin(tipAngle + Math.PI));
+				// tip must point bottom left
+				tipPointX = TIP_HEIGHT / 2 * Math.cos(tipAngle);
+				tipPointY = h + TIP_HEIGHT / 2 * (-Math.sin(tipAngle));
+				graphics.moveTo(tipObject.style.borderRadius, 0);
+				graphics.lineTo(w - tipObject.style.borderRadius, 0);
+				graphics.curveTo(w, 0, w, tipObject.style.borderRadius);
+				graphics.lineTo(w, h - tipObject.style.borderRadius);
+				graphics.curveTo(w, h, w - tipObject.style.borderRadius, h);
+				graphics.lineTo(tipW2, h);
+				graphics.lineTo(tipPointX, tipPointY);
+				graphics.lineTo(0, h - tipW2);
+				graphics.lineTo(0, tipObject.style.borderRadius);
+				graphics.curveTo(0, 0, tipObject.style.borderRadius, 0);
+				graphics.endFill();
+				break;
+			case "bottom-left":
+				tipAngle = Math.PI / 4
+				this.x = anchorObject.x - w + MARGIN_ANCHOR / 2 * Math.cos(tipAngle + Math.PI);
+				this.y = anchorObject.y + anchorObject.height + MARGIN_ANCHOR / 2 * (-Math.sin(tipAngle + Math.PI));
+				// tip must point top right
+				tipPointX = w + TIP_HEIGHT / 2 * Math.cos(tipAngle);
+				tipPointY = TIP_HEIGHT / 2 * (-Math.sin(tipAngle));
+				graphics.beginFill(tipObject.style.backgroundColor, tipObject.style.backgroundAlpha);
+				graphics.lineStyle(tipObject.style.borderThickness, tipObject.style.borderColor, tipObject.style.borderAlpha, true);
+				graphics.moveTo(tipObject.style.borderRadius, 0);
+				graphics.lineTo(w - tipW2, 0);
+				graphics.lineTo(tipPointX, tipPointY);
+				graphics.lineTo(w, tipW2);
+				graphics.lineTo(w, y - tipObject.style.borderRadius);
+				graphics.curveTo(w, h, w - tipObject.style.borderRadius, h);
+				graphics.lineTo(tipObject.style.borderRadius, h);
+				graphics.curveTo(0, h, 0, h - tipObject.style.borderRadius);
+				graphics.lineTo(0, tipObject.style.borderRadius);
+				graphics.curveTo(0, 0, tipObject.style.borderRadius, 0);
+				graphics.endFill();
+				break;
+			case "bottom-right":
+				tipAngle = 3 * Math.PI / 4;
+				this.x = anchorObject.x  + anchorObject.width + MARGIN_ANCHOR / 2 * Math.cos(tipAngle + Math.PI);
+				this.y = anchorObject.y + anchorObject.height + MARGIN_ANCHOR / 2 * (-Math.sin(tipAngle + Math.PI));
+				// tip must point top-left
+				tipAngle = 3 * Math.PI / 4;
+				tipPointX = TIP_HEIGHT / 2 * Math.cos(tipAngle);
+				tipPointY = - TIP_HEIGHT / 2 * Math.sin(tipAngle);
+				graphics.moveTo(tipW2, 0);
+				graphics.lineTo(w - tipObject.style.borderRadius, 0);
+				graphics.curveTo(w, 0, w, tipObject.style.borderRadius);
+				graphics.lineTo(w, h - tipObject.style.borderRadius);
+				graphics.curveTo(w, h, w - tipObject.style.borderRadius, h);
+				graphics.lineTo(tipObject.style.borderRadius, h);
+				graphics.curveTo(0, h, 0, h - tipObject.style.borderRadius);
+				graphics.lineTo(0, tipW2);
+				graphics.lineTo(tipPointX, tipPointY);
+				graphics.lineTo(tipW2, 0);
+				graphics.endFill();
+				var t:DisplayObject = tipObject.target;
+//				trace(t.width, t.height, " || ", t.getBounds(t).width, t.getBounds(t).height);
+				break;
+			default: // center
+				this.x = anchorObject.x + anchorObject.width / 2 - w / 2;
+				this.y = anchorObject.y + anchorObject.height / 2 - h / 2;
+				// no tip pointer
+				graphics.drawRoundRect(0, 0, w, h, tipObject.style.borderRadius);
+				graphics.endFill();
+				break;
+		}
+		this.x += tipObject.options.xOffset;
+		this.y += tipObject.options.yOffset;
+		if(!fromMouseMove && tipObject.options.fadeTime != 0)
+		{
+			resetFadeTween();
+			this.alpha = 0;
+			fadeTween = new GTween(this, tipObject.options.fadeTime / 1000, {alpha: 1});
+		}
+		this.visible = true;
+	}
+	public function hide(force:Boolean = false):void
+	{
+		// Call the hide bubble callback
+		if(tipObject.options.hideCallback != null)
+		{
+			tipObject.options.hideCallback.apply();
+		}
+		// remove the listener
+		if(tipObject.options.anchor == "mouse")
+		{
+			stage.removeEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);
+		}
+		if(!force && tipObject.options.fadeTime != 0)
+		{
+			resetFadeTween();
+			fadeTween = new GTween(this, tipObject.options.fadeTime / 1000, {alpha: 0});
+			var instance:TipBubble = this;
+			fadeTween.onComplete = function():void { instance.visible = false; }
+		}
+		else
+		{
+			this.visible = false;
+		}
+	}
+	public function onMouseMove(e:MouseEvent):void
+	{
+		mousePoint = new Point(e.stageX, e.stageY);
+		show(true);
+	}
+	public function resetFadeTween():void
+	{
+		if(fadeTween != null)
+		{
+			fadeTween.end();
+			fadeTween.onComplete = null;
+			fadeTween = null;
+		}
+	}
+}
+/**
+ * TipObject
+ * Contains the information used in TipBubble
+ */
+class TipObject
+{
+	public var target:DisplayObject;
+	public var text:String;
+	public var options:Object;
+	public var style:Object;
+	public function TipObject(target:DisplayObject, text:String, options:Object = null, style:Object = null)
+	{
+		this.target = target;
+		this.text = text == null? "" : text;
+		/*
+		 * Remember to Change Documentation of ToolTip.add() if you change any default values here
+		 */
+		// set default options
+		this.options = options == null ? new Object() : options;
+		if(this.options.fadeTime == null) { this.options.fadeTime = 150; }
+		if(this.options.width == null) { this.options.width = 200; }
+		if(this.options.xOffset == null) { this.options.xOffset = 0; }
+		if(this.options.yOffset == null) { this.options.yOffset = 0; }
+		if(this.options.showDelay == null) { this.options.showDelay = 300; }
+		if(this.options.hideDelay == null) { this.options.hideDelay = 200; }
+		if(this.options.directionPriority == null) { this.options.directionPriority = "up"; }
+		/*
+		* Remember to Change Documentation of ToolTip.add() if you change any default values here
+		*/
+		// set default styles
+		this.style = style == null ? new Object() : style;
+		if(this.style.textColor == null) { this.style.textColor = 0xffffff; }
+		if(this.style.htmlText == null) { this.style.htmlText = false; }
+		if(this.style.fontFamily == null) { this.style.fontFamily = 'Verdana'; }
+		if(this.style.fontSize == null) { this.style.fontSize = 12; }
+		if(this.style.fontStyle == null) { this.style.boldFont = false; this.style.italicFont = false; }
+		else
+		{
+			switch(this.style.fontStyle)
+			{
+				case 'bold':
+					this.style.bold = true;
+					break;
+				case 'italic':
+					this.style.italic = true;
+					break;
+				case 'bold-italic':
+					this.style.bold = true;
+					this.style.italic = true;
+					break;
+				default:
+					this.style.bold = false;
+					this.style.italic = false;
+			}
+		}
+		if(this.style.textAlign == null) { this.style.textAlign = "center"; }
+		if(this.style.backgroundColor == null) { this.style.backgroundColor = 0x232323; }
+		if(this.style.backgroundAlpha == null) { this.style.backgroundAlpha = 0.95; }
+		if(this.style.borderThickness == null) { this.style.borderThickness = 5; }
+		if(this.style.borderColor == null) { this.style.borderColor = 0xffffff; }
+		if(this.style.borderAlpha == null) { this.style.borderAlpha = 0.3; }
+		if(this.style.borderRadius == null) { this.style.borderRadius = 4; }
+		if(this.style.padding == null) { this.style.padding = 5; }
+		/*
+		* Remember to Change Documentation of ToolTip.add() if you change any default values here
+		*/
+	}
+}
+/**
+ * SingletonEnforcer
+ * Empty class used to enforce Singleton.
+ */
+class SingletonEnforcer {}