rect.h

/* 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