Initial commit

engines/bagel/boflib/rect.h

@@ -0,0 +1,455 @@
+
+/* 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