mako 0.0.0

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

@@ -0,0 +1,98 @@
+/* See the file "LICENSE.txt" for the full license governing this code. */
+package nm.ui {
+	import flash.display.MovieClip;
+	import flash.events.Event;
+	public class Component extends MovieClip
+	{
+		protected var _autoRedraw:Boolean;
+		protected var _height:Number
+		protected var _width:Number
+		protected var _isValid:Boolean;
+		private var _style:Object
+		public function Component(autoRedraw:Boolean = false, width:Number = 0, height:Number = 0)
+		{
+			_width = width;
+			_height = height;
+			_style = new Object();
+			_isValid = false;
+			this._autoRedraw = autoRedraw;
+			styleDefaults();
+			addEventListener(Event.ADDED_TO_STAGE, onAddedToStage, false, 0, true);
+		}
+		protected function onAddedToStage(event:Event):void
+		{
+			removeEventListener(Event.ADDED_TO_STAGE, onAddedToStage);
+			addEventListener(Event.REMOVED_FROM_STAGE, onRemovedFromStage, false, 0, true);
+			if(!_isValid) draw();
+		}
+		protected function onRemovedFromStage(event:Event):void
+		{
+			removeEventListener(Event.REMOVED_FROM_STAGE, onRemovedFromStage);
+			addEventListener(Event.ADDED_TO_STAGE, onAddedToStage, false, 0, true);
+		}
+		public function setStyle(propName:String, val:*):*
+		{
+			_style[propName] = val;
+			if(_autoRedraw && stage != null){ redraw();}
+			return val;
+		}
+		public function getStyle(propName:String):*
+		{
+			return _style[propName];
+		}
+		public function move(x:Number, y:Number):void
+		{
+			this.x = x;
+			this.y = y;
+		}
+		public function destroy():void
+		{
+				removeEventListener(Event.REMOVED_FROM_STAGE, onRemovedFromStage);
+				removeEventListener(Event.ADDED_TO_STAGE, onAddedToStage);
+				dispatchEvent(new Event('destroy'));
+		}
+		protected function styleDefaults():void{}
+		public function draw():void{ _isValid = true }
+		public function redraw():void{}
+		public override function set width(val:Number):void
+		{
+			_width = val;
+			if(_autoRedraw){ redraw();}
+		}
+		public override function get width():Number
+		{
+			return _width
+		}
+		public function get actualWidth():Number{ return super.width; }
+		public function get actualHeight():Number{ return super.height; }
+		public override function set height(val:Number):void
+		{
+			_height = val;
+			if(_autoRedraw){ redraw();}
+		}
+		public override function get height():Number
+		{
+			return _height;
+		}
+		public function set style(newStyle:Object): void
+		{
+			for(var i:String in newStyle) _style[i] = newStyle[i];
+		}
+		public function get style():Object
+		{
+			return _style;
+		}
+		public function invalidate():void
+		{
+			_isValid = false;
+		}
+		public function validate():void
+		{
+			_isValid = true;
+		}
+		public function isValid():Boolean
+		{
+			return _isValid;
+		}
+	}
+}

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

@@ -0,0 +1,38 @@
+/* See the file "LICENSE.txt" for the full license governing this code. */
+package nm.ui{
+	import nm.ui.Component
+	//import nm.draw.shapes.Rect
+	public class ContentBlocker extends Component{
+		public var color:Number
+		//public var alpha:Number
+		private var _blocking:Boolean
+		public function ContentBlocker(width:Number, height:Number, color:Number, alpha:Number){
+			super(true, width, height);
+			this.color = color;
+			this.alpha = alpha;
+			blocking = true;
+			draw()
+		}
+		public override function draw():void{
+			redraw();
+		}
+		public override function redraw():void{
+			this.graphics.clear()
+			//Rect.draw(this, 0, 0, width, height, color, alpha);
+			graphics.beginFill(color, alpha);
+			graphics.drawRect(0, 0, width, height);
+		}
+		public function set blocking(val:Boolean):void
+		{
+			_blocking = val
+			if(val){
+				//this.onRelease = undefined
+				//this.useHandCursor = false
+			}
+			//else delete this.onRelease
+		}
+		public function get blocking():Boolean{
+			return _blocking
+		}
+	}
+}

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

@@ -0,0 +1,59 @@
+/* See the file "LICENSE.txt" for the full license governing this code. */
+package nm.ui
+{
+	import flash.display.DisplayObject;
+	import flash.events.Event;
+	import mx.core.Application;
+	import mx.core.IFlexDisplayObject;
+	import mx.managers.PopUpManager;
+	public class FlexUIScaler
+	{
+		protected var _scale:Number = 1
+		public function FlexUIScaler()
+		{
+			//Listen for when pop-ups are added via PopUpManager:
+			Application.application.systemManager.addEventListener(Event.ADDED, onPopupAdded);
+		}
+		protected function onScaleChange():void
+		{
+			Application.application.scaleX = Application.application.scaleY = _scale;
+			// Resize Popups
+			for(var i:int = 0; i < Application.application.systemManager.popUpChildren.numChildren; i++)
+			{
+				var p:DisplayObject = DisplayObject(Application.application.systemManager.popUpChildren.getChildAt(i));
+				if(p is IFlexDisplayObject)
+				{
+					p.scaleX = p.scaleY = _scale;
+					PopUpManager.centerPopUp(IFlexDisplayObject(p));
+				}
+			}
+			//Force the stage to send a resize event which will fix the modal window background.
+			//Without this, scaling the windows below 100% will result in a modal background that doesn't cover the entire application.
+			Application.application.stage.dispatchEvent(new Event(Event.RESIZE));
+		}
+		//Called when children are added to the systemManager.  We look for any pop-ups added via the PopUpManager and scale those.
+		//We know we've found a pop-up when it is in the popUpChildren list and its parent is the systemManager.
+		//Note that this will only find pop-ups that are placed on the PopUpManagerChildList.POPUP child list.
+		protected function onPopupAdded(event:Event):void
+		{
+			var d:DisplayObject = DisplayObject(event.target.parent);
+			if(Application.application.systemManager.popUpChildren.contains(d) && d.parent == Application.application.systemManager)
+			{
+				d.scaleX = d.scaleY = _scale;
+			}
+		}
+		public function set scale(newScale:Number):void
+		{
+//			trace(_scale)
+			if(_scale != newScale && newScale > 0)
+			{
+				_scale = newScale
+				onScaleChange();
+			}
+		}
+		public function get scale():Number
+		{
+			return _scale;
+		}
+	}
+}

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

@@ -0,0 +1,191 @@
+/* See the file "LICENSE.txt" for the full license governing this code. */
+package nm.ui{
+import flash.events.FocusEvent;
+import flash.text.TextField;
+import flash.text.TextFormat;
+public class FormInput extends Component{
+	private var __name:String;
+	private var _pass:Boolean;
+	private var _labelTF:TextField;
+	private var _inputTF:TextField;
+	private var _warnTF:TextField;
+	private var _inputTFormat:TextFormat;
+	private var _labelTFormat:TextFormat;
+	private var _warnTFormat:TextFormat;
+	private var _mode:Number;
+	private var hasFocus:Boolean = false;
+	public function FormInput(name:String, width:Number, password:Boolean=false, inputTextFormat:TextFormat=null, labelTextFormat:TextFormat=null, warnTextFormat:TextFormat=null){
+		super(false);
+		__name = name;
+		_width = width;
+		_pass = password == true // default to false
+		//if(inputTextFormat is TextFormat) setStyle('inputFormat', inputTextFormat);
+		//if(labelTextFormat is TextFormat) setStyle('labelFormat', labelTextFormat);
+		//if(warnTextFormat is TextFormat) setStyle('warnFormat', warnTextFormat);
+		_inputTFormat = getStyle('inputFormat')
+		_labelTFormat = getStyle('labelFormat')
+		_warnTFormat = getStyle('warnFormat');
+		_mode = 1
+	}
+	public override function draw():void {
+		super.draw();
+		//throw new Error((__name + "  ERROR-----"), 0);
+		//_labelTF = createTextField('label_tf', 1, 0, 0, 1, 1);
+		_labelTF = new TextField(); addChild(_labelTF);
+		_labelTF.x=0; _labelTF.y=0; _labelTF.height=1; _labelTF.width=1;
+		//_labelTF.setNewTextFormat(_labelTFormat);
+		_labelTF.text = __name;
+		_labelTF.autoSize = "left"
+		_labelTF.selectable = false
+		_labelTF.setTextFormat(_labelTFormat);
+		_inputTF = new TextField(); addChild(_inputTF);
+		_inputTF.x=0; _inputTF.y=_pass? 1:0; _inputTF.height=20;  width - _inputTF.width;
+		//_inputTF.setNewTextFormat(_inputTFormat);
+		_inputTF.setTextFormat(_inputTFormat);
+		//_inputTF.tabIndex = 1
+		//_inputTF.addListener(this);
+		_inputTF.type = 'input';
+		_inputTF.displayAsPassword = _pass;
+		_inputTF.addEventListener(FocusEvent.FOCUS_IN, handleFocus);
+		_inputTF.addEventListener(FocusEvent.FOCUS_OUT, handleFocus);
+		//EventTF.init(_inputTF);
+		//_inputTF.addEventListener('ALL', this, 'onTFEvent');
+		_warnTF = new TextField(); addChild(_warnTF);
+		_warnTF.x = 0; _warnTF.y = 0; _warnTF.width = width; _warnTF.height = 20;
+		_warnTF.setTextFormat(_warnTFormat);
+		_warnTF.selectable = false;
+		redraw();
+	}
+	public function setTabIndex(n:Number):void
+	{
+		_inputTF.tabIndex = n;
+	}
+	private function handleFocus(e:FocusEvent):void{
+		var tmpMode:Number = _mode;
+		switch(e.type){
+			case FocusEvent.FOCUS_IN:
+				hasFocus = true;
+				if(_mode != 3) _mode = 2;
+				break;
+			case FocusEvent.FOCUS_OUT:
+				hasFocus = false;
+				if(_mode != 3) _mode = 1;
+				break;
+		}
+		if(tmpMode != _mode) drawbgBox()
+	}
+	/*
+	private function onTFEvent(event:Object){
+		var tmpMode:Number = _mode
+		if(_mode != 3){
+			switch(event.type){
+				case 'setFocus':
+					_mode = 2
+					break;
+				case 'killFocus':
+					_mode = 1
+					break;
+			}
+		}
+		if(tmpMode != _mode) drawbgBox()
+		event.target = this
+		//dispatchEvent(event);
+	}
+	*/
+	public override function redraw():void {
+		drawbgBox()
+		_inputTF.x = _labelTF.width
+		_warnTF.y = _inputTF.height - 2;
+	}
+	public function giveFocus():void {
+		stage.focus = _inputTF;
+		_inputTF.setSelection(0, _inputTF.text.length - 1);
+	}
+	private function drawbgBox():void{
+		graphics.clear();
+		graphics.lineStyle(1, 0, 1);
+		graphics.beginFill(getColorByMode(), 1);
+		graphics.drawRect(0, 0, width, _inputTF.height);
+	}
+	/**
+	* Default function called by the stylealbe constructor to set up default styles
+	*/
+	protected override function styleDefaults():void{
+		setStyle('inputFormat', new TextFormat('Arial', 12, 0x000000));
+		setStyle('labelFormat',  new TextFormat('Arial', 12, 0x999999, true));
+		setStyle('warnFormat', new TextFormat('Arial', 12, 0xF02020, true));
+		setStyle('restColor', 0xEEEEEE)
+		setStyle('activeColor', 0xFFFFFF)
+		setStyle('warnColor', 0xF2E6E1)
+	}
+	private function getColorByMode():Number{
+		switch(_mode){
+			case 1:
+				return getStyle('restColor')
+			case 2:
+				return getStyle('activeColor')
+			case 3:
+				return getStyle('warnColor');
+		}
+		return 0;
+	}
+	public function set warn(text:String):void{
+			if(text == ''){
+				if(hasFocus)_mode = 2;
+				else _mode = 1;
+				text = "";
+				//_mode =  Selection.getFocus() == String(_inputTF) ? 2 : 1
+			}
+			else{
+				_mode = 3
+			}
+			drawbgBox();
+			_warnTF.text = text;
+			_warnTF.setTextFormat(_warnTFormat);
+	}
+	public function get warn():String{
+		return _warnTF.text
+	}
+	public function set password(val:Boolean):void{
+		_inputTF.displayAsPassword = _pass = val;
+	}
+	public function get password():Boolean{
+		return _pass;
+	}
+	public function set label(val:String):void{
+		_labelTF.text = val
+		_labelTF.setTextFormat(_labelTFormat);
+		redraw();
+	}
+	public function get label():String{
+		return _labelTF.text
+	}
+	public function set _enabled(val:Boolean):void{
+		//_inputTF.type = val == true ? 'input' : 'dynamic'; sorry, had to get rid of your fancy ternary operation
+		if (val == true) {
+			_inputTF.type = 'input';
+			_inputTF.selectable = true;
+		}
+		else {
+			_inputTF.type = 'dynamic';
+			_inputTF.selectable = false;
+		}
+	}
+	public function get _enabled():Boolean{
+		return _inputTF.type == 'input';
+	}
+	public function set text(val:String):void{
+		_inputTF.text = val
+		_inputTF.setTextFormat(_inputTFormat);
+	}
+	public function get text():String{
+		return _inputTF.text
+	}
+	public function get input():TextField{
+		return _inputTF
+	}
+	public function get valid():Boolean{
+		return _warnTF.text == '';
+	}
+}
+}

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

@@ -0,0 +1,305 @@
+/* See the file "LICENSE.txt" for the full license governing this code. */
+package nm.ui
+{
+import flash.display.MovieClip;
+import flash.events.MouseEvent;
+import flash.geom.Point;
+import flash.geom.Rectangle;
+import gs.TweenLite;
+/**
+* ...
+* @author Luis Estrada
+*/
+public class GrabZoomClip extends MovieClip
+{
+	protected static const TRACE_STRING:String = "GrabZoomClip";
+	//--------------------------------------------------------------------------
+	//
+	//  Variables
+	//
+	//--------------------------------------------------------------------------
+	private var _width:int;
+	private var _height:int;
+	private var _borderWidth:int;
+	private var _bgAlpha:Number;
+	private var _borderColor:Number = 0;
+	private var _aniStrength:int = 10;
+	private var _minZoom:Number = 0.2;
+	private var _maxZoom:Number = Number.MAX_VALUE;
+	//private var _zoomStep:int = 5;
+	private var click:MovieClip;
+	private var border:MovieClip;
+	private var drag:MovieClip;
+	private var _mask:MovieClip;
+	public var content:MovieClip;
+	//--------------------------------------------------------------------------
+	//
+	//  Constructor
+	//
+	//--------------------------------------------------------------------------
+	public function GrabZoomClip(width:int, height:int)
+	{
+		_width = width;
+		_height = height;
+		draw();
+		click.buttonMode = true;
+		click.addEventListener(MouseEvent.MOUSE_UP, onContentRelease, false, 0, true);
+		click.addEventListener(MouseEvent.MOUSE_DOWN, onContentPress, false, 0, true);
+		click.addEventListener(MouseEvent.MOUSE_WHEEL, onMouseWheel, false, 0, true);
+	}
+	//--------------------------------------------------------------------------
+	//
+	//  Member Functions
+	//
+	//--------------------------------------------------------------------------
+	public function draw():void
+	{
+		border = new MovieClip();
+		click = new MovieClip();
+		drag = new MovieClip();
+		content = new MovieClip();
+		_mask = new MovieClip();
+		this.addChild(border);
+		this.addChild(click);
+		drag.addChild(content);
+		click.addChild(drag);
+		this.addChild(click);
+		this.mask = _mask;
+		redraw();
+	}
+	public function redraw():void
+	{
+		with (border.graphics)
+		{
+			clear();
+			beginFill(_borderColor, _bgAlpha);
+			drawRect(0, 0, _width, _height);
+			endFill();
+		}
+		with (click.graphics)
+		{
+			clear();
+			beginFill(0xAA00FF, _bgAlpha);
+			drawRect(_borderWidth, _borderWidth, width - _borderWidth * 2, height - _borderWidth * 2);
+			endFill();
+		}
+		var bounds:Rectangle = this.getBounds(_mask);
+		with(_mask.graphics)
+		{
+			clear();
+			beginFill(0);
+			drawRect(bounds.topLeft.x, bounds.topLeft.y, _width, _height)
+			endFill();
+		}
+	}
+	protected var _isDraggingContent:Boolean = false;
+	private function onContentRelease(event:MouseEvent):void
+	{
+		//////trace(">>onContentRelease");
+		stage.removeEventListener(MouseEvent.MOUSE_UP, onContentRelease);
+		click.useHandCursor = false;
+		drag.stopDrag();
+		stage.removeEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);
+		_isDraggingContent = false;
+		keepDragClipOnScreen(); // bugfix, was messing up on mouse up
+	}
+	protected function onMouseMove(e:MouseEvent):void
+	{
+		if(_isDraggingContent)
+		{
+			keepDragClipOnScreen();
+		}
+	}
+	protected function keepDragClipOnScreen():void
+	{
+		const minAmountShowing:Number = 80.0;
+		if(drag.x + drag.width < minAmountShowing) // content right bound cant go off left of screen
+		{
+			drag.x = minAmountShowing - drag.width;
+		}
+		else if( drag.x > _width -minAmountShowing) // content left bound cant go off right screen
+		{
+			drag.x = (_width -minAmountShowing);
+		}
+		if(drag.y > _height - minAmountShowing) // content top cant go off bottom of screen
+		{
+			drag.y = _height - minAmountShowing;
+		}
+		else if(drag.y + drag.height < minAmountShowing) // content bottom cant go off top of screen
+		{
+			drag.y = minAmountShowing - drag.height;
+		}
+	}
+	private function onContentPress(event:MouseEvent):void
+	{
+		//////trace(">>onContentPress");
+		stage.addEventListener(MouseEvent.MOUSE_UP, onContentRelease, false, 0, true);
+		stopMovement();
+		click.useHandCursor = true;
+		_isDraggingContent = true;
+		stage.addEventListener(MouseEvent.MOUSE_MOVE, onMouseMove, false, 0, true);
+		//drag.startDrag(false, dragRect);
+		drag.startDrag(false);// checking bounds manually in onMouseMove
+	}
+	private function onMouseWheel(e:MouseEvent):void
+	{
+		//Find min/max zoom levels
+		var tZoomW:Number = _width/(content.width);
+		var tZoomH:Number = _height/(content.height);
+		var minScale:Number = (tZoomW > tZoomH ? tZoomH : tZoomW)*.6;
+		var newScale:Number = content.scaleX + (.07 * e.delta);
+		if(newScale < minScale) newScale = minScale;
+		//if(e.delta < 0 && newScale >= content.scaleX) return;
+		//if(e.delta < 0 && newScale > content.scaleX*.95 && newScale < content.scaleX * 1.05) return;
+		//Set other params
+		var frameTime:Number = .2;
+		var newPoint:Point = translatePoint(content.mouseX, content.mouseY, newScale);
+		//Zoom in/out
+		if(e.delta < 0)
+		{
+			//var percentX:Number = -drag.x/(content.width - _width);
+			//var percentY:Number = -drag.y/(content.height - _height);
+			//if(percentX < 0) percentX = .5;
+			//if(percentY < 0) percentY = .5;
+			//////trace("OLD: ", mouseX, newPoint.x);
+			//////trace("NEW: ", (width*percentX), newPoint.x);
+			//////trace("PERCS: ", percentX, percentY, "   ", drag.x, content.width, content.scaleX);
+			//TweenLite.to(drag, frameTime, { x:(_width*percentX) - newPoint.x, y:(_height*percentY) - newPoint.y } );
+			//if(percentX >= 0 && percentY >= 0)
+			//	TweenLite.to(drag, frameTime, { x:(_width*percentX) - newPoint.x, y:(_height*percentY) - newPoint.y } );
+			//TweenLite.to(drag, frameTime, { x:(mouseX) - newPoint.x, y:(mouseY) - newPoint.y } );
+			//newPoint = translatePoint(this.width/2, this.height/2, newScale);
+			//TweenLite.to(drag, frameTime, { x:((_width / 2) - newPoint.x)*newScale, y:((_height / 2) - newPoint.y)*newScale } );
+			//Forget perfection.... stick with teh hack fix
+			//var cushion:int = 30;
+			//if((content.width * newScale < _width + cushion) &&
+			//	(content.height * newScale < _height + cushion))
+			//{
+			//	var tZoomW:Number = _width/content.width;
+			//	var tZoomH:Number = _height/content.height;
+			//	var fitScale = (tZoomW > tZoomH ? tZoomH : tZoomW) * .75;
+			//	aniZoomAndPosition(content.width / 2, content.height / 2, fitScale, .7, true);
+				//newPoint = translatePoint(content.width/2, content.height/2, newScale);
+				//TweenLite.to(drag, frameTime, { x:((_width / 2) - newPoint.x) - newPoint.x, y:((_height / 2) - newPoint.y) - newPoint.y } );
+				//TweenLite.to(drag, frameTime, { x:(mouseX) - newPoint.x, y:(mouseY) - newPoint.y } );
+			//}
+			//else
+			//{
+			//	////trace("W: ", (content.width * newScale), _width);
+			//	////trace("H: ", (content.height * newScale), _height);
+				aniZoom(newScale, frameTime);
+				TweenLite.to(drag, frameTime, { x:(mouseX) - newPoint.x, y:(mouseY) - newPoint.y } );
+			//}
+		}
+		else
+		{
+			//Position
+			aniZoom(newScale, frameTime);
+			TweenLite.to(drag, frameTime, { x:(mouseX) - newPoint.x, y:(mouseY) - newPoint.y } );
+		}
+		//aniZoomAndPosition(content.mouseX, content.mouseY, newScale, 1, false);
+	}
+	/**
+	 *  Moves and centers to the given position and zoom
+	 */
+	public function aniZoomAndPosition(x:Number, y:Number, targetZoom:Number, frameTime:Number, center:Boolean=true):void
+	{
+//		trace(TRACE_STRING + "::aniZoomAndPosition");
+		aniZoom(targetZoom, frameTime);
+		var newPoint:Point = translatePoint(x, y, targetZoom);
+		var xTarg:int, yTarg:int;
+		if (center == true)
+		{
+			xTarg = (_width / 2) - newPoint.x;
+			yTarg = (_height / 2) - newPoint.y;
+		}
+		else
+		{
+			xTarg = newPoint.x;
+			yTarg = newPoint.y;
+		}
+		//if(xTarg > 0) xTarg = 0; // what was this about? it was messing me up!
+//		trace("xTarg = " + xTarg + ", yTarg = " + yTarg);
+		TweenLite.to(drag, frameTime, { x:xTarg, y:yTarg } );
+	}
+	// Zoom and move to show the given rectangle.
+	// Parts of rect might end up being not shown, if it is too big for our maximum zoom out,
+	//  but preferedZone will always be shown.
+	// It will try and move it as little as possible to make it good.
+	public function showRectangle(rect:Rectangle,preferredRect:Rectangle, frameTime:Number):void
+	{
+		stopMovement();
+		aniZoom(scaleX, frameTime); // not quite sure why this needs to be called first
+		// but it is important!
+		//aniZoomAndPosition(rect.x, rect.y, scaleX, frameTime, true);
+		//return;
+		// zoom to make it fit
+		// TODO
+		// make sure the preferred zone is showing
+		if( ! isRectangleVisibleAtZoom(preferredRect, scaleX) )
+		{
+			rect = translateRect(rect, scaleX);
+			var tx:Number = rect.x //+ ( rect.width / 2.0);
+			var ty:Number = rect.y //+ ( rect.height / 2.0);
+			tx = (_width / 2.0) - tx;
+			ty = (_height / 2.0) - ty;
+			//var g:GTween = new GTween(drag, frameTime, {x:xTarget, y:yTarget});
+			trace(" tx = " + tx + ", ty = " + ty);
+			TweenLite.to(drag, frameTime, { x:tx, y:ty } );
+		}
+	}
+	// check if the given retangle
+	protected function isRectangleVisibleAtZoom(rect:Rectangle, zoomLevel:Number):Boolean
+	{
+		return true;
+	}
+	public function aniZoom(targetZoom:Number, frameTime:Number):void
+	{
+		if(targetZoom > _minZoom && _minZoom < _maxZoom)
+		{
+			stopMovement();
+			TweenLite.to(content , frameTime, { scaleY:targetZoom, scaleX:targetZoom} );
+		}
+	}
+	public function stopMovement():void
+	{
+		TweenLite.killTweensOf(content);
+		TweenLite.killTweensOf(drag);
+	}
+	public function translatePoint(x:Number, y:Number, targetZoom:Number = NaN):Point
+	{
+		var scale:Number = isNaN(targetZoom) ? this.scaleX : targetZoom;
+		return new Point(translateX(x, scale), translateY(y, scale));
+	}
+	protected function translateRect(r:Rectangle, targetZoom:Number):Rectangle
+	{
+		var newPoint:Point = translatePoint(r.x, r.y, targetZoom);
+		var newWidth:Number = r.width * targetZoom;
+		var newHeight:Number = r.height * targetZoom;
+		var result:Rectangle = new Rectangle(newPoint.x, newPoint.y, newWidth, newHeight);
+		return result;
+	}
+	private function translateX(x:Number, z:Number):Number
+	{
+		return x*z;
+		//return drag.x - (x * z + (drag.x * z + this.x)) / z // simplified matrix conversion
+	}
+	private function translateY(y:Number, z:Number):Number
+	{
+		return y*z;
+		return drag.y - (y * z + (drag.y * z + this.y)) / z // simplified matrix conversion
+	}
+	//{ region Properties
+	public function get borderWidth():int { return _borderWidth; }
+	public function set borderWidth(value:int):void
+	{
+		_borderWidth = value;
+	}
+	public function get bgAlpha():Number { return _bgAlpha; }
+	public function set bgAlpha(value:Number):void
+	{
+		_bgAlpha = value;
+	}
+	//} endregion
+}
+}