~eda-qa/dhlib/main

/* <license>
 * This file is part of the dis-Emi-A HaXe Library. Copyright (c) edA-qa mort-ora-y
 * For full copyright and license information please refer to doc/license.txt.
 * </license> 
 */
package mathx;

/**
 * A generic rectangle class, this parallels the flash Rectangle class but will fill
 * in missing items and be usable in more than just a flash environment.
 *
 * May also be used for padding in which case the four core members represent
 * padding variables and not a rectangle.
 */
class Rect2
{
	public var left : Float;
	public var top : Float;
	public var right : Float;
	public var bottom : Float;
	
	private function new( left : Float, top : Float, right : Float, bottom : Float )
	{
		this.left = left;
		this.top = top;
		this.right = right;
		this.bottom = bottom;
	}
	
#if flash
	static public function fromFlash( fr : flash.geom.Rectangle ) : Rect2
	{
		return new Rect2(fr.left, fr.top,fr.right,fr.bottom);
	}
	
	public function toFlash( ) : flash.geom.Rectangle
	{
		return new flash.geom.Rectangle( left, top, right-left, bottom-top );
	}
	
	public function toWindowGlobal( obj : flash.display.DisplayObject ) : Rect2
	{
		var ul = obj.localToGlobal( upperLeft.toFlash() );
		var br = obj.localToGlobal( bottomRight.toFlash() );
		return new Rect2( ul.x, ul.y, br.x, br.y );
	}
	
	public function toWindowLocal( obj : flash.display.DisplayObject ) : Rect2
	{
		var ul = obj.globalToLocal( upperLeft.toFlash() );
		var br = obj.globalToLocal( bottomRight.toFlash() );
		return new Rect2( ul.x, ul.y, br.x, br.y );
	}
	
	public function fromWindowToWindow( objS, objT ) : Rect2
	{
		return toWindowGlobal( objS ).toWindowLocal( objT );
	}
	
#end
	static public function fromULBR( left : Float, top : Float, right : Float, bottom : Float )
	{
		return new Rect2( left, top, right, bottom );
	}
	
	static public function fromULSizePt( ul : Point2, size : Point2 )
	{
		return new Rect2( ul.x, ul.y, ul.x + size.x, ul.y + size.y );
	}

	static public function fromULSize( ulx : Float, uly : Float, cx : Float, cy : Float )
	{
		return new Rect2( ulx, uly, ulx+cx, uly+cy );
	}
	
	/** 
	 * Using the values from Widget.getPos(), getSize() and getCenter()
	 */
	static public function fromPosSizeCtrPt( pos : Point2, size : Point2, ctr : Point2 )
	{
		var ulR = ctr.sub( Point2.at( 0.5, 0.5 ) );
		var ul = pos.add( size.scale( ulR ) );
		var br = ul.add( size );
		return new Rect2( ul.x, ul.y, br.x, br.y );
	}
	
#if flash
	static public function fromWidgetBounds( widget : ui.Widget )
	{
		return fromPosSizeCtrPt( widget.getPos(), widget.getSize(), widget.getCenter() );
	}
#end

	public function toString() : String
	{
		return "(" + left + "," + top + "," + (right-left) + "," + (bottom-top) + ")";
	}
	
	public function clone() : Rect2
	{
		return new Rect2( left, top, right, bottom );
	}
	
	public function intersects( o : Rect2 ) : Bool
	{
		//TODO: I'm being lazy for now, but perhaps this is faster than our own code...?
		return toFlash().intersects( o.toFlash() );
	}
	
	public function containsPt( pt : Point2 ) : Bool
	{
		return pt.x >= left
			&& pt.x <= right
			&& pt.y >= top
			&& pt.y <= bottom;
	}
	
	public function contains( x : Float, y : Float ) : Bool
	{
		return x >= left
			&& x <= right
			&& y >= top
			&& y <= bottom;
	}
	
	public function scalePt( pt : Point2 ) : Rect2
	{
		var cl = clone();
		cl.left *= pt.x;
		cl.right *= pt.x;
		cl.top *= pt.y;
		cl.bottom *= pt.y;
		return cl;
	}
	
	public function scale( cx : Float, cy : Float ) : Rect2
	{
		var cl = clone();
		cl.left *= cx;
		cl.right *= cx;
		cl.top *= cy;
		cl.bottom *= cy;
		return cl;
	}
	
	public function addOff( rect : Rect2 ) : Rect2
	{
		return new Rect2( left + rect.left, top + rect.top, right + rect.right, bottom + rect.bottom );
	}
	
	public function addOffPt( pt : Point2 ) : Rect2 
	{
		return new Rect2( left + pt.x, top + pt.y, right + pt.x, bottom + pt.y );
	}
	
	/**
	 * Obtains a relatively size rectangle.
	 */
	inline public function rel( x1 : Float, y1 : Float,  x2 : Float, y2 : Float ) : Rect2
	{
		return new Rect2( left + width * x1, top + height * y1,
			left + width * x2, top + height * y2 );
	}
	
	/**
	 * OBtains a relatively sized rectangle giving a size rather than position
	 * of bottom right corner.
	 */
	inline public function relSize( x1 : Float, y1 : Float, sizeX : Float, sizeY : Float ) : Rect2
	{
		return new Rect2( left + width * x1, top + height * y1,
			left + width * (x1 + sizeX), top + height * (y1 + sizeY) );
	}
	
	inline public function relSizeCtr( x1 : Float, y1 : Float, sizeX : Float, sizeY : Float ) : Rect2
	{
		return new Rect2( left + width * (x1 - sizeX/2), top + height * (y1 - sizeY/2),
			left + width * (x1 + sizeX/2), top + height * (y1 + sizeY/2) );
	}
	
define(`VIRTUAL',`
	public var $1(get$1,set$1) : $2;
	inline public function get$1() : $2 { $3 }
	inline public function set$1( v : $2 ) : $2 { $4 $3 }
')
	VIRTUAL(width,Float,
		return right-left;
		,
		right=left+v;
		)
	VIRTUAL(height,Float,
		return bottom-top;
		,
		bottom=top+v;
		)
	VIRTUAL(center,Point2,
		return Point2.at( ( left + right ) / 2, (top + bottom) / 2 );
		,
		)
		
	VIRTUAL(size,Point2,
		return Point2.at( right - left, bottom - top );
		,
		var ctr = getcenter();
		left = ctr.x - v.x/2;
		top = ctr.y - v.y/2;
		right = ctr.x + v.x/2;
		bottom = ctr.y + v.y/2;
		)
		
	VIRTUAL(upperLeft,Point2,
		return Point2.at( left, top );
		,
		left = v.x;
		top = v.y;
		)
		
	VIRTUAL(bottomRight,Point2,
		return Point2.at( right, bottom );
		,
		right = v.x;
		bottom = v.y;
		)
		
	/**
	 * Returns the coordinates of the corners starting at the upper Left and moving clockwise
	 */
	public function coords() : Array<Point2>
	{
		return [
			Point2.at( left, top ),
			Point2.at( right, top ),
			Point2.at( right, bottom ),
			Point2.at( left, bottom )
			];
	}
	
}