X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/06d0938900acc655a047c9a81b97ffda838c4b17..431a3edc641e379b8f5d6010220250017e99a3ff:/src/msw/dib.cpp diff --git a/src/msw/dib.cpp b/src/msw/dib.cpp index e630937f07..a7eebe54f2 100644 --- a/src/msw/dib.cpp +++ b/src/msw/dib.cpp @@ -12,8 +12,7 @@ /* TODO: support for palettes is very incomplete, several functions simply ignore them (we should select and realize the palette, if any, before - caling GetDIBits() in the DC we use with it and we shouldn't use - GetBitmapBits() at all because we can't do it with it) + caling GetDIBits() in the DC we use with it. */ // ============================================================================ @@ -36,6 +35,8 @@ #include "wx/log.h" #endif //WX_PRECOMP +#if wxUSE_WXDIB + #include "wx/bitmap.h" #include "wx/intl.h" #include "wx/file.h" @@ -44,7 +45,7 @@ #include #if !defined(__MWERKS__) && !defined(__SALFORDC__) -#include + #include #endif #ifdef __GNUWIN32_OLD__ @@ -54,19 +55,34 @@ #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 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; } +// wrapper around ::GetObject() for DIB sections +static inline bool GetDIBSection(HBITMAP hbmp, DIBSECTION *ds) +{ + // note that at least under Win9x (this doesn't seem to happen under Win2K + // but this doesn't mean anything, of course), GetObject() may return + // sizeof(DIBSECTION) for a bitmap which is *not* a DIB section and the way + // to check for it is by looking at the bits pointer + return ::GetObject(hbmp, sizeof(DIBSECTION), ds) == sizeof(DIBSECTION) && + ds->dsBm.bmBits; +} + // ============================================================================ // implementation // ============================================================================ @@ -77,18 +93,21 @@ static WORD wxGetNumOfBitmapColors(WORD bitsPerPixel) 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. @@ -132,12 +151,20 @@ 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 ( ::GetObject(hbmp, sizeof(ds), &ds) == sizeof(ds) ) + if ( GetDIBSection(hbmp, &ds) ) { m_handle = hbmp; @@ -153,38 +180,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 ) + // prepare all the info we need + BITMAP bm; + if ( !::GetObject(hbmp, sizeof(bm), &bm) ) + { + wxLogLastError(wxT("GetObject(bitmap)")); + + return false; + } + + int d = bm.bmBitsPixel; + if ( d <= 0 ) d = wxDisplayDepth(); - if ( !Create(w, h, d) ) + if ( !Create(bm.bmWidth, bm.bmHeight, d) || !CopyFromDDB(hbmp) ) return false; + } - // we could have used GetDIBits() too but GetBitmapBits() is simpler - if ( !::GetBitmapBits - ( - GetHbitmapOf(bmp), // the source DDB - GetLineSize(w, d)*h, // the number of bytes to copy - m_data // the pixels will be copied here - ) ) - { - 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(), @@ -193,9 +295,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; } @@ -212,7 +316,7 @@ bool wxDIB::Save(const wxString& filename) if ( ok ) { DIBSECTION ds; - if ( !::GetObject(m_handle, sizeof(ds), &ds) ) + if ( !GetDIBSection(m_handle, &ds) ) { wxLogLastError(_T("GetObject(hDIB)")); } @@ -261,7 +365,7 @@ void wxDIB::DoGetObject() const // check for this now rather than trying to find out why it doesn't // work later DIBSECTION ds; - if ( !::GetObject(m_handle, sizeof(ds), &ds) ) + if ( !GetDIBSection(m_handle, &ds) ) { wxLogLastError(_T("GetObject(hDIB)")); return; @@ -280,12 +384,14 @@ 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") ); DIBSECTION ds; - if ( !::GetObject(m_handle, sizeof(ds), &ds) ) + if ( !GetDIBSection(m_handle, &ds) ) { wxLogLastError(_T("GetObject(hDIB)")); @@ -328,7 +434,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; @@ -394,7 +500,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 @@ -440,7 +546,7 @@ HGLOBAL wxDIB::ConvertFromBitmap(HBITMAP hbmp) return NULL; } - if ( !ConvertFromBitmap((BITMAPINFO *)GlobalPtr(hDIB), hbmp) ) + if ( !ConvertFromBitmap((BITMAPINFO *)(void *)GlobalPtr(hDIB), hbmp) ) { // this really shouldn't happen... it worked the first time, why not // now? @@ -452,6 +558,8 @@ HGLOBAL wxDIB::ConvertFromBitmap(HBITMAP hbmp) return hDIB; } +#endif // __WXWINCE__ + // ---------------------------------------------------------------------------- // palette support // ---------------------------------------------------------------------------- @@ -463,7 +571,7 @@ wxPalette *wxDIB::CreatePalette() const wxCHECK_MSG( m_handle, NULL, _T("wxDIB::CreatePalette(): invalid object") ); DIBSECTION ds; - if ( !::GetObject(m_handle, sizeof(ds), &ds) ) + if ( !GetDIBSection(m_handle, &ds) ) { wxLogLastError(_T("GetObject(hDIB)")); @@ -475,7 +583,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 ) @@ -541,8 +649,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; @@ -552,7 +660,8 @@ 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++ ) { @@ -583,5 +692,69 @@ 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 +