point.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_POINT_H
#define BAGEL_BOFLIB_POINT_H
 
#include "bagel/afxwin.h"
#include "bagel/boflib/stdinc.h"
#include "bagel/boflib/object.h"
 
namespace Bagel {
 
class CBofPoint : public StPoint, public CBofObject {
public:
    // Constructors
    CBofPoint();
    CBofPoint(int initX, int initY);
    CBofPoint(StPoint stPoint);
    CBofPoint(const CBofPoint &cPoint);
    CBofPoint(const StSize &stSize);
    CBofPoint(const Common::Point &pt);
 
    CBofPoint(const POINT &stPoint) {
        setWinPoint(&stPoint);
    }
    virtual ~CBofPoint() {
    }
 
    void setWinPoint(const POINT *pPoint);
    POINT GetWinPoint() const;
 
    void operator=(const POINT &stPoint) {
        setWinPoint(&stPoint);
    }
 
    operator const POINT() {
        return GetWinPoint();
    }
 
 
    // Operations
    void offset(int xOffset, int yOffset);
    void offset(StPoint point);
    void offset(StSize size);
    void operator=(const StPoint &point);
    void operator=(const CBofPoint &point);
    bool operator==(StPoint point) const;
    bool operator!=(StPoint point) const;
    void operator+=(StSize size);
    void operator-=(StSize size);
    void operator+=(StPoint point);
    void operator-=(StPoint point);
 
    // Operators returning CBofPoint values
    CBofPoint operator+(StSize size) const;
    CBofPoint operator+(StPoint point) const;
    CBofPoint operator-(StSize size) const;
    CBofPoint operator-(StPoint point) const;
    CBofPoint operator-() const;
};
 
// CBofPoint
inline CBofPoint::CBofPoint() {
    x = 0;
    y = 0;
}
 
inline CBofPoint::CBofPoint(const int initX, const int initY) {
    x = initX;
    y = initY;
}
 
inline CBofPoint::CBofPoint(const StPoint stPoint) {
    x = stPoint.x;
    y = stPoint.y;
}
 
inline CBofPoint::CBofPoint(const StSize &stSize) {
    x = stSize.cx;
    y = stSize.cy;
}
 
inline CBofPoint::CBofPoint(const CBofPoint &cPoint) {
    x = cPoint.x;
    y = cPoint.y;
}
 
inline CBofPoint::CBofPoint(const Common::Point &pt) {
    x = pt.x;
    y = pt.y;
}
 
inline void CBofPoint::setWinPoint(const POINT *pPoint) {
    assert(pPoint != nullptr);
    assert(isValidObject(this));
 
    x = pPoint->x;
    y = pPoint->y;
}
 
inline POINT CBofPoint::GetWinPoint() const {
    assert(isValidObject(this));
 
    POINT stPoint;
 
    stPoint.x = x;
    stPoint.y = y;
 
    return stPoint;
}
 
inline void CBofPoint::offset(int xOffset, int yOffset) {
    // Make sure object is not used after it is destructed
    assert(isValidObject(this));
 
    x += xOffset;
    y += yOffset;
}
 
inline void CBofPoint::offset(StPoint point) {
    // Make sure object is not used after it is destructed
    assert(isValidObject(this));
 
    x += point.x;
    y += point.y;
}
 
inline void CBofPoint::offset(StSize size) {
    // Make sure object is not used after it is destructed
    assert(isValidObject(this));
 
    x += size.cx;
    y += size.cy;
}
 
inline void CBofPoint::operator=(const StPoint &point) {
    // Make sure object is not used after it is destructed
    assert(isValidObject(this));
 
    x = point.x;
    y = point.y;
}
 
inline void CBofPoint::operator=(const CBofPoint &point) {
    // Make sure object is not used after it is destructed
    assert(isValidObject(this));
 
    x = point.x;
    y = point.y;
}
 
inline bool CBofPoint::operator==(StPoint point) const {
    // Make sure object is not used after it is destructed
    assert(isValidObject(this));
 
    return (x == point.x && y == point.y);
}
 
inline bool CBofPoint::operator!=(StPoint point) const {
    // Make sure object is not used after it is destructed
    assert(isValidObject(this));
 
    return (x != point.x || y != point.y);
}
 
inline void CBofPoint::operator+=(StSize size) {
    // Make sure object is not used after it is destructed
    assert(isValidObject(this));
 
    x += size.cx;
    y += size.cy;
}
 
inline void CBofPoint::operator+=(StPoint point) {
    // Make sure object is not used after it is destructed
    assert(isValidObject(this));
 
    x += point.x;
    y += point.y;
}
 
inline void CBofPoint::operator-=(StPoint point) {
    // Make sure object is not used after it is destructed
    assert(isValidObject(this));
 
    x -= point.x;
    y -= point.y;
}
 
inline void CBofPoint::operator-=(StSize size) {
    // Make sure object is not used after it is destructed
    assert(isValidObject(this));
 
    x -= size.cx;
    y -= size.cy;
}
 
inline CBofPoint CBofPoint::operator+(StSize size) const {
    // Make sure object is not used after it is destructed
    assert(isValidObject(this));
 
    return CBofPoint(x + size.cx, y + size.cy);
}
 
inline CBofPoint CBofPoint::operator+(StPoint point) const {
    // Make sure object is not used after it is destructed
    assert(isValidObject(this));
 
    return CBofPoint(x + point.x, y + point.y);
}
 
inline CBofPoint CBofPoint::operator-(StSize size) const {
    // Make sure object is not used after it is destructed
    assert(isValidObject(this));
 
    return CBofPoint(x - size.cx, y - size.cy);
}
 
inline CBofPoint CBofPoint::operator-(StPoint point) const {
    // Make sure object is not used after it is destructed
    assert(isValidObject(this));
 
    return CBofPoint(x - point.x, y - point.y);
}
 
inline CBofPoint CBofPoint::operator-() const {
    // Make sure object is not used after it is destructed
    assert(isValidObject(this));
 
    return CBofPoint(-x, -y);
}
 
} // namespace Bagel
 
#endif