/*
 * Copyright 2001-2006, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Frans van Nispen
 *		Stephan Aßmus <superstippi@gmx.de>
 */

#ifndef	INT_RECT_H
#define	INT_RECT_H


#include <Region.h>

#include "IntPoint.h"

class IntRect {
 public:
			int32				left;
			int32				top;
			int32				right;
			int32				bottom;
	
								IntRect();
								IntRect(const IntRect& r);
								IntRect(const BRect& r);
								IntRect(int32 l, int32 t, int32 r, int32 b);
								IntRect(const IntPoint& lt,
										const IntPoint& rb);
	
			IntRect&			operator=(const IntRect &r);
			void				Set(int32 l, int32 t, int32 r, int32 b);
	
			void				PrintToStream() const;
	
			IntPoint			LeftTop() const;
			IntPoint			RightBottom() const;
			IntPoint			LeftBottom() const;
			IntPoint			RightTop() const;
	
			void				SetLeftTop(const IntPoint& p);
			void				SetRightBottom(const IntPoint& p);
			void				SetLeftBottom(const IntPoint& p);
			void				SetRightTop(const IntPoint& p);
	
			// transformation
			void				InsetBy(const IntPoint& p);
			void				InsetBy(int32 dx, int32 dy);
			void				OffsetBy(const IntPoint& p);
			void				OffsetBy(int32 dx, int32 dy);
			void				OffsetTo(const IntPoint& p);
			void				OffsetTo(int32 x, int32 y);
	
			// expression transformations
			IntRect&			InsetBySelf(const IntPoint& p);
			IntRect&			InsetBySelf(int32 dx, int32 dy);
			IntRect				InsetByCopy(const IntPoint& p);
			IntRect				InsetByCopy(int32 dx, int32 dy);
			IntRect&			OffsetBySelf(const IntPoint& p);
			IntRect&			OffsetBySelf(int32 dx, int32 dy);
			IntRect				OffsetByCopy(const IntPoint& p);
			IntRect				OffsetByCopy(int32 dx, int32 dy);
			IntRect&			OffsetToSelf(const IntPoint& p);
			IntRect&			OffsetToSelf(int32 dx, int32 dy);
			IntRect				OffsetToCopy(const IntPoint& p);
			IntRect				OffsetToCopy(int32 dx, int32 dy);
	
			// comparison
			bool				operator==(const IntRect& r) const;
			bool				operator!=(const IntRect& r) const;
	
			// intersection and union
			IntRect				operator&(const IntRect& r) const;
			IntRect				operator|(const IntRect& r) const;

			// conversion to BRect and clipping_rect
								operator clipping_rect() const;
								operator BRect() const
									{ return BRect(left, top,
												   right, bottom); }
	
			bool				Intersects(const IntRect& r) const;
			bool				IsValid() const;
			int32				Width() const;
			int32				IntegerWidth() const;
			int32				Height() const;
			int32				IntegerHeight() const;
			bool				Contains(const IntPoint& p) const;
			bool				Contains(const IntRect& r) const;
};


// inline definitions ----------------------------------------------------------

inline IntPoint
IntRect::LeftTop() const
{
	return *(const IntPoint*)&left;
}


inline IntPoint
IntRect::RightBottom() const
{
	return *(const IntPoint*)&right;
}


inline IntPoint
IntRect::LeftBottom() const
{
	return IntPoint(left, bottom);
}


inline IntPoint
IntRect::RightTop() const
{
	return IntPoint(right, top);
}


inline
IntRect::IntRect()
{
	top = left = 0;
	bottom = right = -1;
}


inline
IntRect::IntRect(int32 l, int32 t, int32 r, int32 b)
{
	left = l;
	top = t;
	right = r;
	bottom = b;
}


inline
IntRect::IntRect(const IntRect &r)
{
	left = r.left;
	top = r.top;
	right = r.right;
	bottom = r.bottom;
}


inline
IntRect::IntRect(const BRect &r)
{
	left = (int32)r.left;
	top = (int32)r.top;
	right = (int32)r.right;
	bottom = (int32)r.bottom;
}


inline
IntRect::IntRect(const IntPoint& leftTop, const IntPoint& rightBottom)
{
	left = leftTop.x;
	top = leftTop.y;
	right = rightBottom.x;
	bottom = rightBottom.y;
}


inline IntRect &
IntRect::operator=(const IntRect& from)
{
	left = from.left;
	top = from.top;
	right = from.right;
	bottom = from.bottom;
	return *this;
}


inline void
IntRect::Set(int32 l, int32 t, int32 r, int32 b)
{
	left = l;
	top = t;
	right = r;
	bottom = b;
}


inline bool
IntRect::IsValid() const
{
	return left <= right && top <= bottom;
}


inline int32
IntRect::IntegerWidth() const
{
	return right - left;
}


inline int32
IntRect::Width() const
{
	return right - left;
}


inline int32
IntRect::IntegerHeight() const
{
	return bottom - top;
}


inline int32
IntRect::Height() const
{
	return bottom - top;
}

inline
IntRect::operator clipping_rect() const
{
	clipping_rect r;
	r.left = left;
	r.top = top;
	r.right = right;
	r.bottom = bottom;
	return r;
}


#endif	// INT_RECT_H