mako 0.0.0

data/lib/mako/data/flash_widget_dev_core/src/com/adobe/ac/mxeffects/effectClasses/CubeRotateInstance.as

@@ -0,0 +1,94 @@
+package com.adobe.ac.mxeffects.effectClasses
+{
+	import com.adobe.ac.mxeffects.CubeRotate;
+	import com.adobe.ac.mxeffects.Distortion;
+	import com.adobe.ac.mxeffects.DistortionConstants;
+	import flash.geom.Rectangle;
+	public class CubeRotateInstance extends DistortBaseInstance
+	{
+		private var distortLeaving : Distortion;
+		private var distortComing : Distortion;
+		public function CubeRotateInstance( target:Object )
+		{
+			super( target );
+		}
+		override public function play() : void
+		{
+			if( direction == null ) direction = CubeRotate.defaultDirection;
+			if( buildMode == null ) buildMode = CubeRotate.defaultBuildMode;
+			super.play();
+			startAnimation();
+		}
+		private function startAnimation() : void
+		{
+			var leavingOffsetRect : Rectangle;
+			var comingOffsetRect : Rectangle;
+			if( direction == DistortionConstants.RIGHT )
+			{
+				leavingOffsetRect = new Rectangle( 0, NaN, target.width, NaN );
+				comingOffsetRect = new Rectangle( NaN, NaN, target.width, NaN );
+			}
+			else if( direction == DistortionConstants.LEFT )
+			{
+				leavingOffsetRect = new Rectangle( NaN, NaN, target.width, NaN );
+				comingOffsetRect = new Rectangle( 0, NaN, target.width, NaN );
+			}
+			else if( direction == DistortionConstants.TOP )
+			{
+				leavingOffsetRect = new Rectangle( NaN, 0, NaN, target.height );
+				comingOffsetRect = new Rectangle( NaN, 0, NaN, NaN );
+			}
+			else if( direction == DistortionConstants.BOTTOM )
+			{
+				leavingOffsetRect = new Rectangle( NaN, 0, NaN, NaN );
+				comingOffsetRect = new Rectangle( NaN, 0, NaN, target.height );
+			}
+			initializeNextTarget();
+			distortLeaving = new Distortion( currentTarget, leavingOffsetRect );
+			applyCoordSpaceChange( distortLeaving, getContainerChild( siblings[ currentSibling ] ) );
+			applyDistortionMode( distortLeaving );
+			applyBlur( distortLeaving.container );
+			initializeNextTarget();
+			distortComing = new Distortion( currentTarget, comingOffsetRect );
+			applyCoordSpaceChange( distortComing, getContainerChild( siblings[ currentSibling - 1 ] ) );
+			applyDistortionMode( distortComing );
+			applyBlur( distortComing.container );
+			animateLeaving();
+			animateComing();
+		}
+		private function updateLeaving( value : Object ) : void
+		{
+			distortLeaving.pop( Number( value ), direction, distortion );
+		}
+		private function updateComing( value : Object ) : void
+		{
+			distortComing.push( Number( value ), direction, distortion );
+		}
+		private function endAnimation( value : Object ) : void
+		{
+			distortLeaving.destroy( false );
+			var hasSiblings : Boolean = ( siblings.length > currentSibling + 1 );
+			if( hasSiblings )
+			{
+				currentSibling--;
+				delayDeletion( distortComing );
+				startAnimation();
+			}
+			else
+			{
+				distortComing.destroy();
+				super.onTweenEnd( value );
+			}
+		}
+		private function animateLeaving() : void
+		{
+			var updateMethod : Function = updateLeaving;
+			animate( 0, 100, siblingDuration, updateMethod, null );
+		}
+		private function animateComing() : void
+		{
+			var updateMethod : Function = updateComing;
+			animate( 0, 100, siblingDuration, updateMethod, endAnimation );
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/com/adobe/ac/mxeffects/effectClasses/DistortBaseInstance.as

@@ -0,0 +1,258 @@
+package com.adobe.ac.mxeffects.effectClasses
+{
+	import com.adobe.ac.mxeffects.Distortion;
+	import com.adobe.ac.mxeffects.DistortionConstants;
+	import flash.display.DisplayObject;
+	import flash.display.DisplayObjectContainer;
+	import flash.events.Event;
+	import flash.filters.BlurFilter;
+	import flash.geom.Point;
+	import flash.geom.Rectangle;
+	import flash.utils.Dictionary;
+	import mx.core.Container;
+	import mx.core.ContainerCreationPolicy;
+	import mx.core.IFlexDisplayObject;
+	import mx.core.UIComponent;
+	import mx.core.mx_internal;
+	import mx.effects.Tween;
+	import mx.effects.effectClasses.TweenEffectInstance;
+	import mx.events.TweenEvent;
+	use namespace mx_internal;
+	public class DistortBaseInstance extends TweenEffectInstance
+	{
+		public var direction : String;
+		public var buildMode : String;
+		public var smooth : Boolean;
+		public var distortion : Number;
+		public var blur : BlurFilter;
+		public var offsetRect : Rectangle;
+		public var quality : String;
+		public var liveUpdate : Boolean = false;
+		public var liveUpdateInterval : int = 0;
+		protected var siblingDuration : Number;
+		protected var currentSibling : int;
+		protected var currentTarget : UIComponent;
+		protected var container : DisplayObjectContainer;
+		private var originalContainerCreationPolicy : String;
+		private var distortDeletionPending : Distortion;
+		private var concatenatedMatrices : Dictionary;
+		private var _siblings : Array;
+		private var _containerChild : DisplayObject;
+		public function DistortBaseInstance( target : Object )
+		{
+			super( target );
+		}
+		public function get siblings() : Array
+		{
+			return _siblings;
+		}
+		public function set siblings( value : Array ) : void
+		{
+			var index : int = value.indexOf( null );
+			if( index > -1 )
+			{
+				throw new Error( "siblings: [" + value + "] contains a null value at position " + index );
+			}
+			_siblings = value;
+		}
+		override public function play() : void
+		{
+			super.play();
+			initializeProperties();
+		}
+		protected function applyBlur( target : DisplayObject ) : void
+		{
+			if( blur != null )
+			{
+				var filters : Array = target.filters;
+				filters.push( blur );
+				target.filters = filters;
+			}
+		}
+		protected function applyDistortionMode( distortion : Distortion ) : void
+		{
+			if( buildMode != null ) distortion.buildMode = buildMode;
+			distortion.smooth = smooth;
+			distortion.liveUpdate = liveUpdate;
+			findContainer();
+			distortion.targetContainer = container;
+			distortion.concatenatedMatrix = concatenatedMatrices[ distortion.target ];
+		}
+		protected function applyCoordSpaceChange( distortion : Distortion, coordSpaceChild : DisplayObject ) : void
+		{
+			var correctBuildMode : Boolean = ( buildMode == DistortionConstants.POPUP );
+			var coordsSpaceChange : Boolean = ( correctBuildMode && currentTarget.parent == null );
+			if( coordsSpaceChange )
+			{
+				distortion.positionedTarget = DisplayObject( coordSpaceChild );
+			}
+		}
+		protected function animate( startPoints : Object, endPoints : Object,
+											siblingDuration : Number,
+											updateHandler : Function, endHandler : Function ) : void
+		{
+			var tweenListener : Object = new Object();
+			var tween : Tween = createTween( tweenListener, startPoints, endPoints, siblingDuration );
+			if( endHandler == null ) endHandler = onEnd;
+			tween.setTweenHandlers( updateHandler, endHandler );
+		}
+		protected function initializeNextTarget() : void
+		{
+			currentSibling++;
+			currentTarget = siblings[ currentSibling ];
+			initializeBounds( currentTarget );
+		}
+		protected function initializePreviousTarget() : void
+		{
+			currentSibling--;
+			currentTarget = siblings[ currentSibling ];
+			initializeBounds( currentTarget );
+		}
+		protected function initializeProperties() : void
+		{
+			if( isNaN( distortion ) ) distortion = 20;
+			siblingDuration = duration / siblings.length;
+			currentSibling = -1;
+			siblings.unshift( target );
+			findContainer();
+			initializeChildrenForCapture();
+		}
+		protected function initializeBounds( newChild : UIComponent ) : void
+		{
+			var firstChild : DisplayObject = DisplayObject( target );
+			if( container is Container )
+			{
+				var mxContainer : Container = Container( container );
+				originalContainerCreationPolicy = mxContainer.creationPolicy;
+				mxContainer.creationPolicy = ContainerCreationPolicy.ALL;
+				mxContainer.validateNow();
+			}
+			newChild.setActualSize( firstChild.width, firstChild.height );
+			newChild.validateNow();
+		}
+		override public function onTweenEnd( value : Object ) : void
+		{
+			if( originalContainerCreationPolicy != null )
+			{
+				var mxContainer : Container = Container( container );
+				mxContainer.creationPolicy = originalContainerCreationPolicy;
+			}
+			reset();
+			super.onTweenEnd( value );
+		}
+		protected function getContainerChild( child : DisplayObject ) : DisplayObject
+		{
+			var coordsChild : DisplayObject;
+			if( child.parent == null )
+				coordsChild = containerChild;
+			else
+				coordsChild = child;
+			return coordsChild;
+		}
+		protected function get containerChild() : DisplayObject
+		{
+			if( _containerChild == null )
+			{
+				_containerChild = findContainerChild();
+			}
+			else if( _containerChild.parent == null )
+			{
+				_containerChild = findContainerChild();
+			}
+			return _containerChild;
+		}
+		protected function set containerChild( value : DisplayObject ) : void
+		{
+			_containerChild = value;
+		}
+		private function findContainerChild() : DisplayObject
+		{
+			var containerChild : DisplayObject;
+			var len : Number = siblings.length;
+			for( var i : int; i < len; i++ )
+			{
+				var child : DisplayObject = siblings[ i ];
+				if( child.parent != null )
+				{
+					containerChild = child;
+					break;
+				}
+			}
+			return containerChild;
+		}
+		private function findContainer() : void
+		{
+			if( this.container == null )
+			{
+				var container : DisplayObjectContainer;
+				if( target.parent != null )
+				{
+					container = target.parent;
+				}
+				else
+				{
+					var len : Number = siblings.length;
+					for( var i : int; i < len; i++ )
+					{
+						var child : DisplayObject = siblings[ i ];
+						if( child.parent != null )
+						{
+							container = DisplayObjectContainer( child.parent );
+							containerChild = child;
+							break;
+						}
+					}
+				}
+				this.container = container;
+			}
+		}
+		private function initializeChildrenForCapture() : void
+		{
+			concatenatedMatrices = new Dictionary();
+			var mxContainer : Container = Container( container );
+			var len : Number = siblings.length;
+			for( var i : int; i < len; i++ )
+			{
+				var child : DisplayObject = siblings[ i ];
+				if( child.parent == null )
+				{
+					mxContainer.addChild( child );
+					mxContainer.validateNow();
+					concatenatedMatrices[ child ] = child.transform.concatenatedMatrix;
+					mxContainer.removeChild( child );
+				}
+				else
+				{
+					concatenatedMatrices[ child ] = child.transform.concatenatedMatrix;
+				}
+			}
+		}
+		private function reset() : void
+		{
+			siblings.shift();
+			siblingDuration = 0;
+			currentSibling = 0;
+			currentTarget = null;
+			container = null;
+			originalContainerCreationPolicy = null;
+		}
+		protected function delayDeletion( distortComing : Distortion ) : void
+		{
+			distortDeletionPending = distortComing;
+			addEventListener( TweenEvent.TWEEN_START, performDistortDeletion );
+		}
+		private function performDistortDeletion( event : TweenEvent ) : void
+		{
+			if( distortDeletionPending != null )
+			{
+				distortDeletionPending.destroy();
+				distortDeletionPending = null;
+				removeEventListener( TweenEvent.TWEEN_START, performDistortDeletion );
+			}
+		}
+		private function onEnd( value : Object ) : void
+		{
+			//dummy handler
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/com/adobe/ac/mxeffects/effectClasses/DoorInstance.as

@@ -0,0 +1,116 @@
+package com.adobe.ac.mxeffects.effectClasses
+{
+	import com.adobe.ac.mxeffects.Distortion;
+	import com.adobe.ac.mxeffects.Door;
+	public class DoorInstance extends DistortBaseInstance
+	{
+		public var mode : String;
+		private var distort : Distortion;
+		private var distortBack : Distortion;
+		public function DoorInstance( target : Object )
+		{
+			super( target );
+		}
+		override public function play() : void
+		{
+			if( direction == null ) direction = Door.defaultDirection;
+			if( mode == null ) mode = Door.defaultMode;
+			if( buildMode == null ) buildMode = Door.defaultBuildMode;
+			super.play();
+			startAnimation();
+		}
+		private function startAnimation() : void
+		{
+			initializeNextTarget();
+			nextAnimation();
+		}
+		private function nextAnimation() : void
+		{
+			if( mode == Door.OPEN )
+			{
+				initializeNextTarget();
+				distortBack = new Distortion( currentTarget );
+				applyCoordSpaceChange( distortBack, getContainerChild( siblings[ currentSibling - 1 ] ) );
+				applyDistortionMode( distortBack );
+				distortBack.renderSides( 100, 100, 100, 100 );
+				initializePreviousTarget();
+				startOpen();
+			}
+			else if( mode == Door.CLOSE )
+			{
+				distortBack = new Distortion( currentTarget );
+				applyCoordSpaceChange( distortBack, getContainerChild( siblings[ currentSibling ] ) );
+				applyDistortionMode( distortBack );
+				distortBack.renderSides( 100, 100, 100, 100 );
+				initializeNextTarget();
+				startClose();
+				initializePreviousTarget();
+			}
+			distortBack.container.x -= distortBack.offsetRect.x;
+		}
+		private function startOpen() : void
+		{
+			distort = new Distortion( currentTarget );
+			applyCoordSpaceChange( distort, getContainerChild( siblings[ currentSibling ] ) );
+			applyDistortionMode( distort );
+			applyBlur( distort.container );
+			distort.renderSides( 100, 100, 100, 100 );
+			var updateMethod : Function = updateOpenAnimation;
+			animate( 0, 100, siblingDuration, updateMethod, endAnimation );
+		}
+		private function updateOpenAnimation( value : Object ) : void
+		{
+			if( liveUpdate ) distortBack.renderSides( 100, 100, 100, 100 );
+			distort.openDoor( Number( value ), direction, distortion );
+		}
+		private function endAnimation( value : Object ) : void
+		{
+			if( mode == Door.OPEN )
+			{
+				distortBack.destroy();
+				distort.destroy( false );
+			}
+			else if( mode == Door.CLOSE )
+			{
+				distortBack.destroy( false );
+				distort.destroy();
+			}
+			currentSibling++;
+			var hasSiblings : Boolean = ( siblings.length > currentSibling + 1 );
+			if( hasSiblings )
+			{
+				currentSibling--;
+				startAnimation();
+			}
+			else
+			{
+				super.onTweenEnd( value );
+			}
+		}
+		private function startClose() : void
+		{
+			distort = new Distortion( currentTarget );
+			distort.liveUpdate = liveUpdate;
+			applyCoordSpaceChange( distort, getContainerChild( siblings[ currentSibling ] ) );
+			applyDistortionMode( distort );
+			applyBlur( distort.container );
+			var updateMethod : Function = updateCloseAnimation;
+			animate( 0, 100, siblingDuration, updateMethod, endAnimation );
+		}
+		private function updateCloseAnimation( value : Object ) : void
+		{
+			if( liveUpdate ) distortBack.renderSides( 100, 100, 100, 100 );
+			distort.closeDoor( Number( value ), direction, distortion );
+		}
+		private function updateWithLightingToWhite( value : Object ) : void
+		{
+			var updateValue : Number = Number( value );
+			updateCloseAnimation( updateValue );
+		}
+		private function updateWithLightingFromBlack( value : Object ) : void
+		{
+			var updateValue : Number = Number( value );
+			updateCloseAnimation( updateValue );
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/com/adobe/ac/mxeffects/effectClasses/FlipInstance.as

@@ -0,0 +1,79 @@
+package com.adobe.ac.mxeffects.effectClasses
+{
+	import com.adobe.ac.mxeffects.Distortion;
+	import com.adobe.ac.mxeffects.DistortionConstants;
+	import com.adobe.ac.mxeffects.Flip;
+	public class FlipInstance extends DistortBaseInstance
+	{
+		public var exceedBounds : Boolean;
+		public var hasCustomExceedBounds : Boolean;
+		public var horizontalLightingLocation : String;
+		public var verticalLightingLocation : String;
+		private var distortFront : Distortion;
+		private var distortBack : Distortion;
+		public function FlipInstance( target : Object )
+		{
+			super( target );
+		}
+		override public function play() : void
+		{
+			if( direction == null ) direction = Flip.defaultDirection;
+			if( buildMode == null ) buildMode = Flip.defaultBuildMode;
+			if( !hasCustomExceedBounds ) exceedBounds = true;
+			super.play();
+			startFlipFront();
+		}
+		private function startFlipFront() : void
+		{
+			initializeNextTarget();
+			distortFront = new Distortion( currentTarget );
+			applyCoordSpaceChange( distortFront, getContainerChild( siblings[ currentSibling ] ) );
+			applyDistortionMode( distortFront );
+			applyBlur( distortFront.container );
+			var updateMethod : Function = updateFront;
+			animate( 0, 100, siblingDuration / 2, updateMethod, endFront );
+		}
+		private function updateFront( value : Object ) : void
+		{
+			distortFront.flipFront( Number( value ), direction, distortion, exceedBounds );
+		}
+		private function endFront( value : Object ) : void
+		{
+			if( buildMode == DistortionConstants.REPLACE )
+			{
+				container.removeChild( distortFront.container );
+			}
+			startFlipBack();
+		}
+		private function startFlipBack() : void
+		{
+			initializeNextTarget();
+			distortBack = new Distortion( currentTarget );
+			applyCoordSpaceChange( distortBack, getContainerChild( siblings[ currentSibling - 1 ] ) );
+			applyDistortionMode( distortBack );
+			applyBlur( distortBack.container );
+			var updateMethod : Function = updateBack;
+			animate( 0, 100, siblingDuration / 2, updateMethod, endBack );
+		}
+		private function updateBack( value : Object ) : void
+		{
+			distortBack.flipBack( Number( value ), direction, distortion, exceedBounds );
+		}
+		private function endBack( value : Object ) : void
+		{
+			distortFront.destroy( false );
+			var hasSiblings : Boolean = ( siblings.length > currentSibling + 1 );
+			if( hasSiblings )
+			{
+				currentSibling--;
+				delayDeletion( distortBack );
+				startFlipFront();
+			}
+			else
+			{
+				distortBack.destroy();
+				super.onTweenEnd( value );
+			}
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/com/adobe/ac/mxeffects/effectClasses/GateInstance.as

@@ -0,0 +1,163 @@
+package com.adobe.ac.mxeffects.effectClasses
+{
+	import com.adobe.ac.mxeffects.Distortion;
+	import com.adobe.ac.mxeffects.DistortionConstants;
+	import com.adobe.ac.mxeffects.Gate;
+	import flash.geom.Rectangle;
+	import mx.core.IFlexDisplayObject;
+	public class GateInstance extends DistortBaseInstance
+	{
+		public var mode : String;
+		private var distortLeft : Distortion;
+		private var distortRight : Distortion;
+		private var distortBack : Distortion;
+		public function GateInstance( target : Object )
+		{
+			super( target );
+		}
+		override public function play() : void
+		{
+			if( direction == null ) direction = Gate.defaultDirection;
+			if( mode == null ) mode = Gate.defaultMode;
+			if( buildMode == null ) buildMode = Gate.defaultBuildMode;
+			super.play();
+			startAnimation();
+		}
+		private function startAnimation() : void
+		{
+			initializeNextTarget();
+			nextAnimation();
+		}
+		private function nextAnimation() : void
+		{
+			if( mode == Gate.OPEN )
+			{
+				initializeNextTarget();
+				distortBack = new Distortion( currentTarget );
+				applyCoordSpaceChange( distortBack, getContainerChild( siblings[ currentSibling - 1 ] ) );
+				applyDistortionMode( distortBack );
+				distortBack.renderSides( 100, 100, 100, 100 );
+				initializePreviousTarget();
+				startOpen();
+			}
+			else if( mode == Gate.CLOSE )
+			{
+				distortBack = new Distortion( currentTarget );
+				applyCoordSpaceChange( distortBack, getContainerChild( siblings[ currentSibling ] ) );
+				applyDistortionMode( distortBack );
+				distortBack.renderSides( 100, 100, 100, 100 );
+				initializeNextTarget();
+				startClose();
+				initializePreviousTarget();
+			}
+			distortBack.container.x -= distortBack.offsetRect.x;
+		}
+		private function startOpen() : void
+		{
+			initLeftAndRightDistortions();
+			distortLeft.openDoor( 0, direction, distortion );
+			distortRight.openDoor( 0, direction, distortion );
+			var updateMethod : Function = updateOpenAnimation;
+			animate( 0, 100, siblingDuration, updateMethod, endAnimation );
+		}
+		private function updateOpenAnimation( value : Object ) : void
+		{
+			if( liveUpdate ) distortBack.renderSides( 100, 100, 100, 100 );
+			distortLeft.openDoor( Number( value ), direction, distortion );
+			distortRight.openDoor( Number( value ),
+										distortRight.reverseDirection( direction ),
+										distortion );
+		}
+		private function endAnimation( value : Object ) : void
+		{
+			if( mode == Gate.OPEN )
+			{
+				distortBack.destroy();
+				distortLeft.destroy( false );
+				distortRight.destroy( false );
+			}
+			else if( mode == Gate.CLOSE )
+			{
+				distortBack.destroy( false );
+				distortLeft.destroy();
+				distortRight.destroy();
+			}
+			currentSibling++;
+			var hasSiblings : Boolean = ( siblings.length > currentSibling + 1 );
+			if( hasSiblings )
+			{
+				currentSibling--;
+				startAnimation();
+			}
+			else
+			{
+				super.onTweenEnd( value );
+			}
+		}
+		private function startClose() : void
+		{
+			initLeftAndRightDistortions();
+			var updateMethod : Function = updateCloseAnimation;
+			animate( 0, 100, siblingDuration, updateMethod, endAnimation );
+		}
+		private function updateCloseAnimation( value : Object ) : void
+		{
+			if( liveUpdate ) distortBack.renderSides( 100, 100, 100, 100 );
+			distortLeft.closeDoor( Number( value ), direction, distortion );
+			distortRight.closeDoor( Number( value ),
+										distortRight.reverseDirection( direction ),
+										distortion );
+		}
+		private function initLeftAndRightDistortions() : void
+		{
+			var leftRect : Rectangle;
+			var rightRect : Rectangle;
+			if( direction == DistortionConstants.LEFT || direction == DistortionConstants.RIGHT )
+			{
+				leftRect = getVerticalLeftRectangle( currentTarget );
+				rightRect = getVerticalRightRectangle( currentTarget );
+			}
+			else if( direction == DistortionConstants.TOP || direction == DistortionConstants.BOTTOM )
+			{
+				leftRect = getHorizontalLeftRectangle( currentTarget );
+				rightRect = getHorizontalRightRectangle( currentTarget );
+			}
+			distortLeft = new Distortion( currentTarget, leftRect );
+			distortRight = new Distortion( currentTarget, rightRect );
+			applyCoordSpaceChange( distortLeft, getContainerChild( siblings[ currentSibling ] ) );
+			applyCoordSpaceChange( distortRight, getContainerChild( siblings[ currentSibling ] ) );
+			applyDistortionMode( distortLeft );
+			applyDistortionMode( distortRight );
+			applyBlur( distortLeft.container );
+			applyBlur( distortRight.container );
+		}
+		private function getVerticalLeftRectangle( currentTarget : IFlexDisplayObject ) : Rectangle
+		{
+			var leftRect : Rectangle = new Rectangle( 0, 0 );
+			leftRect.width = currentTarget.width / 2;
+			leftRect.height = NaN;
+			return leftRect;
+		}
+		private function getVerticalRightRectangle( currentTarget : IFlexDisplayObject ) : Rectangle
+		{
+			var rightRect : Rectangle = new Rectangle( currentTarget.width / 2, 0 );
+			rightRect.width = currentTarget.width / 2;
+			rightRect.height = NaN;
+			return rightRect;
+		}
+		private function getHorizontalLeftRectangle( currentTarget : IFlexDisplayObject ) : Rectangle
+		{
+			var leftRect : Rectangle = new Rectangle( 0, 0 );
+			leftRect.width = currentTarget.width;
+			leftRect.height = currentTarget.height / 2;
+			return leftRect;
+		}
+		private function getHorizontalRightRectangle( currentTarget : IFlexDisplayObject ) : Rectangle
+		{
+			var rightRect : Rectangle = new Rectangle( 0, currentTarget.height / 2 );
+			rightRect.width = currentTarget.width;
+			rightRect.height = currentTarget.height / 2;
+			return rightRect;
+		}
+	}
+}