DC.h

#ifndef NEO_DC_H
#define NEO_DC_H

namespace neo
{

class SaveRestoreDC
{
public:
    SaveRestoreDC(HDC pDC) { dc = pDC; saved = SaveDC(dc); }
    ~SaveRestoreDC() { RestoreDC(dc, saved); }
private:
    HDC dc;
    int saved; 
};

class DeviceContextIF
{
public:
    virtual ~DeviceContextIF() {}

    virtual HDC GetHDC() = 0;

    HGDIOBJ Select(HGDIOBJ object)
    {
        return SelectObject(GetHDC(), object);
    }

    HBRUSH SetBrush(HBRUSH brush)
    {
        return reinterpret_cast<HBRUSH>(Select(brush));
    }

    HPEN SetPen(HPEN pen)
    {
        return reinterpret_cast<HPEN>(Select(pen));
    }

    HFONT SetFont(HFONT font)
    {
        return reinterpret_cast<HFONT>(Select(font));
    }

    HRGN SetRegion(HRGN region)
    {
        return reinterpret_cast<HRGN>(Select(region));
    }

    bool BitBlt(int x, int y, int width, int height, HDC sourceDC, int srcX, int srcY, DWORD rasterOp = SRCCOPY)
    {
        return ::BitBlt(GetHDC(), x, y, width, height,
            sourceDC, srcX, srcY,
            rasterOp) != FALSE;
    }

    bool BitBlt(const RECT& rect, HDC sourceDC, const POINT& sourcePoint, DWORD rasterOp = SRCCOPY)
    {
        return ::BitBlt(GetHDC(), rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
            sourceDC, sourcePoint.x, sourcePoint.y,
            rasterOp) != FALSE;
    }

    int SetStretchBltMode(int mode) { return ::SetStretchBltMode(GetHDC(), mode); }

    bool StretchBlt(int x, int y, int width, int height, HDC sourceDC, int srcX, int srcY, int srcWidth, int srcHeight, DWORD rasterOp = SRCCOPY)
    {
        return ::StretchBlt(GetHDC(), x, y, width, height,
            sourceDC, srcX, srcY, srcWidth, srcHeight,
            rasterOp) != FALSE;
    }

    bool StretchBlt(const RECT& rect, HDC sourceDC, const RECT& sourceRect, DWORD rasterOp = SRCCOPY)
    {
        return ::StretchBlt(GetHDC(), rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
            sourceDC, sourceRect.left, sourceRect.top, sourceRect.right - sourceRect.left, sourceRect.bottom - sourceRect.top,
            rasterOp) != FALSE;
    }

    void FillRect(const RECT& r, HBRUSH brush)
    {
        ::FillRect(GetHDC(), &r, brush);
    }
    
    void FillRegion(HRGN region, HBRUSH brush)
    {
        ::FillRgn(GetHDC(), region, brush);
    }

    void SetBkModeOpaque()
    {
        SetBkMode(GetHDC(), OPAQUE);
    }
    
    void SetBkModeTransparent()
    {
        SetBkMode(GetHDC(), TRANSPARENT);
    }

    void SetTextColor(COLORREF color)
    {
        ::SetTextColor(GetHDC(), color);
    }
    void SetBkColor(COLORREF color)
    {
        ::SetBkColor(GetHDC(), color);
    }

    void DrawText(const tstring& text, RECT& boundingRect, UINT format = DT_LEFT|DT_TOP)
    {
        ::DrawText(GetHDC(), text.c_str(), -1, &boundingRect, format);
    }

    void DrawText(const tstring& text, int x, int y)
    {
        Rect r(x, y, 1000000, 1000000);
        DrawText(text, r);
    }

    Size GetTextSize(const tstring& text, UINT format = DT_LEFT|DT_TOP, LONG maxWidth = 1000000)
    {
        // use DrawText to support multiline text
        Rect r(0, 0, maxWidth, 0);
        DrawText(text, r, format | DT_CALCRECT);
        return r.GetSize();
    }
};

class DC : public DeviceContextIF
{
public:
    DC(HDC pDC = 0) : dc(pDC) {}

    virtual HDC GetHDC() { return dc; }

    void operator=(HDC pDC) { dc = pDC; }
    operator HDC() { return dc; }

    HDC dc; 
};

class PaintDC : public DeviceContextIF
{
public:
    PaintDC(HWND pHwnd) : hwnd(pHwnd)
    {
        dc = BeginPaint(hwnd, &ps);
    }
    PaintDC(PaintDC&& rhs)
    {
        hwnd = rhs.hwnd;
        dc = rhs.dc;
        ps = rhs.ps;
        rhs.hwnd = 0;
        rhs.dc = 0;
        ZeroMemory(&rhs.ps, sizeof(rhs.ps));
    }
    ~PaintDC()
    {
        EndPaint(hwnd, &ps);
    }

    virtual HDC GetHDC() { return dc; }

    operator HDC() { return dc; }
private:
    PaintDC(const PaintDC& rhs) {}

    HWND hwnd;
    HDC dc;
    PAINTSTRUCT ps;
};

class ClientDC : public DeviceContextIF
{
public:
    ClientDC(HWND win) : window(win) { dc = GetDC(window); }
    ClientDC(ClientDC&& rhs)
    {
        window = rhs.window;
        dc = rhs.dc;
        rhs.window = 0;
        rhs.dc = 0;
    }
    ~ClientDC() { ReleaseDC(window, dc); }

    virtual HDC GetHDC() { return dc; }

    operator HDC() { return dc; }
private:
    ClientDC(const ClientDC& rhs) {}

    HWND window;
    HDC dc;
};

class MemoryDC : public DeviceContextIF
{
public:
    MemoryDC(HBITMAP bitmap) { Init(ClientDC(0), bitmap); }
    MemoryDC(HDC other, HBITMAP bitmap) { Init(other, bitmap); }
    MemoryDC(MemoryDC&& rhs)
    {
        dc = rhs.dc;
        attachedBitmap = rhs.attachedBitmap;
        rhs.dc = 0;
        rhs.attachedBitmap = 0;
    }
    ~MemoryDC() { if(dc) { RestoreDC(dc, -1); DeleteDC(dc); } }

    virtual HDC GetHDC() { return dc; }

    operator HDC() { return dc; }

    HBITMAP GetBitmap() { return attachedBitmap; }
private:
    MemoryDC(const MemoryDC& rhs) {}
    void Init(HDC other, HBITMAP bitmap);

    HDC dc;
    HBITMAP attachedBitmap;
};

inline void MemoryDC::Init(HDC other, HBITMAP bitmap)
{
    attachedBitmap = bitmap;

    dc = CreateCompatibleDC(other);
    assert(dc != 0);
    if(dc)
    {
        SaveDC(dc);
        SelectObject(dc, bitmap);
    }
}

} // namespace neo

#endif