Rect.h

#ifndef NEO_RECT_H
#define NEO_RECT_H

namespace neo
{

struct Point : public POINT
{
    Point(LONG px = 0, LONG py = 0)
    {
        x = px;
        y = py;
    }

    Point(const POINT& other)
    {
        x = other.x;
        y = other.y;
    }

    void operator=(const POINT& other)
    {
        x = other.x;
        y = other.y;
    }

    bool operator==(const POINT& other) const
    {
        return x == other.x && y == other.y;
    }

    Point& ClientToScreen(HWND window)
    {
        ::ClientToScreen(window, this);
        return *this;
    }

    Point& ScreenToClient(HWND window)
    {
        ::ScreenToClient(window, this);
        return *this;
    }

    Point operator+(const POINT& other)
    {
        return Point(x + other.x, y + other.y);
    }

    Point operator-(const POINT& other)
    {
        return Point(x - other.x, y - other.y);
    }

    Point& operator+=(const POINT& other)
    {
        x += other.x;
        y += other.y;
        return *this;
    }

    Point& operator-=(const POINT& other)
    {
        x -= other.x;
        y -= other.y;
        return *this;
    }
};

struct Size : public SIZE
{
    Size(LONG width = 0, LONG height = 0)
    {
        cx = width;
        cy = height;
    }

    Size(const SIZE& other)
    {
        cx = other.cx;
        cy = other.cy;
    }

    void operator=(const SIZE& other)
    {
        cx = other.cx;
        cy = other.cy;
    }

    bool operator==(const SIZE& other) const
    {
        return cx == other.cx && cy == other.cy;
    }
};

struct Rect : public RECT
{
    Rect()
    {
        left = top = right = bottom = 0;
    }

    Rect(LONG x, LONG y, LONG width, LONG height)
    {
        left = x;
        top = y;
        right = left + width;
        bottom = top + height;
    }

    Rect(const POINT& topleft, const SIZE& size)
    {
        Set(topleft, size);
    }

    Rect(const POINT& topleft, const POINT& bottomright)
    {
        Set(topleft, bottomright);
    }

    Rect(const RECT& other)
    {
        left = other.left;
        top = other.top;
        right = other.right;
        bottom = other.bottom;
    }

    void operator=(const RECT& other)
    {
        left = other.left;
        top = other.top;
        right = other.right;
        bottom = other.bottom;
    }

    void Set(const POINT& topleft, const SIZE& size)
    {
        left = topleft.x;
        top = topleft.y;
        right = left + size.cx;
        bottom = top + size.cy;
    }

    void Set(const POINT& topleft, const POINT& bottomright)
    {
        left = topleft.x;
        top = topleft.y;
        right = bottomright.x;
        bottom = bottomright.y;
    }

    bool operator==(const RECT& other) const
    {
        return EqualRect(this, &other) != FALSE;
    }

    Point TopLeft() const
    {
        return Point(left, top);
    }

    LONG Width() const
    {
        return right - left;
    }

    LONG Height() const
    {
        return bottom - top;
    }

    Size GetSize() const
    {
        return Size(Width(), Height());
    }

    bool IsEmpty() const
    {
        return IsRectEmpty(this) != FALSE;
    }

    bool PtInRect(const POINT& p) const
    {
        return ::PtInRect(this, p) != FALSE;
    }

    Rect& Offset(int dx, int dy)
    {
        OffsetRect(this, dx, dy);
        return *this;
    }

    Rect& Inflate(int dx, int dy)
    {
        InflateRect(this, dx, dy);
        return *this;
    }

    bool Intersect(const RECT& r1, const RECT& r2)
    {
        return IntersectRect(this, &r1, &r2) != FALSE;
    }

    Rect Intersect(const RECT& other) const
    {
        Rect r;
        IntersectRect(&r, this, &other);
        return r;
    }

    bool Union(const RECT& r1, const RECT& r2)
    {
        return UnionRect(this, &r1, &r2) != FALSE;
    }

    Rect Union(const RECT& other) const
    {
        Rect r;
        UnionRect(&r, this, &other);
        return r;
    }

    Rect& ClientToScreen(HWND window)
    {
        Set(Point(left, top).ClientToScreen(window), GetSize());
        return *this;
    }

    Rect& ScreenToClient(HWND window)
    {
        Set(Point(left, top).ScreenToClient(window), GetSize());
        return *this;
    }

    static Rect DesktopRect()
    {
        return Rect(
            GetSystemMetrics(SM_XVIRTUALSCREEN), GetSystemMetrics(SM_XVIRTUALSCREEN),
            GetSystemMetrics(SM_CXVIRTUALSCREEN), GetSystemMetrics(SM_CYVIRTUALSCREEN));
    }
};

} // namespace neo

#endif