X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/3692b94818dcddb6e5bc2350147aabe8a260d6c6..b5b0a35d6b648aead1aa353dfe9c03775496981f:/src/msw/dib.cpp diff --git a/src/msw/dib.cpp b/src/msw/dib.cpp index 9aa457995a..efa5b11d4a 100644 --- a/src/msw/dib.cpp +++ b/src/msw/dib.cpp @@ -30,40 +30,42 @@ #pragma hdrstop #endif +#if wxUSE_WXDIB + #ifndef WX_PRECOMP #include "wx/string.h" #include "wx/log.h" + #include "wx/intl.h" #endif //WX_PRECOMP #include "wx/bitmap.h" -#include "wx/intl.h" #include "wx/file.h" #include #include #if !defined(__MWERKS__) && !defined(__SALFORDC__) -#include -#endif - -#ifdef __GNUWIN32_OLD__ - #include "wx/msw/gnuwin32/extra.h" + #include #endif #include "wx/image.h" #include "wx/msw/dib.h" +#ifdef __WXWINCE__ + #include // for SHLoadDIBitmap() +#endif + // ---------------------------------------------------------------------------- // private functions // ---------------------------------------------------------------------------- // calculate the number of palette entries needed for the bitmap with this // number of bits per pixel -static inline WORD wxGetNumOfBitmapColors(WORD bitsPerPixel) +static inline WORD GetNumberOfColours(WORD bitsPerPixel) { // only 1, 4 and 8bpp bitmaps use palettes (well, they could be used with // 24bpp ones too but we don't support this as I think it's quite uncommon) - return bitsPerPixel <= 8 ? 1 << bitsPerPixel : 0; + return (WORD)(bitsPerPixel <= 8 ? 1 << bitsPerPixel : 0); } // wrapper around ::GetObject() for DIB sections @@ -87,18 +89,21 @@ static inline bool GetDIBSection(HBITMAP hbmp, DIBSECTION *ds) bool wxDIB::Create(int width, int height, int depth) { - // we don't handle the palette yet - wxASSERT_MSG( depth == 24 || depth == 32, - _T("unsupported image depth in wxDIB::Create()") ); + // we don't support formats using palettes right now so we only create + // either 24bpp (RGB) or 32bpp (RGBA) bitmaps + wxASSERT_MSG( depth, _T("invalid image depth in wxDIB::Create()") ); + if ( depth < 24 ) + depth = 24; - static const int infosize = sizeof(BITMAPINFOHEADER); + // allocate memory for bitmap structures + static const int sizeHeader = sizeof(BITMAPINFOHEADER); - BITMAPINFO *info = (BITMAPINFO *)malloc(infosize); + BITMAPINFO *info = (BITMAPINFO *)malloc(sizeHeader); wxCHECK_MSG( info, false, _T("malloc(BITMAPINFO) failed") ); - memset(info, 0, infosize); + memset(info, 0, sizeHeader); - info->bmiHeader.biSize = infosize; + info->bmiHeader.biSize = sizeHeader; info->bmiHeader.biWidth = width; // we use positive height here which corresponds to a DIB with normal, i.e. @@ -109,7 +114,7 @@ bool wxDIB::Create(int width, int height, int depth) info->bmiHeader.biHeight = height; info->bmiHeader.biPlanes = 1; - info->bmiHeader.biBitCount = depth; + info->bmiHeader.biBitCount = (WORD)depth; info->bmiHeader.biSizeImage = GetLineSize(width, depth)*height; m_handle = ::CreateDIBSection @@ -142,10 +147,18 @@ bool wxDIB::Create(const wxBitmap& bmp) { wxCHECK_MSG( bmp.Ok(), false, _T("wxDIB::Create(): invalid bitmap") ); + if ( !Create(GetHbitmapOf(bmp)) ) + return false; + + m_hasAlpha = bmp.HasAlpha(); + + return true; +} + +bool wxDIB::Create(HBITMAP hbmp) +{ // this bitmap could already be a DIB section in which case we don't need // to convert it to DIB - HBITMAP hbmp = GetHbitmapOf(bmp); - DIBSECTION ds; if ( GetDIBSection(hbmp, &ds) ) { @@ -163,49 +176,113 @@ bool wxDIB::Create(const wxBitmap& bmp) } else // no, it's a DDB -- convert it to DIB { - const int w = bmp.GetWidth(); - const int h = bmp.GetHeight(); - int d = bmp.GetDepth(); - if ( d == -1 ) - d = wxDisplayDepth(); + // prepare all the info we need + BITMAP bm; + if ( !::GetObject(hbmp, sizeof(bm), &bm) ) + { + wxLogLastError(wxT("GetObject(bitmap)")); - if ( !Create(w, h, d) ) return false; + } - if ( !GetDIBSection(m_handle, &ds) ) - { - // we've just created a new DIB section, why should this fail? - wxFAIL_MSG( _T("GetObject(DIBSECTION) unexpectedly failed") ); + int d = bm.bmBitsPixel; + if ( d <= 0 ) + d = wxDisplayDepth(); + if ( !Create(bm.bmWidth, bm.bmHeight, d) || !CopyFromDDB(hbmp) ) return false; - } + } - if ( !::GetDIBits - ( - ScreenHDC(), // the DC to use - hbmp, // the source DDB - 0, // first scan line - h, // number of lines to copy - ds.dsBm.bmBits, // pointer to the buffer - (BITMAPINFO *)&ds.dsBmih, // bitmap header - DIB_RGB_COLORS // and not DIB_PAL_COLORS - ) ) - { - wxLogLastError(wxT("GetDIBits()")); + return true; +} - return 0; - } +// Windows CE doesn't have GetDIBits() so use an alternative implementation +// for it +// +// in fact I'm not sure if GetDIBits() is really much better than using +// BitBlt() like this -- it should be faster but I didn't do any tests, if +// anybody has time to do them and by chance finds that GetDIBits() is not +// much faster than BitBlt(), we could always use the Win CE version here +#ifdef __WXWINCE__ + +bool wxDIB::CopyFromDDB(HBITMAP hbmp) +{ + MemoryHDC hdcSrc; + if ( !hdcSrc ) + return false; + + SelectInHDC selectSrc(hdcSrc, hbmp); + if ( !selectSrc ) + return false; + + MemoryHDC hdcDst; + if ( !hdcDst ) + return false; + + SelectInHDC selectDst(hdcDst, m_handle); + if ( !selectDst ) + return false; + + + if ( !::BitBlt( + hdcDst, + 0, 0, m_width, m_height, + hdcSrc, + 0, 0, + SRCCOPY + ) ) + { + wxLogLastError(_T("BitBlt(DDB -> DIB)")); + + return false; } return true; } +#else // !__WXWINCE__ + +bool wxDIB::CopyFromDDB(HBITMAP hbmp) +{ + DIBSECTION ds; + if ( !GetDIBSection(m_handle, &ds) ) + { + // we're sure that our handle is a DIB section, so this should work + wxFAIL_MSG( _T("GetObject(DIBSECTION) unexpectedly failed") ); + + return false; + } + + if ( !::GetDIBits + ( + ScreenHDC(), // the DC to use + hbmp, // the source DDB + 0, // first scan line + m_height, // number of lines to copy + ds.dsBm.bmBits, // pointer to the buffer + (BITMAPINFO *)&ds.dsBmih, // bitmap header + DIB_RGB_COLORS // and not DIB_PAL_COLORS + ) ) + { + wxLogLastError(wxT("GetDIBits()")); + + return false; + } + + return true; +} + +#endif // __WXWINCE__/!__WXWINCE__ + // ---------------------------------------------------------------------------- // Loading/saving the DIBs // ---------------------------------------------------------------------------- bool wxDIB::Load(const wxString& filename) { +#ifdef __WXWINCE__ + m_handle = SHLoadDIBitmap(filename); +#else // !__WXWINCE__ m_handle = (HBITMAP)::LoadImage ( wxGetInstance(), @@ -214,9 +291,11 @@ bool wxDIB::Load(const wxString& filename) 0, 0, // don't specify the size LR_CREATEDIBSECTION | LR_LOADFROMFILE ); +#endif // __WXWINCE__ + if ( !m_handle ) { - wxLogLastError(_T("LoadImage(LR_CREATEDIBSECTION | LR_LOADFROMFILE)")); + wxLogLastError(_T("Loading DIB from file")); return false; } @@ -301,6 +380,8 @@ void wxDIB::DoGetObject() const // DDB <-> DIB conversions // ---------------------------------------------------------------------------- +#ifndef __WXWINCE__ + HBITMAP wxDIB::CreateDDB(HDC hdc) const { wxCHECK_MSG( m_handle, 0, _T("wxDIB::CreateDDB(): invalid object") ); @@ -313,7 +394,31 @@ HBITMAP wxDIB::CreateDDB(HDC hdc) const return 0; } - return ConvertToBitmap((BITMAPINFO *)&ds.dsBmih, hdc, ds.dsBm.bmBits); + // how many colours are we going to have in the palette? + DWORD biClrUsed = ds.dsBmih.biClrUsed; + if ( !biClrUsed ) + { + // biClrUsed field might not be set + biClrUsed = GetNumberOfColours(ds.dsBmih.biBitCount); + } + + if ( !biClrUsed ) + { + return ConvertToBitmap((BITMAPINFO *)&ds.dsBmih, hdc, ds.dsBm.bmBits); + } + else + { + // fake a BITMAPINFO w/o bits, just the palette info + wxCharBuffer bmi(sizeof(BITMAPINFO) + (biClrUsed - 1)*sizeof(RGBQUAD)); + BITMAPINFO *pBmi = (BITMAPINFO *)bmi.data(); + MemoryHDC hDC; + // get the colour table + SelectInHDC sDC(hDC, m_handle); + ::GetDIBColorTable(hDC, 0, biClrUsed, pBmi->bmiColors); + memcpy(&pBmi->bmiHeader, &ds.dsBmih, ds.dsBmih.biSize); + + return ConvertToBitmap(pBmi, hdc, ds.dsBm.bmBits); + } } /* static */ @@ -349,7 +454,7 @@ HBITMAP wxDIB::ConvertToBitmap(const BITMAPINFO *pbmi, HDC hdc, void *bits) numColors = pbmih->biClrUsed; if ( !numColors ) { - numColors = wxGetNumOfBitmapColors(pbmih->biBitCount); + numColors = GetNumberOfColours(pbmih->biBitCount); } break; @@ -415,7 +520,7 @@ size_t wxDIB::ConvertFromBitmap(BITMAPINFO *pbi, HBITMAP hbmp) bi.biBitCount = bm.bmBitsPixel; // memory we need for BITMAPINFO only - DWORD dwLen = bi.biSize + wxGetNumOfBitmapColors(bm.bmBitsPixel) * sizeof(RGBQUAD); + DWORD dwLen = bi.biSize + GetNumberOfColours(bm.bmBitsPixel) * sizeof(RGBQUAD); // get either just the image size or the image bits if ( !::GetDIBits @@ -461,7 +566,7 @@ HGLOBAL wxDIB::ConvertFromBitmap(HBITMAP hbmp) return NULL; } - if ( !ConvertFromBitmap((BITMAPINFO *)(void *)GlobalPtr(hDIB), hbmp) ) + if ( !ConvertFromBitmap((BITMAPINFO *)(void *)GlobalPtrLock(hDIB), hbmp) ) { // this really shouldn't happen... it worked the first time, why not // now? @@ -473,6 +578,8 @@ HGLOBAL wxDIB::ConvertFromBitmap(HBITMAP hbmp) return hDIB; } +#endif // __WXWINCE__ + // ---------------------------------------------------------------------------- // palette support // ---------------------------------------------------------------------------- @@ -481,6 +588,10 @@ HGLOBAL wxDIB::ConvertFromBitmap(HBITMAP hbmp) wxPalette *wxDIB::CreatePalette() const { + // GetDIBColorTable not available in eVC3 +#if defined(_WIN32_WCE) && _WIN32_WCE < 400 + return NULL; +#else wxCHECK_MSG( m_handle, NULL, _T("wxDIB::CreatePalette(): invalid object") ); DIBSECTION ds; @@ -496,7 +607,7 @@ wxPalette *wxDIB::CreatePalette() const if ( !biClrUsed ) { // biClrUsed field might not be set - biClrUsed = wxGetNumOfBitmapColors(ds.dsBmih.biBitCount); + biClrUsed = GetNumberOfColours(ds.dsBmih.biBitCount); } if ( !biClrUsed ) @@ -508,6 +619,8 @@ wxPalette *wxDIB::CreatePalette() const return NULL; } + MemoryHDC hDC; + // LOGPALETTE struct has only 1 element in palPalEntry array, we're // going to have biClrUsed of them so add necessary space LOGPALETTE *pPalette = (LOGPALETTE *) @@ -516,10 +629,13 @@ wxPalette *wxDIB::CreatePalette() const // initialize the palette header pPalette->palVersion = 0x300; // magic number, not in docs but works - pPalette->palNumEntries = biClrUsed; + pPalette->palNumEntries = (WORD)biClrUsed; - // and the colour table (it starts right after the end of the header) - const RGBQUAD *pRGB = (RGBQUAD *)((char *)&ds.dsBmih + ds.dsBmih.biSize); + // and the colour table + wxCharBuffer rgb(sizeof(RGBQUAD) * biClrUsed); + RGBQUAD *pRGB = (RGBQUAD*)rgb.data(); + SelectInHDC selectHandle(hDC, m_handle); + ::GetDIBColorTable(hDC, 0, biClrUsed, pRGB); for ( DWORD i = 0; i < biClrUsed; i++, pRGB++ ) { pPalette->palPalEntry[i].peRed = pRGB->rgbRed; @@ -543,6 +659,7 @@ wxPalette *wxDIB::CreatePalette() const palette->SetHPALETTE((WXHPALETTE)hPalette); return palette; +#endif } #endif // wxUSE_PALETTE @@ -562,8 +679,8 @@ bool wxDIB::Create(const wxImage& image) // if we have alpha channel, we need to create a 32bpp RGBA DIB, otherwise // a 24bpp RGB is sufficient - const bool hasAlpha = image.HasAlpha(); - const int bpp = hasAlpha ? 32 : 24; + m_hasAlpha = image.HasAlpha(); + const int bpp = m_hasAlpha ? 32 : 24; if ( !Create(w, h, bpp) ) return false; @@ -573,23 +690,37 @@ bool wxDIB::Create(const wxImage& image) const int srcBytesPerLine = w * 3; const int dstBytesPerLine = GetLineSize(w, bpp); const unsigned char *src = image.GetData() + ((h - 1) * srcBytesPerLine); - const unsigned char *alpha = hasAlpha ? image.GetAlpha() + (h - 1)*w : NULL; + const unsigned char *alpha = m_hasAlpha ? image.GetAlpha() + (h - 1)*w + : NULL; unsigned char *dstLineStart = (unsigned char *)m_data; for ( int y = 0; y < h; y++ ) { // copy one DIB line unsigned char *dst = dstLineStart; - for ( int x = 0; x < w; x++ ) + if ( alpha ) { - // also, the order of RGB is inversed for DIBs - *dst++ = src[2]; - *dst++ = src[1]; - *dst++ = src[0]; - - src += 3; - - if ( alpha ) - *dst++ = *alpha++; + for ( int x = 0; x < w; x++ ) + { + // RGB order is reversed, and we need to premultiply + // all channels by alpha value for use with ::AlphaBlend. + const unsigned char a = *alpha++; + *dst++ = (unsigned char)((src[2] * a + 127) / 255); + *dst++ = (unsigned char)((src[1] * a + 127) / 255); + *dst++ = (unsigned char)((src[0] * a + 127) / 255); + *dst++ = a; + src += 3; + } + } + else // no alpha channel + { + for ( int x = 0; x < w; x++ ) + { + // RGB order is reversed. + *dst++ = src[2]; + *dst++ = src[1]; + *dst++ = src[0]; + src += 3; + } } // pass to the previous line in the image @@ -604,5 +735,68 @@ bool wxDIB::Create(const wxImage& image) return true; } +wxImage wxDIB::ConvertToImage() const +{ + wxCHECK_MSG( IsOk(), wxNullImage, + wxT("can't convert invalid DIB to wxImage") ); + + // create the wxImage object + const int w = GetWidth(); + const int h = GetHeight(); + wxImage image(w, h, false /* don't bother clearing memory */); + if ( !image.Ok() ) + { + wxFAIL_MSG( wxT("could not allocate data for image") ); + return wxNullImage; + } + + if ( m_hasAlpha ) + { + image.SetAlpha(); + } + + // this is the same loop as in Create() just above but with copy direction + // reversed + const int bpp = GetDepth(); + const int dstBytesPerLine = w * 3; + const int srcBytesPerLine = GetLineSize(w, bpp); + unsigned char *dst = image.GetData() + ((h - 1) * dstBytesPerLine); + unsigned char *alpha = image.HasAlpha() ? image.GetAlpha() + (h - 1)*w + : NULL; + const bool is32bit = bpp == 32; + const unsigned char *srcLineStart = (unsigned char *)GetData(); + for ( int y = 0; y < h; y++ ) + { + // copy one DIB line + const unsigned char *src = srcLineStart; + for ( int x = 0; x < w; x++ ) + { + dst[2] = *src++; + dst[1] = *src++; + dst[0] = *src++; + + dst += 3; + + if ( is32bit ) + { + if ( alpha ) + *alpha++ = *src; + src++; + } + } + + // pass to the previous line in the image + dst -= 2*dstBytesPerLine; + if ( alpha ) + alpha -= 2*w; + + // and to the next one in the DIB + srcLineStart += srcBytesPerLine; + } + + return image; +} + #endif // wxUSE_IMAGE +#endif // wxUSE_WXDIB