GdiObject.h

#ifndef NEO_GDI_OBJECT_H
#define NEO_GDI_OBJECT_H

namespace neo
{

template<typename HANDLE_T>
class GdiObject
{
public:
    GdiObject(HANDLE_T pHandle = 0) : handle(pHandle) {}
    ~GdiObject()
    {
        if(handle)
            DeleteObject(handle);
    }
    void SetHandle(HANDLE_T pHandle)
    {
        if(handle)
            DeleteObject(handle);
        handle = pHandle;
    }
    operator HANDLE_T() { return handle; }
    HANDLE_T handle;
};

class SolidBrush : public GdiObject<HBRUSH>
{
public:
    SolidBrush() {}
    SolidBrush(COLORREF color) { Create(color); }

    void Create(COLORREF color) { SetHandle(CreateSolidBrush(color)); }
};

class HatchBrush : public GdiObject<HBRUSH>
{
public:
    HatchBrush() {}
    HatchBrush(int hatch, COLORREF color) { Create(hatch, color); }

    void Create(int hatch, COLORREF color) { SetHandle(CreateHatchBrush(hatch, color)); }
};

class PatternBrush : public GdiObject<HBRUSH>
{
public:
    PatternBrush() {}
    PatternBrush(HBITMAP bitmap) { Create(bitmap); }

    void Create(HBITMAP bitmap) { SetHandle(CreatePatternBrush(bitmap)); }
};

// there are also GetSysColorBrush() and GetStockObject(), but these don't need to be managed

class Pen : public GdiObject<HPEN>
{
public:
    Pen() {}
    Pen(COLORREF color, int width = 1, int penStyle = PS_SOLID) { Create(color, width, penStyle); }

    void Create(COLORREF color, int width = 1, int penStyle = PS_SOLID) { SetHandle(CreatePen(penStyle, width, color)); }
};

class Bitmap : public GdiObject<HBITMAP>
{
public:
    Bitmap() {}
    Bitmap(int width, int height, UINT planes, UINT bpp, const void* data) { CreateBitmap(width, height, planes, bpp, data); }
    Bitmap(HDC compatibleDC, int width, int height) { CreateCompatibleBitmap(compatibleDC, width, height); }
    Bitmap(const tstring& filename) { LoadBitmap(filename); }

    void CreateBitmap(int width, int height, UINT planes, UINT bpp, const void* data) { SetHandle(::CreateBitmap(width, height, planes, bpp, data)); }
    void CreateCompatibleBitmap(HDC compatibleDC, int width, int height) { SetHandle(::CreateCompatibleBitmap(compatibleDC, width, height)); }
    void LoadBitmap(const tstring& filename) { DeleteObject(handle); SetHandle((HBITMAP)LoadImage(0, filename.c_str(), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE)); }
};

class BitmapData : public BITMAP
{
public:
    BitmapData(HBITMAP bitmap)
    {
        ZeroMemory(this, sizeof(BitmapData));
        GetObject(bitmap, sizeof(BitmapData), this);
    }
};

class DibSection : public GdiObject<HBITMAP>
{
public:
    DibSection();
    DibSection(int width, int height, int bpp, bool bottomup = true);
    DibSection(HBITMAP bitmap, int bpp, bool bottomup);
    DibSection(HBITMAP bitmap);
    DibSection& operator= (const DibSection& other);

    static int BPP(HBITMAP bitmap);
    static bool IsDibSection(HBITMAP bitmap);
    static bool IsBottomUp(HBITMAP bitmap);
    static void FillBitmapInfo(BITMAPINFO& bmi, int w, int h, int bpp, bool bottomup = true);

    bool Create(int width, int height, int bpp, bool bottomup = true);
    bool CopyCreate(HBITMAP bitmap, int bpp, bool bottomup);
    bool CopyCreate(HBITMAP bitmap) { return CopyCreate(bitmap, BPP(bitmap), IsBottomUp(bitmap)); }

    bool Attach(HBITMAP bitmap);
    HBITMAP Detach();
    void Clear();
    bool CopyFromBitmap(HBITMAP bitmap);
    bool CopyToBitmap(HBITMAP bitmap);

    int GetWidth() { return dibData.bmWidth; }
    int GetHeight() { return dibData.bmHeight; }
    int GetBPP() { return dibData.bmBitsPixel; }
    void* GetBits() { return dibData.bmBits; }
    void* GetPixelAddress(int x, int y) { return (BYTE*)dibData.bmBits + y*dibData.bmWidthBytes + x*dibData.bmBitsPixel/8; }
    bool IsBottomUp() { return dibInfo.bmiHeader.biHeight > 0; }
    int FlippedY(int y) { return IsBottomUp() ? dibData.bmHeight - 1 - y : y; }

    BITMAP dibData;     
    BITMAPINFO dibInfo; 
private:
    template<typename T>
    static bool GetObject(HANDLE handle, T& obj) { return ::GetObject(handle, sizeof(obj), &obj) == sizeof(obj); }
};

class FontParams
{
public:
    FontParams()
    : width(0)
    , escapement(0)
    , orientation(0)
    , weight(FW_DONTCARE)
    , italic(FALSE)
    , underline(FALSE)
    , strikeout(FALSE)
    , charset(ANSI_CHARSET)
    , outPrecision(OUT_DEFAULT_PRECIS)
    , clipPrecision(CLIP_DEFAULT_PRECIS)
    , quality(PROOF_QUALITY)
    , pitchAndFamily(VARIABLE_PITCH | FF_DONTCARE)
    {}

    FontParams& SetWidth(int pWidth) { width = pWidth; return *this; }
    FontParams& SetEscapment(int pEscapement) { escapement = pEscapement; return *this; }
    FontParams& SetOrientation(int pOrientation) { orientation = pOrientation; return *this; }
    FontParams& SetWeight(int pWeight) { weight = pWeight; return *this; }
    FontParams& SetItalic(BOOL set) { italic = set; return *this; }
    FontParams& SetUnderline(BOOL set) { underline = set; return *this; }
    FontParams& SetStrikeout(BOOL set) { strikeout = set; return *this; }
    FontParams& SetCharSet(BYTE pCharset) { charset = pCharset; return *this; }
    FontParams& SetOutPrecision(BYTE pOutPrecision) { outPrecision = pOutPrecision; return *this; }
    FontParams& SetClipPrecision(BYTE pClipPrecision) { clipPrecision = pClipPrecision; return *this; }
    FontParams& SetQuality(BYTE pQuality) { quality = pQuality; return *this; }
    FontParams& SetPitchAndFamily(BYTE pPitchAndFamily) { pitchAndFamily = pPitchAndFamily; return *this; }
    FontParams& SetFaceName(const tstring& pFacename) { facename = pFacename; return *this; }

    HFONT CreateFont(int height) const
    {
        return ::CreateFont(height,
            width,
            escapement,
            orientation,
            weight,
            italic,
            underline,
            strikeout,
            charset,
            outPrecision,
            clipPrecision,
            quality,
            pitchAndFamily,
            facename.c_str());
    }

    int width;
    int escapement;
    int orientation;
    int weight;
    DWORD italic;
    DWORD underline;
    DWORD strikeout;
    DWORD charset;
    DWORD outPrecision;
    DWORD clipPrecision;
    DWORD quality;
    DWORD pitchAndFamily;
    tstring facename;
};

class Font : public GdiObject<HFONT>
{
public:
    Font(HFONT font = 0) : GdiObject<HFONT>(font) {}
    Font(int height, const FontParams& params = FontParams()) { Create(height, params); }

    void Create(int height, const FontParams& params = FontParams()) { SetHandle(params.CreateFont(height)); }

    void CreateDefaultFont()
    {
        // get message box font
        NONCLIENTMETRICS ncm;
        ncm.cbSize = sizeof(ncm);

        // If we're compiling with the Vista SDK or later, the NONCLIENTMETRICS struct
        // will be the wrong size for previous versions, so we need to adjust it.
#if(WINVER >= 0x0600)
        OSVERSIONINFO os;
        os.dwOSVersionInfoSize = sizeof(os);
        GetVersionEx(&os);

        if(os.dwMajorVersion < 6)
            // In versions of Windows prior to Vista, the iPaddedBorderWidth member
            // is not present, so we need to subtract its size from cbSize.
            ncm.cbSize -= sizeof(ncm.iPaddedBorderWidth);
#endif
        SystemParametersInfo(SPI_GETNONCLIENTMETRICS, ncm.cbSize, &ncm, 0);

        // create a font that matches the message box font
        SetHandle(CreateFontIndirect(&ncm.lfMessageFont));
    }
};

//-----------------------------------------------------------------------------

inline DibSection::DibSection()
{
    handle = 0;
    Clear();
}

inline DibSection::DibSection(int width, int height, int bpp, bool bottomup)
{
    handle = 0;
    Create(width, height, bpp, bottomup);
}

inline DibSection::DibSection(HBITMAP bitmap, int bpp, bool bottomup)
{
    handle = 0;
    CopyCreate(bitmap, bpp, bottomup);
}

inline DibSection::DibSection(HBITMAP bitmap)
{
    handle = 0;
    CopyCreate(bitmap);
}

inline DibSection& DibSection::operator= (const DibSection& other)
{
    handle = 0;
    CopyCreate(other.handle);
    return *this;
}

inline int DibSection::BPP(HBITMAP bitmap)
{
    BITMAP bm;
    if(GetObject(bitmap, bm))
        return bm.bmBitsPixel;
    return 0;
}

inline bool DibSection::IsDibSection(HBITMAP bitmap)
{
    DIBSECTION ds;
    return GetObject(bitmap, ds);
}

inline bool DibSection::IsBottomUp(HBITMAP bitmap)
{
    DIBSECTION ds;
    if(GetObject(bitmap, ds))
        return ds.dsBmih.biHeight > 0;
    return true;
}

inline void DibSection::FillBitmapInfo(BITMAPINFO& bmi, int w, int h, int bpp, bool bottomup)
{
    ZeroMemory(&bmi, sizeof(bmi));
    bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
    bmi.bmiHeader.biWidth = w;
    bmi.bmiHeader.biHeight = h;
    if(!bottomup)
        bmi.bmiHeader.biHeight = -h;
    bmi.bmiHeader.biBitCount = bpp;
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biCompression = BI_RGB;
    bmi.bmiHeader.biXPelsPerMeter = 0x0ec4; // this is a standard value
    bmi.bmiHeader.biYPelsPerMeter = 0x0ec4;
}

inline bool DibSection::Create(int width, int height, int bpp, bool bottomup)
{
    DeleteObject(handle);

    FillBitmapInfo(dibInfo, width, height, bpp, bottomup);
    handle = CreateDIBSection(ClientDC(0), &dibInfo, DIB_RGB_COLORS, 0, 0, 0);
    if(handle)
        if(GetObject(handle, dibData))
            if(dibData.bmBits)
                return true;

    Clear();
    return false;
}

inline bool DibSection::CopyCreate(HBITMAP bitmap, int bpp, bool bottomup)
{
    BITMAP bm;
    if(GetObject(bitmap, bm))
        if(Create(bm.bmWidth, bm.bmHeight, bpp, bottomup))
            if(CopyFromBitmap(bitmap))
                return true;

    Clear();
    return false;
}

inline bool DibSection::Attach(HBITMAP bitmap)
{
    DIBSECTION ds;
    if(GetObject(bitmap, ds)){
        DeleteObject(handle);
        handle = bitmap;
        dibData = ds.dsBm;
        dibInfo.bmiHeader = ds.dsBmih;
        return true;
    }

    Clear();
    return false;
}

inline HBITMAP DibSection::Detach()
{
    HBITMAP result = handle;
    handle = 0;
    Clear();
    return result;
}

inline void DibSection::Clear()
{
    DeleteObject(handle);
    handle = 0;
    ZeroMemory(&dibData, sizeof(dibData));
    ZeroMemory(&dibInfo, sizeof(dibInfo));
}

inline bool DibSection::CopyFromBitmap(HBITMAP bitmap)
{
    BITMAP bm;
    if(GetObject(bitmap, bm))
        if(bm.bmWidth == GetWidth() && bm.bmHeight == GetHeight())
            if(GetDIBits(ClientDC(0), bitmap, 0, GetHeight(), dibData.bmBits, &dibInfo, DIB_RGB_COLORS) == GetHeight())
                return true;

    return false;
}

inline bool DibSection::CopyToBitmap(HBITMAP bitmap)
{
    BITMAP bm;
    if(GetObject(bitmap, bm))
        if(bm.bmWidth == GetWidth() && bm.bmHeight == GetHeight())
            if(SetDIBits(ClientDC(0), bitmap, 0, GetHeight(), dibData.bmBits, &dibInfo, DIB_RGB_COLORS) == GetHeight())
                return true;

    return false;
}

} // namespace neo

#endif