456 lines
11 KiB
C++
456 lines
11 KiB
C++
|
|
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#ifndef BAGEL_BOFLIB_RECT_H
|
|
#define BAGEL_BOFLIB_RECT_H
|
|
|
|
#include "common/rect.h"
|
|
#include "bagel/afxwin.h"
|
|
#include "bagel/boflib/stdinc.h"
|
|
#include "bagel/boflib/object.h"
|
|
#include "bagel/boflib/point.h"
|
|
#include "bagel/boflib/size.h"
|
|
|
|
namespace Bagel {
|
|
|
|
class CBofRect : public CBofObject {
|
|
public:
|
|
// Constructors
|
|
CBofRect();
|
|
CBofRect(int l, int t, int r, int b);
|
|
CBofRect(const CBofRect &srcRect);
|
|
CBofRect(const CBofPoint &point, const CBofSize &size);
|
|
CBofRect(const CBofPoint &pttopLeft, const CBofPoint &ptBottomRight);
|
|
virtual ~CBofRect() {
|
|
}
|
|
|
|
// Attributes
|
|
int width() const;
|
|
int height() const;
|
|
CBofSize size() const;
|
|
CBofPoint topLeft() const;
|
|
CBofPoint bottomRight() const;
|
|
|
|
CBofPoint topRight() const;
|
|
CBofPoint bottomLeft() const;
|
|
|
|
bool isRectEmpty() const;
|
|
bool isRectNull() const;
|
|
bool ptInRect(const CBofPoint &point) const;
|
|
|
|
// Operations
|
|
|
|
inline void setRect(int x1, int y1, int x2, int y2);
|
|
void setRectEmpty();
|
|
void copyRect(const CBofRect &cRect);
|
|
bool equalRect(const CBofRect &cRect);
|
|
|
|
CBofRect(const RECT &cRect) {
|
|
setWinRect(&cRect);
|
|
}
|
|
CBofRect(const RECT *pRect) {
|
|
setWinRect(pRect);
|
|
}
|
|
|
|
void setWinRect(const RECT *pRect);
|
|
RECT getWinRect();
|
|
|
|
void operator=(const RECT &srcRect) {
|
|
setWinRect(&srcRect);
|
|
}
|
|
void operator=(const Common::Rect &srcRect) {
|
|
const RECT r = { srcRect.left, srcRect.top, srcRect.right, srcRect.bottom };
|
|
setWinRect(&r);
|
|
}
|
|
|
|
operator const RECT() {
|
|
return getWinRect();
|
|
}
|
|
operator const Common::Rect() {
|
|
return Common::Rect(left, top, right, bottom);
|
|
}
|
|
|
|
void offsetRect(int x, int y);
|
|
void offsetRect(const CBofSize &size);
|
|
void offsetRect(const CBofPoint &point);
|
|
|
|
// Operations that fill '*this' with result
|
|
bool intersectRect(const CBofRect *pRect1, const CBofRect *pRect2);
|
|
bool intersectRect(const CBofRect &cRect1, const CBofRect &cRect2);
|
|
bool unionRect(const CBofRect *pRect1, const CBofRect *pRect2);
|
|
|
|
// Additional Operations
|
|
void operator=(const CBofRect &srcRect);
|
|
bool operator==(const CBofRect &rect);
|
|
bool operator!=(const CBofRect &rect);
|
|
void operator+=(const CBofPoint &point);
|
|
void operator-=(const CBofPoint &point);
|
|
void operator&=(const CBofRect &rect);
|
|
void operator|=(const CBofRect &rect);
|
|
|
|
// Operators returning CBofRect values
|
|
CBofRect operator+(const CBofPoint &point);
|
|
CBofRect operator-(const CBofPoint &point);
|
|
CBofRect operator&(const CBofRect &rect2);
|
|
CBofRect operator|(const CBofRect &rect2);
|
|
|
|
int left;
|
|
int top;
|
|
int right;
|
|
int bottom;
|
|
};
|
|
|
|
inline CBofRect::CBofRect() {
|
|
top = left = 0;
|
|
right = bottom = -1;
|
|
}
|
|
|
|
inline CBofRect::CBofRect(int l, int t, int r, int b) {
|
|
left = l;
|
|
top = t;
|
|
right = r;
|
|
bottom = b;
|
|
}
|
|
|
|
inline CBofRect::CBofRect(const CBofRect &srcRect) {
|
|
left = srcRect.left;
|
|
top = srcRect.top;
|
|
right = srcRect.right;
|
|
bottom = srcRect.bottom;
|
|
}
|
|
|
|
inline CBofRect::CBofRect(const CBofPoint &point, const CBofSize &size) {
|
|
right = (left = point.x) + size.cx - 1;
|
|
bottom = (top = point.y) + size.cy - 1;
|
|
}
|
|
|
|
inline CBofRect::CBofRect(const CBofPoint &pttopLeft, const CBofPoint &ptBottomRight) {
|
|
setRect(pttopLeft.x, pttopLeft.y, ptBottomRight.x, ptBottomRight.y);
|
|
}
|
|
|
|
inline int CBofRect::width() const {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
return right - left + 1;
|
|
}
|
|
|
|
inline int CBofRect::height() const {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
return bottom - top + 1;
|
|
}
|
|
|
|
inline CBofSize CBofRect::size() const {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
return CBofSize(width(), height());
|
|
}
|
|
|
|
inline CBofPoint CBofRect::topLeft() const {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
return CBofPoint(left, top);
|
|
}
|
|
|
|
inline CBofPoint CBofRect::bottomRight() const {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
return CBofPoint(right, bottom);
|
|
}
|
|
|
|
inline CBofPoint CBofRect::topRight() const {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
return CBofPoint(right, top);
|
|
}
|
|
|
|
inline CBofPoint CBofRect::bottomLeft() const {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
return CBofPoint(left, bottom);
|
|
}
|
|
|
|
inline bool CBofRect::isRectEmpty() const {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
return (width() <= 0 || height() <= 0);
|
|
}
|
|
|
|
inline bool CBofRect::isRectNull() const {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
return (left == 0 && right == 0 && top == 0 && bottom == 0);
|
|
}
|
|
|
|
inline bool CBofRect::ptInRect(const CBofPoint &point) const {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
return (point.x >= left && point.x <= right && point.y >= top && point.y <= bottom);
|
|
}
|
|
|
|
inline void CBofRect::setRect(int x1, int y1, int x2, int y2) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
left = x1;
|
|
top = y1;
|
|
right = x2;
|
|
bottom = y2;
|
|
}
|
|
|
|
inline void CBofRect::setRectEmpty() {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
left = top = 0;
|
|
right = bottom = -1;
|
|
|
|
// Verify that the rectangle is now empty
|
|
assert(isRectEmpty());
|
|
}
|
|
|
|
inline void CBofRect::copyRect(const CBofRect &cSrcRect) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
assert(isValidObject(&cSrcRect));
|
|
|
|
left = cSrcRect.left;
|
|
right = cSrcRect.right;
|
|
top = cSrcRect.top;
|
|
bottom = cSrcRect.bottom;
|
|
}
|
|
|
|
inline bool CBofRect::equalRect(const CBofRect &cRect) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
assert(isValidObject(&cRect));
|
|
|
|
return (left == cRect.left && right == cRect.right && top == cRect.top && bottom == cRect.bottom);
|
|
}
|
|
|
|
inline RECT CBofRect::getWinRect() {
|
|
assert(isValidObject(this));
|
|
|
|
RECT stRect;
|
|
|
|
stRect.left = left;
|
|
stRect.top = top;
|
|
stRect.right = right + 1;
|
|
stRect.bottom = bottom + 1;
|
|
|
|
return stRect;
|
|
}
|
|
|
|
inline void CBofRect::setWinRect(const RECT *pRect) {
|
|
assert(isValidObject(this));
|
|
|
|
assert(pRect != nullptr);
|
|
|
|
left = pRect->left;
|
|
top = pRect->top;
|
|
right = pRect->right - 1;
|
|
bottom = pRect->bottom - 1;
|
|
}
|
|
|
|
inline void CBofRect::offsetRect(int x, int y) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
left += x;
|
|
right += x;
|
|
top += y;
|
|
bottom += y;
|
|
}
|
|
|
|
inline void CBofRect::offsetRect(const CBofPoint &point) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
left += point.x;
|
|
right += point.x;
|
|
top += point.y;
|
|
bottom += point.y;
|
|
}
|
|
|
|
inline void CBofRect::offsetRect(const CBofSize &size) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
left += size.cx;
|
|
right += size.cx;
|
|
top += size.cy;
|
|
bottom += size.cy;
|
|
}
|
|
|
|
inline bool CBofRect::intersectRect(const CBofRect *pRect1, const CBofRect *pRect2) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
// Can't access null pointers
|
|
assert(pRect1 != nullptr);
|
|
assert(pRect2 != nullptr);
|
|
|
|
left = MAX(pRect1->left, pRect2->left);
|
|
top = MAX(pRect1->top, pRect2->top);
|
|
right = MIN(pRect1->right, pRect2->right);
|
|
bottom = MIN(pRect1->bottom, pRect2->bottom);
|
|
|
|
return ((width() > 0) && (height() > 0));
|
|
}
|
|
|
|
inline bool CBofRect::intersectRect(const CBofRect &cRect1, const CBofRect &cRect2) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
return intersectRect(&cRect1, &cRect2);
|
|
}
|
|
|
|
inline bool CBofRect::unionRect(const CBofRect *pRect1, const CBofRect *pRect2) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
// Can't access null pointers
|
|
assert(pRect1 != nullptr);
|
|
assert(pRect2 != nullptr);
|
|
|
|
left = MIN(pRect1->left, pRect2->left);
|
|
top = MIN(pRect1->top, pRect2->top);
|
|
right = MAX(pRect1->right, pRect2->right);
|
|
bottom = MAX(pRect1->bottom, pRect2->bottom);
|
|
|
|
return isRectEmpty();
|
|
}
|
|
|
|
inline void CBofRect::operator=(const CBofRect &srcRect) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
left = srcRect.left;
|
|
right = srcRect.right;
|
|
top = srcRect.top;
|
|
bottom = srcRect.bottom;
|
|
}
|
|
|
|
inline bool CBofRect::operator==(const CBofRect &rect) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
return (left == rect.left && right == rect.right &&
|
|
top == rect.top && bottom == rect.bottom);
|
|
}
|
|
|
|
inline bool CBofRect::operator!=(const CBofRect &rect) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
return (left != rect.left || right != rect.right ||
|
|
top != rect.top || bottom != rect.bottom);
|
|
}
|
|
|
|
inline void CBofRect::operator+=(const CBofPoint &point) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
offsetRect(point);
|
|
}
|
|
|
|
inline void CBofRect::operator-=(const CBofPoint &point) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
offsetRect(-point.x, -point.y);
|
|
}
|
|
|
|
inline void CBofRect::operator&=(const CBofRect &rect) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
intersectRect(this, &rect);
|
|
}
|
|
|
|
inline void CBofRect::operator|=(const CBofRect &rect) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
unionRect(this, &rect);
|
|
}
|
|
|
|
inline CBofRect CBofRect::operator+(const CBofPoint &pt) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
CBofRect rect(*this);
|
|
|
|
rect.offsetRect(pt.x, pt.y);
|
|
|
|
return rect;
|
|
}
|
|
|
|
inline CBofRect CBofRect::operator-(const CBofPoint &pt) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
CBofRect rect(*this);
|
|
|
|
rect.offsetRect(-pt.x, -pt.y);
|
|
|
|
return rect;
|
|
}
|
|
|
|
inline CBofRect CBofRect::operator&(const CBofRect &rect2) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
CBofRect rect;
|
|
|
|
rect.intersectRect(this, &rect2);
|
|
|
|
return rect;
|
|
}
|
|
|
|
inline CBofRect CBofRect::operator|(const CBofRect &rect2) {
|
|
// Make sure object is not used after it is destructed
|
|
assert(isValidObject(this));
|
|
|
|
CBofRect rect;
|
|
|
|
rect.unionRect(this, &rect2);
|
|
|
|
return rect;
|
|
}
|
|
|
|
} // namespace Bagel
|
|
|
|
#endif
|