faithtools/faith/rect.h

Go to the documentation of this file.

#ifndef KDE__RECT_H
#define KDE__RECT_H

#include <faith/point.h>
#include <faith/size.h>

namespace Faith
{
class FAITH_TOOLS_EXPORT Rect
{
        Point mTopLeft;
        Size mSize;
public:
        Rect()
                : mSize(-1, -1)
        { }
        
        Rect(int x, int y, int w, int h)
                : mTopLeft(x,y), mSize(w, h)
        { }

        Rect(int x, int y, const Size &size)
                : mTopLeft(x,y), mSize(size)
        { }

        Rect(const Point &pt, const Size &size)
                : mTopLeft(pt), mSize(size)
        { }
        
        Rect(const Point &pt, const Point &bottomRight)
                : mTopLeft(pt), mSize(bottomRight.x()-pt.x(), bottomRight.y()-pt.y())
        { }

        Rect(const Point &pt, int w, int h)
                : mTopLeft(pt), mSize(w, h)
        { }

        explicit Rect(const Size &size)
                : mSize(size)
        { }

        bool operator ==(const Rect &other) const
        {
                return
                        other.mTopLeft == mTopLeft
                        && other.mSize == mSize;
        }
        
        void operator +=(const Point &d)
        {
                mTopLeft += d;
        }
        
        Rect operator + (const Point &d) const
        {
                Rect r(*this);
                r += d;
                return r;
        }
        
        bool isInvalid() const
        {
                return (mSize.width() < 0 || mSize.height() < 0);
        }
        
        bool isValid() const { return !isInvalid(); }

        int left() const { return x(); }
        int right() const { return x()+mSize.width()-1; }

        int top() const { return y(); }
        int bottom() const { return y()+mSize.height()-1; }

        Point topLeft() const { return mTopLeft; }
        void setTopLeft(const Point &pt) { mTopLeft = pt; }
        Point bottomLeft() const { return Point(x(), y()+height()); }
        Point bottomRight() const { return Point(x()+width(), y()+height()); }
        
        void moveBy(int x, int y)
        {
                mTopLeft += Point(x, y);
        }

        int x() const { return mTopLeft.x(); }
        int y() const { return mTopLeft.y(); }

        int width() const { return mSize.width(); }
        int height() const { return mSize.height(); }

        void move(int x, int y) { mTopLeft = Point(x,y); }
        void move(const Point &pt) { mTopLeft = pt; }
        void resize(int x, int y) { mSize.resize(x,y); }
        void resize(const Size &size) { mSize = size; }
        
        bool contains(const Faith::Point &other)
        {
                return
                        (other.x() >= mTopLeft.x()) &&
                        (other.y() >= mTopLeft.y()) &&
                        (other.x() <= mTopLeft.x() + mSize.width()) &&
                        (other.y() <= mTopLeft.y() + mSize.height());
        }
        
        Point center() const { return Point(x()+width()/2, y()+height()/2); }

        Size size() const { return mSize; }
        
        void setRect(int x, int y, int w, int h)
        {
                mTopLeft = Point(x,y);
                mSize = Size(w,h);
        }
        
        void rect(int *x, int *y, int *w, int *h) const
        {
                *x = mTopLeft.x();
                *y = mTopLeft.y();
                *w = mSize.width();
                *h = mSize.height();
        }
        
        void coords(int *x, int *y, int *bx, int *by) const
        {
                *x = mTopLeft.x();
                *y = mTopLeft.y();
                *bx = bottom();
                *by = left();
        }
        
        void setCoords(int x, int y, int bx, int by)
        {
                setRect(x, y, bx-x, by-y);
        }
        
        void addCoords(int x, int y, int bx, int by)
        {
                mTopLeft += Point(x,y);
                mSize += Size(bx, by);
        }
        
        Rect unite(const Rect &other) const
        {
                Rect r;
                int ax1, ay1, ax2, ay2;
                other.coords(&ax1, &ay1, &ax2, &ay2);
                int bx1, by1, bx2, by2;
                coords(&bx1, &by1, &bx2, &by2);
                
                r.setCoords(MIN(ax1, bx1), MIN(ay1, by1), MAX(ax2, bx2), MAX(ay2, by2));
                return r;
        }
        
        void moveCenter(const Point &to)
        {
                mTopLeft = Point(to.x()*2-width(), to.y()*2-height());
        }
};

inline Rect operator+(const Point &d, const Rect &r)
{
        return r.operator+(d);
}

}

#endif

---