240 lines
4.3 KiB
C++
240 lines
4.3 KiB
C++
/*
|
|
* 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
|