TnbBitmapHandle.h

[詳解]

#pragma once
#include "TnbPointerHandle.h"
#ifndef _WIN32_WCE
 #pragma comment(lib, "gdi32.lib")
#else
 #define LR_CREATEDIBSECTION 0
#endif
 
 
 
//TNB Library
namespace TNB
{
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 
struct TPhDeleteBitmapHandle
{
    void operator()(HBITMAP h) 
    {
      #ifdef _DEBUG
        if ( ::GetObjectType(h) == NULL )
        {
            ASSERT0( false, "~CBitmapHandle", "先に HBITMAPが破棄されてしまっています。" );
        }
        else if ( ! ::DeleteObject(h) )
        {
            ASSERT1( false, "~CBitmapHandle", "HBITMAP の破棄に失敗しました。\ncode = %d", ::GetLastError() );
        }
      #else
        ::DeleteObject(h);
      #endif
    }
};
 
#endif // _TnbDOXYGEN
 
 
 
class CBitmapHandle : public CPointerHandleBaseT<HBITMAP, TPhDeleteBitmapHandle, NULL> 
{
    typedef CPointerHandleBaseT<HBITMAP, TPhDeleteBitmapHandle, NULL> _super;   
    DEFSUPER(_super);
public:
 
    CBitmapHandle(void) : _super() 
    {
    }
 
    CBitmapHandle(const CBitmapHandle& other) : _super(other) 
    {
    }
 
    CBitmapHandle(HBITMAP P) : _super(P) 
    {
    }
 
    CBitmapHandle(UINT uBitmapResourceId, int cx = 0, int cy = 0, UINT fuLoad = LR_CREATEDIBSECTION)
    {
        _super::operator=(Load(uBitmapResourceId, cx, cy, fuLoad));
    }
 
    CBitmapHandle(LPCTSTR lpszFile, int cx = 0, int cy = 0, UINT fuLoad = LR_CREATEDIBSECTION)
    {
        _super::operator=(Load(lpszFile, cx, cy, fuLoad));
    }
 
    #ifdef __AFX_H__
    CBitmapHandle(const CString& strFile, int cx = 0, int cy = 0, UINT fuLoad = LR_CREATEDIBSECTION)
    {
        _super::operator=(Load(strFile.operator LPCTSTR(), cx, cy, fuLoad));
    }
    #endif
 
    bool GetSize(SIZE& _size) const
    {
        BITMAP bm;
        if ( ::GetObject(*this, sizeof(BITMAP), &bm) > 0 )
        {
            _size.cx = bm.bmWidth;
            _size.cy = bm.bmHeight;
            return true;
        }
        _GetLastError("GetObject");
        _size.cx = 0;
        _size.cy = 0;
        return false;
    }
 
    HBITMAP Detach(void)
    {
        if ( IsNull() ) { return NULL; }
        #ifndef _WIN32_WCE
            HBITMAP h = static_cast<HBITMAP>(::CopyImage(*this, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION));
        #else
            RGBQUAD* pRgb;
            HBITMAP h = Create32bitDibSection(*this, pRgb);
        #endif
        Null();
        return h;
    }
 
    void SetClone(HBITMAP hBmp)
    {
        #ifndef _WIN32_WCE
            _super::operator=(static_cast<HBITMAP>(::CopyImage(hBmp, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION)));
        #else
            RGBQUAD* pRgb;
            _super::operator=(Create32bitDibSection(hBmp, pRgb));
        #endif
    }
 
    bool Draw(HDC hdc, int x = 0, int y = 0) const
    {
        HBITMAP h = *this;
        return Draw(hdc, h, x, y);
    }
 
    DWORD Save(LPCTSTR lpszFileName, WORD bitsPixel = 0)
    {
        return Save(lpszFileName, *this, bitsPixel);
    }
 
 
    //-----------------
 
 
    static HBITMAP Create32bitDibSection(HBITMAP hbm, RGBQUAD*& _pRgb, BITMAPINFOHEADER* pHeader = NULL)
    {
        BITMAP bm;
        if ( ! ::GetObject(hbm, sizeof(BITMAP), &bm) )
        {
            return NULL;
        }
        HDC hdcSrc = ::CreateCompatibleDC(NULL);
        HDC hdcDst = ::CreateCompatibleDC(NULL);
        HGDIOBJ hbmOld = ::SelectObject(hdcSrc, hbm);
        BITMAPINFOHEADER bmi;
        Zero(bmi);
        bmi.biSize          = sizeof(BITMAPINFOHEADER);
        bmi.biWidth         = bm.bmWidth;
        bmi.biHeight        = bm.bmHeight;
        bmi.biPlanes        = 1;
        bmi.biBitCount      = 32;
        bmi.biCompression   = BI_RGB;
        HBITMAP hbmNew = ::CreateDIBSection(hdcSrc, reinterpret_cast<BITMAPINFO*>(&bmi), DIB_RGB_COLORS, reinterpret_cast<void **>(&_pRgb), NULL, 0);
        HGDIOBJ hbmOld2 = ::SelectObject(hdcDst, hbmNew);
        ::BitBlt(hdcDst, 0, 0, bm.bmWidth, bm.bmHeight, hdcSrc, 0, 0, SRCCOPY);
        ::SelectObject(hdcDst, hbmOld2);
        ::SelectObject(hdcSrc, hbmOld);
        ::DeleteDC(hdcSrc);
        ::DeleteDC(hdcDst);
        if ( pHeader != NULL )
        {
            *pHeader = bmi;
        }
        return hbmNew;
    }
 
    static HBITMAP Load(UINT uBitmapResourceId, int cx = 0, int cy = 0, UINT fuLoad = LR_CREATEDIBSECTION)
    {
        HINSTANCE hIns = GetInstanceHandleByTnb(EI_Bitmap);
        LPCTSTR lpId = MAKEINTRESOURCE(uBitmapResourceId);
        return static_cast<HBITMAP>(::LoadImage(hIns, lpId, IMAGE_BITMAP, cx, cy, fuLoad));
    }
 
    static HBITMAP Load(LPCTSTR lpszFileName, int cx = 0, int cy = 0, UINT fuLoad = LR_CREATEDIBSECTION)
    {
        if ( lpszFileName == NULL || *lpszFileName == 0 )
        {
            return NULL;
        }
        HINSTANCE hIns = GetInstanceHandleByTnb(EI_Bitmap);
        #ifndef _WIN32_WCE
            return static_cast<HBITMAP>(::LoadImage(hIns, lpszFileName, IMAGE_BITMAP, cx, cy, fuLoad | LR_LOADFROMFILE));
        #else
            return static_cast<HBITMAP>(::LoadBitmap(hIns, lpszFileName));
        #endif
    }
 
    static HBITMAP LoadOem(UINT uOemBitmapResourceId, int cx = 0, int cy = 0, UINT fuLoad = 0)
    {
        LPCTSTR lpId = MAKEINTRESOURCE(uOemBitmapResourceId);
        #ifndef _WIN32_WCE
            fuLoad |= LR_SHARED;
        #endif
        return static_cast<HBITMAP>(::LoadImage(NULL, lpId, IMAGE_BITMAP, cx, cy, fuLoad));
    }
 
    static bool Draw(HDC hdc, HBITMAP hBmp, int x = 0, int y = 0)
    {
        #ifndef _WIN32_WCE
            LPARAM l = reinterpret_cast<LPARAM>(hBmp);
            bool r = !! ::DrawState(hdc, NULL, NULL, l, 0, x, y, 0, 0, DST_BITMAP | DSS_NORMAL);
            return r;
        #else
            BITMAP bm;
            if ( ::GetObject(hBmp, sizeof(BITMAP), &bm) > 0 )
            {
                HDC tempDC = ::CreateCompatibleDC(hdc);
                HGDIOBJ oldBmp = ::SelectObject(tempDC, hBmp);
                bool r =!! ::BitBlt(hdc, x, y, bm.bmWidth, bm.bmHeight, tempDC, 0, 0, SRCCOPY);
                ::SelectObject(tempDC, oldBmp);
                ::DeleteDC(tempDC);
                return r;
            }
            return false;
        #endif
    }
 
    #ifndef _WIN32_WCE
    static DWORD SaveMemory(CWorkMem& _save, HBITMAP bmp, WORD bitsPixel = 0)
    {
        BITMAP bp;
        if ( ::GetObject(bmp, sizeof(BITMAP), &bp) <= 0 ) 
        {
            return _GetLastError("GetObject"); 
        }
        // BITMAP情報生成
        BITMAPFILEHEADER fh = { 0 };
        LONG paletCount = 0;
        fh.bfType = 'B' + 'M' * 256;
        fh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
        CWorkMem workHead(sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256);
        BITMAPINFOHEADER* pih = (BITMAPINFOHEADER*)workHead.Ref();
        ZeroMemory(pih, workHead.GetSize());
        pih->biSize         = sizeof(BITMAPINFOHEADER);
        pih->biWidth        = bp.bmWidth;
        pih->biHeight       = bp.bmHeight;
        pih->biPlanes       = bp.bmPlanes;
        pih->biBitCount     = (bitsPixel == 0) ? bp.bmBitsPixel : bitsPixel;
        pih->biCompression  = BI_RGB;
        pih->biSizeImage    = bp.bmWidthBytes * bp.bmHeight;
        switch(pih->biBitCount)
        {
        case 1:
            paletCount = 2;
            pih->biSizeImage = (((pih->biWidth / 4) + 3) & 0xfffffffc) * pih->biHeight;
            fh.bfOffBits += (sizeof(RGBQUAD) * 2);
            break;
        case 4:
            paletCount = 16;
            pih->biSizeImage = (((pih->biWidth / 2) + 3) & 0xfffffffc) * pih->biHeight;
            fh.bfOffBits += (sizeof(RGBQUAD) * 16);
            break;
        case 8:
            paletCount = 256;
            pih->biSizeImage = ((pih->biWidth + 3) & 0xfffffffc) * pih->biHeight;
            fh.bfOffBits += (sizeof(RGBQUAD) * 256);
            break;
        case 16:
            paletCount = 0;
            pih->biSizeImage = ((pih->biWidth * 2 + 3) & 0xfffffffc) * pih->biHeight;
            break;
        case 24:
            paletCount = 0;
            pih->biSizeImage = ((pih->biWidth * 3 + 3) & 0xfffffffc) * pih->biHeight;
            break;
        case 32:
            paletCount = 0;
            pih->biSizeImage = pih->biWidth * 4 * pih->biHeight;
            break;
        default:
            return ERROR_INVALID_PARAMETER;
        }
        // 画像データ出力
        CWorkMem data(pih->biSizeImage + 256 * sizeof(RGBQUAD));
        HDC dc = ::CreateCompatibleDC(NULL);
        HGDIOBJ old = ::SelectObject(dc, bmp);
        int r = ::GetDIBits(dc, bmp, 0, pih->biHeight, data.Ref(), reinterpret_cast<LPBITMAPINFO>(pih), DIB_RGB_COLORS);
        if ( r == 0 )
        {
            return _GetLastError("GetDIBits");
        }
        ::SelectObject(dc, old);
        ::DeleteDC(dc);
        fh.bfSize = fh.bfOffBits + pih->biSizeImage;
        // ヘッダ
        LPCVOID P1 = &fh;
        size_t l1 = sizeof(fh);
        // BITMAP情報
        LPCVOID P2 = pih;
        size_t l2 = sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * paletCount;
        // 画像データ
        LPCVOID P3 = data.Ref();
        size_t l3 = pih->biSizeImage;
        // 出力
        _save.Resize(l1 + l2 + l3);
        BYTE* B = _save.Ref();
        MemCopy(B, P1, l1);
        B += l1;
        MemCopy(B, P2, l2);
        B += l2;
        MemCopy(B, P3, l3);
        B += l3;
        return ERROR_SUCCESS;
    }
    #else
    static DWORD SaveMemory(CWorkMem& _save, HBITMAP bmp, WORD bitsPixel = 0)
    {
        RGBQUAD* pRgb;
        BITMAPINFOHEADER header;
        BITMAPFILEHEADER fh;
        ZeroMemory(&fh, sizeof(fh));
        fh.bfType = 'B' + 'M' * 256;
        fh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
        HBITMAP hTmp = Create32bitDibSection(bmp, pRgb, &header);
        if ( hTmp == NULL )
        {
            return _GetLastError("GetObject");
        }
        size_t len = header.biWidth * 4 * header.biHeight;
        fh.bfSize = fh.bfOffBits + len;
        // ヘッダ
        LPCVOID P1 = &fh;
        size_t l1 = sizeof(fh);
        // BITMAP情報
        LPCVOID P2 = &header;
        size_t l2 = sizeof(header);
        // 画像データ
        LPCVOID P3 = pRgb;
        size_t l3 = len;
        // 出力
        _save.Resize(l1 + l2 + l3);
        BYTE* B = _save.Ref();
        MemCopy(B, P1, l1);
        B += l1;
        MemCopy(B, P2, l2);
        B += l2;
        MemCopy(B, P3, l3);
        B += l3;
        _DeleteObject(hTmp);
        return ERROR_SUCCESS;
    }
    #endif
 
    static DWORD Save(LPCTSTR lpszFileName, HBITMAP bmp, WORD bitsPixel = 0)
    {
        CWorkMem m;
        DWORD r = SaveMemory(m, bmp, bitsPixel);
        if ( r != ERROR_SUCCESS )
        {
            return r;
        }
        // ファイル出力オープン
        HANDLE hFile = ::CreateFile(lpszFileName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, NULL);
        if ( hFile == INVALID_HANDLE_VALUE )
        {
            return _GetLastError("CreateFile");
        }
        DWORD tmp;
        if ( ! ::WriteFile(hFile, m.Ref(), ToDword(m.GetSize()), &tmp, NULL) )
        {
            DWORD r = _GetLastError("WriteFile");
            ::CloseHandle(hFile);
            return r;
        }
        ::CloseHandle(hFile);
        return ERROR_SUCCESS;   
    }
};
 
 
 
};//TNB