sprint/gtl/Bitmap.h

Go to the documentation of this file.

/******************************************************************************
 *  GTL: GUI Template Library 
 *    A Cross Platform C++ Wrapper for Win32 users
 *  Copyright (C) 2007-2011 Paolo Medici (www.pmx.it)
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *******************************************************************************/

#ifndef _SPRINT_GTL_BITMAP_H
#define _SPRINT_GTL_BITMAP_H

#ifdef WIN32

#include <windows.h>

namespace sprint {
        namespace gtl {

#if 0
HBITMAP LoadBitmapAndRemap(HINSTANCE hInst, int id, COLORREF from, COLORREF to)
{
// DWORD backgroundColor = GetSysColor(COLOR_BTNFACE);
COLORMAP colorMap;
colorMap.from = from;
colorMap.to = to;
return  ::CreateMappedBitmap(hInst, id, 0, &colorMap, 1);
}
#endif

template<bool tManagedBmp>
class TBitmap {
        public:
        HBITMAP m_bmp;
        public:
                TBitmap(HBITMAP hbmp = NULL) : m_bmp(hbmp) { }
                ~TBitmap() { if(tManagedBmp) ::DeleteObject(m_bmp); }

                bool IsNull() const { return m_bmp == NULL; }

                
                operator HBITMAP() const { return m_bmp; }

        bool DeleteObject()
        {
        if(m_bmp)
        {
                BOOL bRet = ::DeleteObject(m_bmp);
                if(bRet)
                        m_bmp = NULL;
                return bRet;
        }
        else
        return true;
        }
                
                HBITMAP Attach(HBITMAP hBitmap)
                {
                        if(tManagedBmp && m_bmp != NULL&& m_bmp != hBitmap)
                                ::DeleteObject(m_bmp);
                        m_bmp = hBitmap;
                        return hBitmap;
                }
                
                HBITMAP Detach()
                {
                        HBITMAP hBitmap = m_bmp;
                        m_bmp = NULL;
                        return hBitmap;
                }
                
        HBITMAP LoadBitmap(LPCTSTR  bitmap)
        {
        return Attach( ::LoadBitmap(::GetModuleHandle(NULL), bitmap) );
        }

        HBITMAP LoadOEMBitmap(UINT nIDBitmap) // for OBM_/OCR_/OIC_
        {
        return Attach( ::LoadBitmap(NULL, MAKEINTRESOURCE(nIDBitmap)) );
        }

        HBITMAP CreateDIBitmap(HDC hDC, CONST BITMAPINFOHEADER* lpbmih, DWORD dwInit, CONST VOID* lpbInit, CONST BITMAPINFO* lpbmi, UINT uColorUse)
        {
                return Attach( ::CreateDIBitmap(hDC, lpbmih, dwInit, lpbInit, lpbmi, uColorUse) );
        }
        
        HBITMAP CreateDIBSection(HDC hDC, const BITMAPINFO* lpbmi, UINT uColorUse, void** ppvBits, HANDLE hSection = 0, DWORD dwOffset = 0)
        {
        return Attach( ::CreateDIBSection(hDC, lpbmi, uColorUse, ppvBits, hSection, dwOffset) );
        }

        HBITMAP CreateBitmap(int nWidth, int nHeight, UINT nPlanes, UINT nBitsPerPixel, const void* lpBits)
        {
        return Attach( ::CreateBitmap(nWidth, nHeight, nPlanes, nBitsPerPixel, lpBits) );
        }       
        
                HBITMAP CreateCompatibleBitmap(HDC hDC, int nWidth, int nHeight)
                {
                        return Attach( ::CreateCompatibleBitmap(hDC, nWidth, nHeight) );
                }

                bool GetBitmap(BITMAP& bm) const
                {
                        return (::GetObject(m_bmp, sizeof(BITMAP), &bm) == sizeof(BITMAP));
                }
                
        int GetDIBits(HDC hDC, UINT uStartScan, UINT cScanLines,  LPVOID lpvBits, LPBITMAPINFO lpbmi, UINT uColorUse) const
        {
                return ::GetDIBits(hDC, m_bmp, uStartScan, cScanLines,  lpvBits, lpbmi, uColorUse);
        }

        int SetDIBits(HDC hDC, UINT uStartScan, UINT cScanLines, CONST VOID* lpvBits, const BITMAPINFO* lpbmi, UINT uColorUse)
        {
                return ::SetDIBits(hDC, m_bmp, uStartScan, cScanLines, lpvBits, lpbmi, uColorUse);
        }
                
        bool GetSize(SIZE& size) const
        {
                BITMAP bm = { 0 };
                if(!GetBitmap(&bm))
                        return false;
                size.cx = bm.bmWidth;
                size.cy = bm.bmHeight;
                return true;
        }               
        
};

typedef TBitmap<true> CBitmap;
typedef TBitmap<false> CBitmapHandle;

}

}

#endif

#endif