View difference between Paste ID: C3j4WSC1 and pRMpk81f

 package com.view
 {
 	import com.controller.LineEvent;
 	import com.helpers.LineTools;
 	import com.model.vo.DataVO;
 
 	import flash.display.Sprite;
 	import flash.events.Event;
 	import flash.events.MouseEvent;
 	import flash.geom.Matrix;
 	import flash.geom.Point;
 	import flash.geom.Rectangle;
 
-	import flashx.textLayout.operations.RedoOperation;
+
 
 	public class FurnitureMediator extends Mediator
 	{
 		[Inject]
 		public var furniture:FurnitureView;
 
 		private var item:Sprite;
-
+
 		private var canMove:Boolean=false;
-		private var canMove:Boolean = false;
+
 		private var pointsArray:Array;
 		private var itemRect:Rectangle;
-		private var rotation:Number = 0;
+		private var rotation:Number=0;
 
 		private var itemLastPositionX:Number;
 		private var itemLastPositionY:Number;
 
 		private var collisionWallPoints:Array;
-
+
 
 		private var outSideBounds:Array;
-			item = furniture.item;
+
-			pointsArray = DataVO.cornerPoints;
+
-			itemRect = item.getBounds(furniture);
+
-
+			item=furniture.item;
-			item.x = 100;
+
-			item.y = 100;
+			pointsArray=DataVO.cornerPoints;
-
+
 			itemRect=item.getBounds(furniture);
-			itemRect.x = item.x - 25;
+
-			itemRect.y = item.y - 50;
+
-
+			itemRect.x=item.x - 25;
 			itemRect.y=item.y - 50;
 
 			item.x=100;
 			item.y=100;
-
+
-		private function render(event:Event):void
+
 			eventMap.mapListener(item, MouseEvent.MOUSE_DOWN, mouseDownHandler);
-			if (canMove)
+
 		}
-				item.x = DataVO.mouseX;
+
-				item.y = DataVO.mouseY;
+
-
+		protected function render(event:Event):void
-				itemRect.x = item.x - 25;
+
-				itemRect.y = item.y - 50;
+			if (canMove)
-
+
-				if (getCollisionWallCornerPoints())
+				item.x=DataVO.mouseX;
 				item.y=DataVO.mouseY;
-					rotation = getSnapRotationOfTwoPoint(getCollisionWallCornerPoints());
+
-
+				itemRect.x=item.x - 25;
-					item.rotation = rotation;
+				itemRect.y=item.y - 50;
-
+
 				if (getCollisionWallCornerPoints())
 				{
 					collisionWallPoints = getCollisionWallCornerPoints();
-
+
 
 				if (getObjectWallIntersectPoints(rotation, item, itemRect))
-			var points:Array = new Array();
+
-
+					wallIntersectPoints = getObjectWallIntersectPoints(rotation, item, itemRect);
-			for (var i:int = 0; i < 4; i++)
+
 
-				var array:Array = new Array();
+				if (collisionWallPoints)
-				var check:Boolean = LineTools.isPointInsidePolygon(bounds[i], pointsArray, convertPointsToWall(pointsArray).length);
+
 					rotation=getSnapRotationOfTwoPoint(collisionWallPoints);
 
-
+					item.rotation=rotation;
 				}
 
-
+				if (wallIntersectPoints)
-			var result:Array = new Array();
+
-
+					if (wallIntersectPoints.length > 0)
-			for (var j:int = 0; j < points.length; j++)
+
 						outSideBounds = getOutsidePointOfPolygon(getRotatedBoundsOfObject(rotation, item, itemRect));
-				if (!points[j][0])
+
 						if (wallIntersectPoints.length > 0)
 						{
 							try
 							{
-
+								var diffX:Number = outSideBounds[0].x - wallIntersectPoints[1][0].x;
-			if (result.length > 0)
+								var diffY:Number = outSideBounds[0].y - wallIntersectPoints[1][0].y;
 
 								if (Math.abs(diffX) < 50 && Math.abs(diffY) < 50)
 								{
-
+									item.x=DataVO.mouseX + (diffX * -1);
 									item.y=DataVO.mouseY + (diffY * -1);
 
-
+									itemRect.x=item.x - 25;
 									itemRect.y=item.y - 50;
 								}
-			var check:Boolean = false;
+							}
-
+							catch(error:Error)
-			check = LineTools.isPointInsidePolygon(point, pointsArray, convertPointsToWall(pointsArray).length);
+							{
 								trace(error);
 							}
-
+
 						}
 					}
-			var result:Array = new Array();
+
-			var wallCornerPoints:Array = convertPointsToWall(pointsArray);
+
-			var rotatedItemBounds:Array = getRotatedBoundsOfObject(rotation, item, itemRect);
+
-
+
-			for (var i:int = 0; i < wallCornerPoints.length; i++)
+
 		private function getOutsidePointOfPolygon(bounds:Array):Array
-				var wallPoints:Array = new Array();
+
-				var boxIntersect:Array = LineTools.boxIntersect(wallCornerPoints[i][0], wallCornerPoints[i][1], rotatedItemBounds[0], rotatedItemBounds[1], rotatedItemBounds[2], rotatedItemBounds[3]);
+			var points:Array=new Array();
-
+
-				if(boxIntersect)
+			for (var i:int=0; i < 4; i++)
 			{
 				var array:Array=new Array();
 				var check:Boolean=LineTools.isPointInsidePolygon(bounds[i], pointsArray, convertPointsToWall(pointsArray).length);
 				array.push(check);
 				array.push(bounds[i]);
 
-
+
 			}
-			if (result.length >= 2)
+
 			var result:Array=new Array();
 
 			for (var j:int=0; j < points.length; j++)
-
+
 				if (!points[j][0])
-			if (result.length == 1)
+
 					result.push(points[j][1]);
 				}
 			}
-
+
 			if (result.length > 0)
 			{
-
+
 			}
 
-			var rotationInRadians:Number = degreesToRadians(rotation);
+
-
+
-			var itemCenterPoint:Point = new Point(object.x, object.y);
+
-
+
-			var realBounds:Array = getBoundsOfObject(objectRectangle);
+
-
+			var check:Boolean=false;
-			var bounds:Array = new Array();
+
-
+			check=LineTools.isPointInsidePolygon(point, pointsArray, convertPointsToWall(pointsArray).length);
-			var topLeft:Point = getRotatedRectPoint(rotationInRadians, realBounds[0], itemCenterPoint);
+
-			var topRight:Point = getRotatedRectPoint(rotationInRadians, realBounds[1], itemCenterPoint);
+
-			var bottomRight:Point = getRotatedRectPoint(rotationInRadians, realBounds[2], itemCenterPoint);
+
-			var bottomLeft:Point = getRotatedRectPoint(rotationInRadians, realBounds[3], itemCenterPoint);
+
-
+
 			var result:Array=new Array();
 			var wallCornerPoints:Array=convertPointsToWall(pointsArray);
 			var rotatedItemBounds:Array=getRotatedBoundsOfObject(rotation, item, itemRect);
 
-
+			for (var i:int=0; i < wallCornerPoints.length; i++)
 			{
 				var wallPoints:Array=new Array();
-
+				var boxIntersect:Array=LineTools.boxIntersect(wallCornerPoints[i][0], wallCornerPoints[i][1], rotatedItemBounds[0], rotatedItemBounds[1], rotatedItemBounds[2], rotatedItemBounds[3]);
 
 				if (boxIntersect)
-			var bounds:Array = new Array();
+
-
+
-			var topLeft:Point = $objectRectangle.topLeft;
+
-			var topRight:Point = new Point($objectRectangle.right, $objectRectangle.top);
+
-			var bottomRight:Point = $objectRectangle.bottomRight;
+
-			var botomLeft:Point = new Point($objectRectangle.x, $objectRectangle.bottom);
+
-
+
 			//if two or more wall intersect
 			if (result.length >= 2)
 			{
 				return null;
-
+
 
 			//if one wall intersect
-
+			if (result.length == 1)
-		private function getRotatedRectPoint(angle:Number, point:Point, rotationPoint:Point = null):Point
+
 				return result[0];
-			var ix:Number = (rotationPoint) ? rotationPoint.x : 0;
+
-			var iy:Number = (rotationPoint) ? rotationPoint.y : 0;
+
-
+
-			var m:Matrix = new Matrix( 1,0,0,1, point.x - ix, point.y - iy);
+
 
-			return new Point( m.tx + ix, m.ty + iy);
+
 		{
-
+			var rotationInRadians:Number=degreesToRadians(rotation);
 
 			var itemCenterPoint:Point=new Point(object.x, object.y);
-			var degrees:Number = radians * 180 / Math.PI;
+
 			var realBounds:Array=getBoundsOfObject(objectRectangle);
 
-
+			var bounds:Array=new Array();
 
 			var topLeft:Point=getRotatedRectPoint(rotationInRadians, realBounds[0], itemCenterPoint);
-			var radians:Number = degrees * Math.PI / 180
+			var topRight:Point=getRotatedRectPoint(rotationInRadians, realBounds[1], itemCenterPoint);
 			var bottomRight:Point=getRotatedRectPoint(rotationInRadians, realBounds[2], itemCenterPoint);
 			var bottomLeft:Point=getRotatedRectPoint(rotationInRadians, realBounds[3], itemCenterPoint);
-
+
 			bounds.push(topLeft);
 			bounds.push(topRight);
-			var wallCornerPoints:Array = getCollisionWallCornerPoints();
+
-			var wallIntersectPoints:Array = getObjectWallIntersectPoints(rotation, item, itemRect);
+
-			var rulerPoints:Array = new Array();
+
-
+
-			if(!wallCornerPoints || !wallIntersectPoints) return;
+
-
+
-			if(Point.distance(wallCornerPoints[0], wallIntersectPoints[0]) > Point.distance(wallCornerPoints[0], wallIntersectPoints[1]))
+
 		{
 			var bounds:Array=new Array();
 
 			var topLeft:Point=$objectRectangle.topLeft;
 			var topRight:Point=new Point($objectRectangle.right, $objectRectangle.top);
 			var bottomRight:Point=$objectRectangle.bottomRight;
 			var botomLeft:Point=new Point($objectRectangle.x, $objectRectangle.bottom);
-				dispatch(new LineEvent(LineEvent.PLACE_RULER, rulerPoints));
+
 			bounds.push(topLeft);
 			bounds.push(topRight);
-
+
 			bounds.push(botomLeft);
 
-			var rotation:Number = radiansToDegrees(getAngleOfTwoPoint(array[0], array[1]));
+
 		}
 
-
+		private function getRotatedRectPoint(angle:Number, point:Point, rotationPoint:Point=null):Point
 		{
 			var ix:Number=(rotationPoint) ? rotationPoint.x : 0;
-			var slope:int = (point1.y - point2.y) / (point1.x - point2.x);
+			var iy:Number=(rotationPoint) ? rotationPoint.y : 0;
-			var int1:Number = testPoint.y - point2.y;
+
-			var int2:Number = slope * (testPoint.x - point2.x);
+			var m:Matrix=new Matrix(1, 0, 0, 1, point.x - ix, point.y - iy);
-
+
 			return new Point(m.tx + ix, m.ty + iy);
 		}
 
 		private function radiansToDegrees(radians:Number):Number
-
+
 			var degrees:Number=radians * 180 / Math.PI;
 			return degrees;
-
+
 
 		private function degreesToRadians(degrees:Number):Number
-			var dx:Number = point2.x - point1.x;
+
-			var dy:Number = point2.y - point1.y;
+			var radians:Number=degrees * Math.PI / 180
-			return Math.atan2(dy,dx);
+
 		}
-
+
 		private function drawRuler():void
 		{
-			var wallCornerPoints:Array = convertPointsToWall(pointsArray);
+			var wallCornerPoints:Array=getCollisionWallCornerPoints();
-			var wallIntersectPoints:Array = getObjectWallIntersectPoints(item.rotation, item, itemRect);
+			var wallIntersectPoints:Array=getObjectWallIntersectPoints(rotation, item, itemRect);
-			var result:Array = new Array();
+			var rulerPoints:Array=new Array();
-
+
-			if (!wallIntersectPoints || wallIntersectPoints.length == 0)
+			if (!wallCornerPoints || !wallIntersectPoints)
-			{
+				return;
 
 			if (Point.distance(wallCornerPoints[0], wallIntersectPoints[0]) > Point.distance(wallCornerPoints[0], wallIntersectPoints[1]))
-
+
 				rulerPoints.push(wallIntersectPoints[0], wallIntersectPoints[1], wallCornerPoints[0], wallIntersectPoints[1], wallIntersectPoints[0], wallCornerPoints[1]);
 				dispatch(new LineEvent(LineEvent.PLACE_RULER, rulerPoints));
-				for (var i:int = 0; i < wallCornerPoints.length; i++)
+
 			else
-					var point:Point = LineTools.rayRayIntersect(wallIntersectPoints[1][0], wallIntersectPoints[1][1], wallCornerPoints[i][0], wallCornerPoints[i][1]);
+
-
+
 				dispatch(new LineEvent(LineEvent.PLACE_RULER, rulerPoints));
 			}
 		}
 
 		private function getSnapRotationOfTwoPoint(array:Array):Number
 		{
-
+			var rotation:Number=radiansToDegrees(getAngleOfTwoPoint(array[0], array[1]));
 			return rotation - 90;
-			}
+
-			catch(error:Error)
+
 		private function isThePointBetweenTwoPoint(testPoint:Point, point1:Point, point2:Point):Boolean
 		{
 			var slope:int=(point1.y - point2.y) / (point1.x - point2.x);
-
+			var int1:Number=testPoint.y - point2.y;
 			var int2:Number=slope * (testPoint.x - point2.x);
-
+
 			if (int1 == int2)
 			{
-
+
 			}
 
-			var x:int = point1.x + point2.x;
+
-			var y:int = point1.y + point2.y;
+
-			var centerPoint:Point = new Point(x/2, y/2);
+
 		private function getAngleOfTwoPoint(point1:Point, point2:Point):Number
 		{
-
+			var dx:Number=point2.x - point1.x;
 			var dy:Number=point2.y - point1.y;
 			return Math.atan2(dy, dx);
-			var result:Array = new Array();
+
-			var points:Array = array;
+
-
+
-			for (var i:int = 0; i < points.length; i++)
+
 			var wallCornerPoints:Array=convertPointsToWall(pointsArray);
-				var wall:Array = new Array();
+			var wallIntersectPoints:Array=getObjectWallIntersectPoints(item.rotation, item, itemRect);
-
+			var result:Array=new Array();
-				if (i == points.length - 1)
+
 			if (!wallIntersectPoints || wallIntersectPoints.length == 0)
 			{
 				return null;
-				}
+
 
 			try
 			{
-					wall.push(points[i+1]);
+				for (var i:int=0; i < wallCornerPoints.length; i++)
 				{
 					var point:Point=LineTools.rayRayIntersect(wallIntersectPoints[1][0], wallIntersectPoints[1][1], wallCornerPoints[i][0], wallCornerPoints[i][1]);
 
-
+
 					{
-
+
 						result.push(wallCornerPoints[i][1]);
-
+
 					}
 
-			canMove = false;
+
 			}
-
+			catch (error:Error)
 			{
 				trace(error);
-			canMove = true;
+
 
 
 
 			return null;
 		}
 
 		private function getCenterPointOfTwoPoint(point1:Point, point2:Point):Point
 		{
 			var x:int=point1.x + point2.x;
 			var y:int=point1.y + point2.y;
 			var centerPoint:Point=new Point(x / 2, y / 2);
 			return centerPoint;
 		}
 
 		private function convertPointsToWall(array:Array):Array
 		{
 			var result:Array=new Array();
 			var points:Array=array;
 
 			for (var i:int=0; i < points.length; i++)
 			{
 				var wall:Array=new Array();
 
 				if (i == points.length - 1)
 				{
 					wall.push(points[i]);
 					wall.push(points[0]);
 				}
 				else
 				{
 					wall.push(points[i]);
 					wall.push(points[i + 1]);
 				}
 				result.push(wall);
 			}
 
 			return result;
 
 		}
 
 		protected function mouseUpHandler(event:MouseEvent):void
 		{
 			canMove=false;
 		}
 
 		protected function mouseDownHandler(event:MouseEvent):void
 		{
 			canMove=true;
 		}
 	}
 }