Сборник классов для работы с графикой

struct Point
{
    int x, y;
    Point() : x(0), y(0) {}
    Point(int x, int y) : x(x), y(y) {}
    Point(const POINT& point) : x(point.x), y(point.y) {}
    Point(const Point& point) : x(point.x), y(point.y) {}
    POINT tagPOINT() { return { x, y }; }
    Point& operator = (const POINT& pt) { return x = pt.x, y = pt.y, *this; }
    Point& operator = (const Point& pt) { return x = pt.x, y = pt.y, *this; }
    bool operator == (const POINT& pt) { return x == pt.x && y == pt.y; }
    bool operator == (const Point& pt) { return x == pt.x && y == pt.y; }
};
 
struct Rect
{
    int left, top, right, bottom;
    Rect() : left(0), top(0), right(0), bottom(0) {}
    Rect(int left, int top, int right, int bottom) : left(left), top(top), right(right), bottom(bottom) {}
    Rect(const POINT& lt, const Point& rb) : left(lt.x), top(lt.y), right(rb.x), bottom(rb.y) {}
    Rect(const Point& lt, const Point& rb) : left(lt.x), top(lt.y), right(rb.x), bottom(rb.y) {}
    Rect(const RECT& rect) : left(rect.left), top(rect.top), right(rect.right), bottom(rect.bottom) {}
    Rect(const Rect& rect) : left(rect.left), top(rect.top), right(rect.right), bottom(rect.bottom) {}
    RECT tagRECT() { return { left, top, right, bottom }; }
    Point LeftTop() { return Point(left, top); }
    Point RightBottom() { return Point(right, bottom); }
    int width() { return right - left; }
    int height() { return bottom - top; }
    Rect& operator = (const RECT& rc) { return left = rc.left, top = rc.top, right = rc.right, bottom = rc.bottom, *this; }
    Rect& operator = (const Rect& rc) { return left = rc.left, top = rc.top, right = rc.right, bottom = rc.bottom, *this; }
    bool operator == (const RECT& rc) { return left == rc.left && top == rc.top && right == rc.right && bottom == rc.bottom; }
    bool operator == (const Rect& rc) { return left == rc.left && top == rc.top && right == rc.right && bottom == rc.bottom; }  
};
 
struct HRGB
{
    unsigned char r, g, b;
    HRGB() : r(0), g(0), b(0) {}
    HRGB(unsigned char r, unsigned char g, unsigned char b) : r(r), g(g), b(b) {}
    HRGB(COLORREF color) : r(GetRValue(color)), g(GetGValue(color)), b(GetBValue(color)) {}
    HRGB(const HRGB& rgb) : r(rgb.r), g(rgb.g), b(rgb.b) {}
    COLORREF color() { return RGB(r, g, b); }
    HRGB& operator = (COLORREF color)
    {
        r = GetRValue(color);
        g = GetGValue(color);
        b = GetBValue(color);
        return *this;
    }
    HRGB& operator = (const HRGB& rgb) { return r = rgb.r, g = rgb.g, b = rgb.b, *this; }
    bool operator == (const HRGB& rgb) { return r == rgb.r && g == rgb.g && b == rgb.b; }
};

class Font
{
private:
    HFONT m_font;
    HDC m_dc;
    std::string m_name;
    unsigned m_size;
    bool m_bold;
    bool m_italic;
    bool m_underline;
    bool m_strikeout;
    double m_orientation;
    COLORREF m_color;
    DWORD m_charset;
 
    void update()
    {
        SetTextColor(m_dc, m_color);
        m_font = CreateFont( m_size,
                             0,
                             static_cast<int>(m_orientation * 10),
                             0,
                             m_bold ? FW_BOLD : FW_NORMAL,
                             m_italic,
                             m_underline,
                             m_strikeout,
                             m_charset,
                             OUT_DEFAULT_PRECIS,
                             CLIP_DEFAULT_PRECIS,
                             PROOF_QUALITY,
                             DEFAULT_PITCH | FF_DONTCARE,
                             AnsiStringToWide(m_name).c_str());
        SelectObject(m_dc, m_font);
    }
public:
    Font(HDC dc = 0)
    {
        m_font = 0;
        m_dc = dc;
        m_name = "";
        m_size = 20;
        m_bold = false;
        m_italic = false;
        m_strikeout = false;
        m_underline = false;
        m_orientation = 0;
        m_color = 0x000000;
        m_charset = DEFAULT_CHARSET;
        SetBkMode(m_dc, TRANSPARENT);
        update();
    }
 
    HFONT HFONT() { return m_font; };
 
    HDC SetDC(HDC value) { return m_dc = value, update(), m_dc; }
    __declspec(property(get = m_dc, put = SetDC)) HDC dc;
 
    DWORD SetCharset(DWORD value) { m_charset = value, update(); }
    __declspec(property(get = m_charset, put = SetCharset)) DWORD charset;
 
    COLORREF SetColor(COLORREF value) { return m_color = value, update(), m_color; }
    __declspec(property(get = m_color, put = SetColor)) COLORREF color;
 
    unsigned SetSize(unsigned value) { return m_size = value, update(), m_size; }
    __declspec(property(get = m_size, put = SetSize)) unsigned size;
 
    const std::string& SetName(const std::string& value) { return m_name = value, update(), m_name; }
    __declspec(property(get = m_name, put = SetName)) const std::string& name;
 
    bool SetBold(bool value) { return m_bold = value, update(), m_bold; }
    __declspec(property(get = m_bold, put = SetBold)) bool bold;
 
    bool SetItalic(bool value) { return m_italic = value, update(), m_italic; }
    __declspec(property(get = m_italic, put = SetItalic)) bool italic;
 
    bool SetUnderline(bool value) { return m_underline = value, update(), m_underline; }
    __declspec(property(get = m_underline, put = SetUnderline)) bool underline;
 
    bool SetStrikeout(bool value) { return m_strikeout = value, update(), m_strikeout; }
    __declspec(property(get = m_strikeout, put = SetStrikeout)) bool strikeout;
 
    double SetOrientation(double value) { return m_orientation = value, update(), m_orientation; }
    __declspec(property(get = m_orientation, put = SetOrientation)) bool orientation;
};

//Класс определяет точку в двухмерной системе координат
template <typename T>
struct Point
{
    //Координаты точки
    T x, y;
 
    //Конструктор по умолчанию
    Point()
    {
        if (!std::is_arithmetic<T>::value)
            throw std::exception("Type is not arithmetical");
        else
            x = 0, y = 0;
    }
 
    //Конструктор, задающий координаты
    Point(T x, T y)
    {
        if (!std::is_arithmetic<T>::value)
            throw std::exception("Type is not arithmetical");
        else
            this->x = x, this->y = y;
    }
 
    //Конструктор копирования из объекта POINT
    Point(const POINT& point)
    {
        if (!std::is_arithmetic<T>::value)
            throw std::exception("Type is not arithmetical");
        else
            x = point.x, y = point.y;
    }
 
    //Конструктор копирования из объекта Point
    Point(const Point& point)
    {
        if (!std::is_arithmetic<T>::value)
            throw std::exception("Type is not arithmetical");
        else
            x = point.x, y = point.y;
    }
 
    //Функция возвращает объект POINT с координатами текущего объекта
    POINT tagPOINT() const { return { x, y }; }
 
    //Перегруженный оператор = для объекта POINT
    Point<T> &operator = (const POINT& pt)
    {
        x = pt.x, y = pt.y;
        return *this;
    }
 
    //Перегруженный оператор = для объекта Point
    Point<T> &operator = (const Point& pt)
    {
        x = pt.x, y = pt.y;
        return *this;
    }
 
    //Перегруженный оператор == для объекта POINT
    bool operator == (const POINT& pt) const
    {
        return x == pt.x && y == pt.y;
    }
 
    //Перегруженный оператор == для объекта Point
    bool operator == (const Point<T> &pt) const
    {
        return x == pt.x && y == pt.y;
    }
};
 
//Класс определяет область в двухмерной системе координат
template <typename T>
struct Rect
{
    //Координаты области
    T left, top, right, bottom;
 
    //Конструктор по умолчанию
    Rect()
    {
        if (!std::is_arithmetic<T>::value)
            throw std::exception("Type is not arithmetical");
        else
            left = 0, top = 0, right = 0, bottom = 0;
    }
 
    //Конструктор, задающий координаты
    Rect(T left, T top, T right, T bottom)
    {
        if (!std::is_arithmetic<T>::value)
            throw std::exception("Type is not arithmetical");
        else
            this->left = left, this->top = top, this->right = right, this->bottom = bottom;
    }
 
    //Конструктор, задающий координаты из двух точек класса POINT
    Rect(const POINT& lt, const POINT& rb)
    {
        if (!std::is_arithmetic<T>::value)
            throw std::exception("Type is not arithmetical");
        else
            left = lt.x, top = lt.y, right = rb.x, bottom = rb.y;
    }
 
    //Конструктор, задающий координаты из двух точек класса Point
    Rect(const Point<T> &lt, const Point<T> &rb)
    {
        if (!std::is_arithmetic<T>::value)
            throw std::exception("Type is not arithmetical");
        else
            left = lt.x, top = lt.y, right = rb.x, bottom = rb.y;
    }
 
    //Конструктор копирования из объекта RECT
    Rect(const RECT& rect)
    {
        if (!std::is_arithmetic<T>::value)
            throw std::exception("Type is not arithmetical");
        else
            left = rect.left top = rect.top, right = rect.right, bottom = rect.bottom;
    }
 
    //Конструктор копирования из объекта Rect
    Rect(const Rect<T> &rect)
    {
        if (!std::is_arithmetic<T>::value)
            throw std::exception("Type is not arithmetical");
        else
            left = rect.left top = rect.top, right = rect.right, bottom = rect.bottom;
    }
 
    //Функция возвращает объект RECT с координатами текущего объекта
    RECT tagRECT() const { return { left, top, right, bottom }; }
 
    //Функция возвращает объект Point, с координатами левой верхней точки области
    Point<T> LeftTop() const { return Point<T>(left, top); }
 
    //Функция возвращает объект Point, с координатами правой нижей точки области
    Point<T> RightBottom() const { return Point<T>(right, bottom); }
 
    //Функция возвращает ширину области
    T width() const { return right - left; }
 
    //Функция возвращает высоту области
    T height() const { return bottom - top; }
 
    //Перегруженный оператор = для объекта RECT
    Rect<T> &operator = (const RECT& rc)
    {
        left = rc.left, top = rc.top, right = rc.right, bottom = rc.bottom;
        return *this;
    }
 
    //Перегруженный оператор = для объекта Rect
    Rect<T> &operator = (const Rect<T> &rc)
    {
        left = rc.left, top = rc.top, right = rc.right, bottom = rc.bottom;
        return *this;
    }
 
    //Перегруженный оператор == для объекта RECT
    bool operator == (const RECT& rc) const
    {
        return left == rc.left && top == rc.top && right == rc.right && bottom == rc.bottom;
    }
 
    //Перегруженный оператор == для объекта Rect
    bool operator == (const Rect<T> &rc) const
    {
        return left == rc.left && top == rc.top && right == rc.right && bottom == rc.bottom;
    }
};
 
//Класс определяет составляющие цвета в системе RGB
struct HRGB
{
    //Составляющие цвета
    unsigned char r, g, b;
 
    //Конструктор по умолчанию
    HRGB() : r(0), g(0), b(0) {}
 
    //Конструктор, задающий составляющие цвета
    HRGB(unsigned char r, unsigned char g, unsigned char b) : r(r), g(g), b(b) {}
 
    //Конструктор, задающий составляющие цвета из значения типа COLORREF
    HRGB(COLORREF color) : r(GetRValue(color)), g(GetGValue(color)), b(GetBValue(color)) {}
 
    //Конструктор копирования из объекта HRGB
    HRGB(const HRGB& rgb) : r(rgb.r), g(rgb.g), b(rgb.b) {}
 
    //Функция возвращает значение цвета типа HRGB, соответствующее составляющим
    COLORREF color() const { return RGB(r, g, b); }
 
    //Перегруженный оператор = для значения типа COLORREF
    HRGB& operator = (COLORREF color)
    {
        r = GetRValue(color);
        g = GetGValue(color);
        b = GetBValue(color);
        return *this;
    }
 
    //Перегруженный оператор = для объекта HRGB
    HRGB& operator = (const HRGB& rgb) { return r = rgb.r, g = rgb.g, b = rgb.b, *this; }
 
    //Перегруженный оператор == для объекта HRGB
    bool operator == (const HRGB& rgb) const { return r == rgb.r && g == rgb.g && b == rgb.b; }
};

#include <iostream>
#include <type_traits>
 
template<typename T>
struct Test {
    static_assert(std::is_arithmetic<T>::value, "T must be arithmetic type");   
};
 
int main() {
    // Ok
    Test<int> obj;
    
    // Compilation error
    // Test<std::ostream> obj2;
}

//Класс определяет точку в двухмерной системе координат
template <typename T>
struct Point
{
    static_assert(std::is_arithmetic<T>::value, "Type is not arithmetical");
 
    //Координаты точки
    T x, y;
 
    //Конструктор по умолчанию
    Point() : x(0), y(0) {}
 
    //Конструктор, задающий координаты
    Point(T x, T y) : x(x), y(y) {}
 
    //Конструктор копирования из объекта POINT
    Point(const POINT& point) : x(point.x), y(point.y) {}
 
    //Конструктор копирования из объекта Point
    Point(const Point& point) : x(point.x), y(point.y) {}
 
    //Функция возвращает объект POINT с координатами текущего объекта
    POINT tagPOINT() const { return { x, y }; }
 
    //Перегруженный оператор = для объекта POINT
    Point<T> &operator = (const POINT& pt)
    {
        x = pt.x, y = pt.y;
        return *this;
    }
 
    //Перегруженный оператор = для объекта Point
    Point<T> &operator = (const Point& pt)
    {
        x = pt.x, y = pt.y;
        return *this;
    }
 
    //Перегруженный оператор == для объекта POINT
    bool operator == (const POINT& pt) const
    {
        return x == pt.x && y == pt.y;
    }
 
    //Перегруженный оператор == для объекта Point
    bool operator == (const Point<T> &pt) const
    {
        return x == pt.x && y == pt.y;
    }
};
 
//Класс определяет область в двухмерной системе координат
template <typename T>
struct Rect
{
    static_assert(std::is_arithmetic<T>::value, "Type is not arithmetical");
 
    //Координаты области
    T left, top, right, bottom;
 
    //Конструктор по умолчанию
    Rect() : left(0), top(0), right(0), bottom(0) {}
 
    //Конструктор, задающий координаты
    Rect(T left, T top, T right, T bottom) : left(left), top(top), right(right), bottom(bottom) {}
 
    //Конструктор, задающий координаты из двух точек класса POINT
    Rect(const POINT& lt, const POINT& rb) : left(lt.x), top(lt.y), right(rb.x), bottom(rb.y) {}
 
    //Конструктор, задающий координаты из двух точек класса Point
    Rect(const Point<T> &lt, const Point<T> &rb) : left(lt.x), top(lt.y), right(rb.x), bottom(rb.y) {}
 
    //Конструктор копирования из объекта RECT
    Rect(const RECT& rect) : left(rect.left), top(rect.top), right(rect.right), bottom(rect.bottom) {}
 
    //Конструктор копирования из объекта Rect
    Rect(const Rect<T> &rect) : left(rect.left), top(rect.top), right(rect.right), bottom(rect.bottom) {}
 
    //Функция возвращает объект RECT с координатами текущего объекта
    RECT tagRECT() const { return { left, top, right, bottom }; }
 
    //Функция возвращает объект Point, с координатами левой верхней точки области
    Point<T> LeftTop() const { return Point<T>(left, top); }
 
    //Функция возвращает объект Point, с координатами правой нижей точки области
    Point<T> RightBottom() const { return Point<T>(right, bottom); }
 
    //Функция возвращает ширину области
    T width() const { return right - left; }
 
    //Функция возвращает высоту области
    T height() const { return bottom - top; }
 
    //Перегруженный оператор = для объекта RECT
    Rect<T> &operator = (const RECT& rc)
    {
        left = rc.left, top = rc.top, right = rc.right, bottom = rc.bottom;
        return *this;
    }
 
    //Перегруженный оператор = для объекта Rect
    Rect<T> &operator = (const Rect<T> &rc)
    {
        left = rc.left, top = rc.top, right = rc.right, bottom = rc.bottom;
        return *this;
    }
 
    //Перегруженный оператор == для объекта RECT
    bool operator == (const RECT& rc) const
    {
        return left == rc.left && top == rc.top && right == rc.right && bottom == rc.bottom;
    }
 
    //Перегруженный оператор == для объекта Rect
    bool operator == (const Rect<T> &rc) const
    {
        return left == rc.left && top == rc.top && right == rc.right && bottom == rc.bottom;
    }
};
 
//Класс определяет составляющие цвета в системе RGB
struct HRGB
{
    //Составляющие цвета
    unsigned char r, g, b;
 
    //Конструктор по умолчанию
    HRGB() : r(0), g(0), b(0) {}
 
    //Конструктор, задающий составляющие цвета
    HRGB(unsigned char r, unsigned char g, unsigned char b) : r(r), g(g), b(b) {}
 
    //Конструктор, задающий составляющие цвета из значения типа COLORREF
    HRGB(COLORREF color) : r(GetRValue(color)), g(GetGValue(color)), b(GetBValue(color)) {}
 
    //Конструктор копирования из объекта HRGB
    HRGB(const HRGB& rgb) : r(rgb.r), g(rgb.g), b(rgb.b) {}
 
    //Функция возвращает значение цвета типа HRGB, соответствующее составляющим
    COLORREF color() const { return RGB(r, g, b); }
 
    //Перегруженный оператор = для значения типа COLORREF
    HRGB& operator = (COLORREF color)
    {
        r = GetRValue(color);
        g = GetGValue(color);
        b = GetBValue(color);
        return *this;
    }
 
    //Перегруженный оператор = для объекта HRGB
    HRGB& operator = (const HRGB& rgb)
    {
        r = rgb.r, g = rgb.g, b = rgb.b;
        return *this;
    }
 
    //Перегруженный оператор == для объекта HRGB
    bool operator == (const HRGB& rgb) const
    {
        return r == rgb.r && g == rgb.g && b == rgb.b;
    }
};

class Font
{
private:
    HFONT m_font;
    HDC m_dc;
    std::string m_name;
    unsigned m_size;
    bool m_bold;
    bool m_italic;
    bool m_underline;
    bool m_strikeout;
    double m_orientation;
    COLORREF m_color;
    DWORD m_charset;
 
    void update()
    {
        SetTextColor(m_dc, m_color);
        DeleteObject(m_font);
        m_font = CreateFont( m_size,
                             0,
                             static_cast<int>(m_orientation * 10),
                             0,
                             m_bold ? FW_BOLD : FW_NORMAL,
                             m_italic,
                             m_underline,
                             m_strikeout,
                             m_charset,
                             OUT_DEFAULT_PRECIS,
                             CLIP_DEFAULT_PRECIS,
                             PROOF_QUALITY,
                             DEFAULT_PITCH | FF_DONTCARE,
                             AnsiStringToWide(m_name).c_str());
        SelectObject(m_dc, m_font);
    }
public:
    explicit Font(HDC dc = 0)
    {
        m_font = 0;
        m_dc = dc;
        m_name = "";
        m_size = 20;
        m_bold = false;
        m_italic = false;
        m_strikeout = false;
        m_underline = false;
        m_orientation = 0;
        m_color = 0x000000;
        m_charset = DEFAULT_CHARSET;
        SetBkMode(m_dc, TRANSPARENT);
        update();
    }
 
    ~Font() { DeleteObject(m_font); }
 
    HFONT SetFont(HFONT font) { return m_font = font, SelectObject(m_dc, m_font), m_font; }
    __declspec(property(get = m_font, put = SetFont)) HFONT hfont;
 
    HDC SetDC(HDC value) { return m_dc = value, update(), m_dc; }
    __declspec(property(get = m_dc, put = SetDC)) HDC dc;
 
    DWORD SetCharset(DWORD value) { m_charset = value, update(); }
    __declspec(property(get = m_charset, put = SetCharset)) DWORD charset;
 
    COLORREF SetColor(COLORREF value) { return m_color = value, update(), m_color; }
    __declspec(property(get = m_color, put = SetColor)) COLORREF color;
 
    unsigned SetSize(unsigned value) { return m_size = value, update(), m_size; }
    __declspec(property(get = m_size, put = SetSize)) unsigned size;
 
    const std::string& SetName(const std::string& value) { return m_name = value, update(), m_name; }
    __declspec(property(get = m_name, put = SetName)) const std::string& name;
 
    bool SetBold(bool value) { return m_bold = value, update(), m_bold; }
    __declspec(property(get = m_bold, put = SetBold)) bool bold;
 
    bool SetItalic(bool value) { return m_italic = value, update(), m_italic; }
    __declspec(property(get = m_italic, put = SetItalic)) bool italic;
 
    bool SetUnderline(bool value) { return m_underline = value, update(), m_underline; }
    __declspec(property(get = m_underline, put = SetUnderline)) bool underline;
 
    bool SetStrikeout(bool value) { return m_strikeout = value, update(), m_strikeout; }
    __declspec(property(get = m_strikeout, put = SetStrikeout)) bool strikeout;
 
    double SetOrientation(double value) { return m_orientation = value, update(), m_orientation; }
    __declspec(property(get = m_orientation, put = SetOrientation)) double orientation;
};
 
class Pen
{
private:
    HPEN m_pen;
    HDC m_dc;
    COLORREF m_color;
    int m_width;
    int m_style;
 
    void update()
    {
        DeleteObject(m_pen);
        m_pen = CreatePen(m_style, m_width, m_color);
        SelectObject(m_dc, m_pen);
    }
public:
    explicit Pen(HDC dc = 0)
    {
        m_pen = 0;
        m_dc = dc;
        m_color = 0x000000;
        m_width = 1;
        m_style = PS_SOLID;
        update();
    }
 
    ~Pen() { DeleteObject(m_pen); }
 
    HPEN SetPen(HPEN pen) { return m_pen = pen, SelectObject(m_dc, m_pen), m_pen; }
    __declspec(property(get = m_pen, put = SetPen)) HPEN hpen;
 
    HDC SetDC(HDC value) { return m_dc = value, update(), m_dc; }
    __declspec(property(get = m_dc, put = SetDC)) HDC dc;
 
    COLORREF SetColor(COLORREF value) { return m_color = value, update(), m_color; }
    __declspec(property(get = m_color, put = SetColor)) COLORREF color;
 
    int SetWidth(int value) { return m_width = value, update(), m_width; }
    __declspec(property(get = m_width, put = SetWidth)) int width;
 
    int SetStyle(int value) { return m_style = value, update(), m_style; }
    __declspec(property(get = m_style, put = SetStyle)) int style;
};

class Font
{
private:
    HFONT m_font;
    HDC m_dc;
    std::string m_name;
    unsigned m_size;
    bool m_bold;
    bool m_italic;
    bool m_underline;
    bool m_strikeout;
    double m_orientation;
    COLORREF m_color;
    DWORD m_charset;
 
    void update()
    {
        SetTextColor(m_dc, m_color);
        DeleteObject(m_font);
        m_font = CreateFont( m_size,
                             0,
                             static_cast<int>(m_orientation * 10),
                             0,
                             m_bold ? FW_BOLD : FW_NORMAL,
                             m_italic,
                             m_underline,
                             m_strikeout,
                             m_charset,
                             OUT_DEFAULT_PRECIS,
                             CLIP_DEFAULT_PRECIS,
                             PROOF_QUALITY,
                             DEFAULT_PITCH | FF_DONTCARE,
                             AnsiStringToWide(m_name).c_str());
        SelectObject(m_dc, m_font);
    }
public:
    explicit Font(HDC dc = 0)
    {
        m_font = 0;
        m_dc = dc;
        m_name = "";
        m_size = 20;
        m_bold = false;
        m_italic = false;
        m_strikeout = false;
        m_underline = false;
        m_orientation = 0;
        m_color = 0x000000;
        m_charset = DEFAULT_CHARSET;
        SetBkMode(m_dc, TRANSPARENT);
        update();
    }
 
    ~Font() { DeleteObject(m_font); }
 
    HFONT GetFont() { return m_font; }
    HFONT SetFont(HFONT font) { return m_font = font, SelectObject(m_dc, m_font), m_font; }
    __declspec(property(get = GetFont, put = SetFont)) HFONT hfont;
 
    HDC GetDC() { return m_dc; }
    HDC SetDC(HDC value) { return m_dc = value, update(), m_dc; }
    __declspec(property(get = m_dc, put = SetDC)) HDC dc;
 
    DWORD GetCharset() { return m_charset; }
    DWORD SetCharset(DWORD value) { return m_charset = value, update(), m_charset; }
    __declspec(property(get = GetCharset, put = SetCharset)) DWORD charset;
 
    COLORREF GetColor() { return m_color; }
    COLORREF SetColor(COLORREF value) { return m_color = value, update(), m_color; }
    __declspec(property(get = GetColor, put = SetColor)) COLORREF color;
 
    unsigned GetSize() { return m_size; }
    unsigned SetSize(unsigned value) { return m_size = value, update(), m_size; }
    __declspec(property(get = GetSize, put = SetSize)) unsigned size;
 
    const std::string& GetName() { return m_name; }
    const std::string& SetName(const std::string& value) { return m_name = value, update(), m_name; }
    __declspec(property(get = GetName, put = SetName)) const std::string& name;
 
    bool GetBold() { return m_bold; }
    bool SetBold(bool value) { return m_bold = value, update(), m_bold; }
    __declspec(property(get = GetBold, put = SetBold)) bool bold;
 
    bool GetItalic() { return m_italic; }
    bool SetItalic(bool value) { return m_italic = value, update(), m_italic; }
    __declspec(property(get = GetItalic, put = SetItalic)) bool italic;
 
    bool GetUnderline() { return m_underline; }
    bool SetUnderline(bool value) { return m_underline = value, update(), m_underline; }
    __declspec(property(get = GetUnderline, put = SetUnderline)) bool underline;
 
    bool GetStrikeout() { return m_strikeout; }
    bool SetStrikeout(bool value) { return m_strikeout = value, update(), m_strikeout; }
    __declspec(property(get = GetStrikeout, put = SetStrikeout)) bool strikeout;
 
    double GetOrientation() { return m_orientation; }
    double SetOrientation(double value) { return m_orientation = value, update(), m_orientation; }
    __declspec(property(get = GetOrientation, put = SetOrientation)) double orientation;
};
 
class Pen
{
private:
    HPEN m_pen;
    HDC m_dc;
    COLORREF m_color;
    int m_width;
    int m_style;
 
    void update()
    {
        DeleteObject(m_pen);
        m_pen = CreatePen(m_style, m_width, m_color);
        SelectObject(m_dc, m_pen);
    }
public:
    explicit Pen(HDC dc = 0)
    {
        m_pen = 0;
        m_dc = dc;
        m_color = 0x000000;
        m_width = 1;
        m_style = PS_SOLID;
        update();
    }
 
    ~Pen() { DeleteObject(m_pen); }
 
    HPEN SetPen(HPEN pen) { return m_pen = pen, SelectObject(m_dc, m_pen), m_pen; }
    __declspec(property(get = m_pen, put = SetPen)) HPEN hpen;
 
    HDC GetDC() { return m_dc; }
    HDC SetDC(HDC value) { return m_dc = value, update(), m_dc; }
    __declspec(property(get = m_dc, put = SetDC)) HDC dc;
 
    COLORREF GetColor() { return m_color; }
    COLORREF SetColor(COLORREF value) { return m_color = value, update(), m_color; }
    __declspec(property(get = GetColor, put = SetColor)) COLORREF color;
 
    int GetWidth() { return m_width; }
    int SetWidth(int value) { return m_width = value, update(), m_width; }
    __declspec(property(get = GetWidth, put = SetWidth)) int width;
 
    int GetStyle() { return m_style; }
    int SetStyle(int value) { return m_style = value, update(), m_style; }
    __declspec(property(get = GetStyle, put = SetStyle)) int style;
};

class Brush
{
private:
    HBRUSH m_brush;
    HDC m_dc;
    LOGBRUSH m_lb;
    
    void update()
    {
        DeleteObject(m_brush);
        m_brush = CreateBrushIndirect(&m_lb);
        SelectObject(m_dc, m_brush);
    }
public:
    explicit Brush(HDC dc = 0)
    {
        m_brush = 0;
        m_dc = dc;
        m_lb.lbColor = 0xffffff;
        m_lb.lbStyle = BS_SOLID;
        m_lb.lbHatch = 0;
        update();
    }
 
    ~Brush() { DeleteObject(m_brush); }
 
    HBRUSH GetBrush() { return m_brush; }
    HBRUSH SetBrush(HBRUSH brush) { return m_brush = brush, SelectObject(m_dc, m_brush), m_brush; }
    __declspec(property(get = GetBrush, put = SetBrush)) HBRUSH hbrush;
 
    HDC GetDC() { return m_dc; }
    HDC SetDC(HDC value) { return m_dc = value, update(), m_dc; }
    __declspec(property(get = m_dc, put = SetDC)) HDC dc;
 
    COLORREF GetColor() { return m_lb.lbColor; }
    COLORREF SetColor(COLORREF value) { return m_lb.lbColor = value, update(), m_lb.lbColor; }
    __declspec(property(get = GetColor, put = SetColor)) COLORREF color;
 
    unsigned GetStyle() { return m_lb.lbStyle; }
    unsigned SetStyle(unsigned value) { return m_lb.lbStyle = value, update(), m_lb.lbStyle; }
    __declspec(property(get = GetStyle, put = SetStyle)) unsigned style;
 
    long GetHatch() { return m_lb.lbHatch; }
    long SetHatch(long value) { return m_lb.lbHatch = value, update(), m_lb.lbHatch; }
    __declspec(property(get = GetHath, put = SetHatch)) long hatch;
};
 
class Canvas
{
private:
    HDC m_dc;
    Point<int> m_pos;
public:
    Font font;
    Pen pen;
    Brush brush;
 
    Canvas(HDC dc = 0) : m_dc(dc), font(dc), pen(dc), brush(dc) {}
 
    HDC GetDC() { return m_dc; }
    HDC SetDC(HDC value)
    {
        m_dc = value, font.dc = value, pen.dc = value, brush.dc = value;
        return m_dc;
    }
    __declspec(property(get = GetDC, put = SetDC)) HDC dc;
 
    COLORREF GetPixel(int x, int y) { return ::GetPixel(m_dc, x, y); }
    COLORREF GetPixel(const Point<int> &point) { return GetPixel(point.x, point.y); }
 
    COLORREF SetPixel(int x, int y, COLORREF color) { return ::SetPixel(m_dc, x, y, color); }
    COLORREF SetPixel(const Point<int> &point, COLORREF color) { return SetPixel(point.x, point.y, color); }
 
    __declspec(property(get = GetPixel, put = SetPixel)) COLORREF pixels[][];
 
    bool FloodFill(int x, int y, COLORREF color) { return ::FloodFill(m_dc, x, y, color); }
    bool FloodFill(const Point<int> &point, COLORREF color) { return FloodFill(point.x, point.y, color); }
 
    int FillRect(const Rect<int> &rect, COLORREF color)
    {
        brush.color = color;
        return ::FillRect(m_dc, &RECT(rect.tagRECT()), brush.hbrush);
    }
 
    int FillRect(int left, int top, int right, int bottom, COLORREF color)
    {
        return FillRect({ left, top, right, bottom }, color);
    }
 
    bool TextOut(int x, int y, const std::string& text)
    {
        std::wstring wtext = AnsiStringToWide(text);
        return ::TextOut(m_dc, x, y, wtext.c_str(), wtext.length());
    }
 
    bool TextOut(const Point<int> &point, const std::string& text) { return TextOut(point.x, point.y, text); }
 
    //bool TextRect(const Rect<int> &rect, const std::string& text) { return TextOut(); }
 
    bool MoveTo(int x, int y) { return m_pos.x = x, m_pos.y = y, ::MoveToEx(m_dc, x, y, 0); }
    bool MoveTo(const Point<int> &point) { return MoveTo(point.x, point.y); }
 
    bool LineTo(int x, int y) { return m_pos.x = x, m_pos.y = y, ::LineTo(m_dc, x, y); }
    bool LineTo(const Point<int> &point) { return LineTo(point.x, point.y); }
 
    bool Line(const Point<int> &point0, const Point<int> &point1) { return MoveTo(point1), LineTo(point1); }
 
    const Point<int> &GetPos() const { return m_pos; }
    const Point<int> &SetPos(const Point<int> &pos) { return m_pos = pos, MoveTo(pos), m_pos; }
    __declspec(property(get = GetPos, put = SetPos)) Point<int> &PenPos;
 
    bool Arc(const Point<int> &pt1, const Point<int> &pt2, const Point<int> &pt3, const Point<int> &pt4)
    {
        return ::Arc(m_dc, pt1.x, pt1.y, pt2.x, pt2.y, pt3.x, pt3.y, pt4.x, pt4.y);
    }
 
    bool Arc(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)
    {
        return ::Arc(m_dc, x1, y1, x2, 2, x3, y3, x4, y4);
    }
 
    bool Chord(const Point<int> &pt1, const Point<int> &pt2, const Point<int> &pt3, const Point<int> &pt4)
    {
        return ::Chord(m_dc, pt1.x, pt1.y, pt2.x, pt2.y, pt3.x, pt3.y, pt4.x, pt4.y);
    }
 
    bool Chord(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)
    {
        return ::Chord(m_dc, x1, y1, x2, 2, x3, y3, x4, y4);
    }
 
    int FrameRect(const Rect<int> &rect) { return ::FrameRect(m_dc, &RECT(rect.tagRECT()), brush.hbrush); }
    int FrameRect(int left, int top, int right, int bottom) { return FrameRect({ left, top, right, bottom }); }
 
    bool Rectangle(int left, int top, int right, int bottom) { return ::Rectangle(m_dc, left, top, right, bottom); }
    bool Rectangle(const Rect<int> &rect) { return Rectangle(rect.left, rect.top, rect.right, rect.bottom); }
 
    bool Ellipse(int left, int top, int right, int bottom) { return ::Ellipse(m_dc, left, top, right, bottom); }
    bool Ellipse(const Rect<int> &rect) { return Ellipse(rect.left, rect.top, rect.right, rect.bottom); }
 
    bool RoundRect(const Rect<int> &rect, size_t width, size_t height)
    {
        return ::RoundRect(m_dc, rect.left, rect.top, rect.right, rect.bottom, width, height);
    }
 
    bool RoundRect(int left, int top, int right, int bottom, int width, int height)
    {
        return ::RoundRect(m_dc, left, top, right, bottom, width, height);
    }
 
    //bool Polygon(const std::vector<POINT> points) { return ::Polygon(m_dc, &points[0], points.size()); }
    bool Polygon(const std::vector<Point<int>> points)
    {
        if (!points.size()) return false;
        for (int i = 0; i < points.size() - 1; i++)
            Line(points[i], points[i+1]);
        LineTo(points[0]);
        return true;
    }
 
    bool Polyline(const std::vector<Point<int>> points)
    {
        if (!points.size()) return false;
        for (int i = 0; i < points.size() - 1; i++)
            Line(points[i], points[i + 1]);
        return true;
    }
};

    Point(T x, T y) : x(x), y(y) {}

    Point<T> &operator = (const POINT& pt)