ATL, GDI+. PNG,...

After a half of a day of a dramatic struggle with CImage, I failed to make it working with the png images - the images that contain the alpha chanel. I found the solution, but with GDI+ and I will show it later.

Firstly, I have to say, that the CImage converts any image into 32 bit per pixel format, but it is just RGB (pre-muliplay alpha?). When CImage loads an image it copies the image data into an internal buffer. You can see everything yourself, if you will debug CImage methods such as Load from the stream, for example.

Secondly, I just included atlimage.h file header into my source code and got a bunch of dlls from which my application depends now. Including the dynamic run-time libraries, and GDI+, and something from the Windows Installer, and...

I very like ATL, I just love the style, but, probably, I will try to avoid using CImage in my projects.
For a fast and dirty job that does not require to load any data with alpha..., maybe, it is possible. CImage even has AlphaBlend function - it's just a wrapper for the Win API function. From my point view, it is just one more evidence of a bad design made for this class - from one side the class uses GDI+, from other side it uses GDI function to draw the image.

The original task was to load the PNG-file from the resources in an ATL-based application. I thought I solved it. It looked great - I made a template - CImageResource, that contain only one function -  LoadFromResource. The objects I created in my application were like

CImageResource<CImage> m_Image;

I added a window background image to the resources and saw it's drawn in the application window. AlphaBlend method was used and everything was just fine.

The problems begun when I added a button image with the real visible alpha.

So finally the class CImageResource is not a template :). It looks so:

#pragma once

class CImageResource 
{
    Bitmap* m_pBitmap;
    HGLOBAL    m_hBlock;

public:
    CImageResource() : m_pBitmap(NULL), m_hBlock(NULL) {}
    ~CImageResource() { Clear(); }

    inline BOOL IsNull() const { return m_pBitmap == NULL; }

    UINT GetWidth()
    {
        if (IsNull())
            return 0;
        return m_pBitmap->GetWidth();
    }

    UINT GetHeight()
    {
        if (IsNull())
            return 0;
        return m_pBitmap->GetHeight();
    }

    BOOL Draw(HDC hDC, int x, int y)
    {
        if (IsNull())
            return FALSE;
        Graphics graphics(hDC);
        return graphics.DrawImage(m_pBitmap, x, y,
            m_pBitmap->GetWidth(), m_pBitmap->GetHeight()) == Ok;
    }

    BOOL Draw(HDC hDC, RECT& rect)
    {
        if (IsNull())
            return FALSE;
        Graphics graphics(hDC);
        return graphics.DrawImage(m_pBitmap, rect.left, rect.top,
            rect.right - rect.left, rect.bottom - rect.top) == Ok;
    }

    BOOL Load(LPCWSTR lpszFile)
    {
        Clear();
        m_pBitmap = Bitmap::FromFile(lpszFile);
        return m_pBitmap->GetLastStatus() == Ok;
    }

    BOOL LoadFromResource(UINT nResID)
    {
        Clear();
        HMODULE hModule = GetModuleHandle(NULL);
        HRSRC hResource = FindResource(hModule, 
            MAKEINTRESOURCE(nResID), L"IMAGES");
        if (hResource == NULL)
            return FALSE;

        HGLOBAL hImage = LoadResource(hModule, hResource);
        if (hImage == NULL)
            return FALSE;
        LPVOID pImage = LockResource(hImage);
        if (pImage == NULL)
            return FALSE;

        HRESULT hr = E_FAIL;
        int size = SizeofResource(hModule, hResource);
        m_hBlock = GlobalAlloc(GMEM_MOVEABLE, size);
        if (m_hBlock == NULL)
            return FALSE;

        LPVOID pBlock = GlobalLock(m_hBlock);
        if (pBlock != NULL) 
        {
            memmove(pBlock, pImage, size);
            IStream* pStream = NULL;
            if (CreateStreamOnHGlobal(m_hBlock, FALSE, &pStream) == S_OK) 
            {
                m_pBitmap = Bitmap::FromStream(pStream);
                pStream->Release();
                if (m_pBitmap != NULL)
                {
                    if (m_pBitmap->GetLastStatus() == Ok)
                        return TRUE;
                }
                delete m_pBitmap;
                m_pBitmap = NULL;
            }
            GlobalUnlock(m_hBlock);
        }
        GlobalFree(m_hBlock);
        m_hBlock = NULL;
        return FALSE;
    }

    void Clear()
    {
        delete m_pBitmap;
        m_pBitmap = NULL;
        if (m_hBlock != NULL)
        {
            GlobalUnlock(m_hBlock);
            GlobalFree(m_hBlock);
        }
    }
};

Now all images are loaded and drawn with the alpha. For drawing I use the GDI+ as well.
Here are few helpful links from CodeProject about this topic:
Joe Woodbury. Loading JPG & PNG resources using GDI+: http://www.codeproject.com/KB/GDI-plus/cgdiplusbitmap.aspx
Christian Graus. Starting with GDI+: http://www.codeproject.com/KB/GDI-plus/startinggdiplus.aspx
 Darren Sessions. A user draw button that supports PNG files with transparency, for Visual C++ 6.0 and VS2005: http://www.codeproject.com/KB/buttons/GdipButton.aspx