#include "wx/msw/dib.h"
#include "wx/image.h"
+// missing from mingw32 header
+#ifndef CLR_INVALID
+ #define CLR_INVALID ((COLORREF)-1)
+#endif // no CLR_INVALID
+
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
-#if !USE_SHARED_LIBRARIES
- IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
- IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
+IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
+IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
- IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
-#endif
+IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
// ============================================================================
// implementation
// the mask returned by GetIconInfo() is inversed compared to the usual
// wxWin convention
- HBITMAP hbmpMask = ::CreateBitmap(w, h, 1, 1, 0);
-
- // the icons mask is opposite to the usual wxWin convention
- HDC dcSrc = ::CreateCompatibleDC(NULL);
- HDC dcDst = ::CreateCompatibleDC(NULL);
- (void)SelectObject(dcSrc, iconInfo.hbmMask);
- (void)SelectObject(dcDst, hbmpMask);
-
- HBRUSH brush = ::CreateSolidBrush(RGB(255, 255, 255));
- RECT rect = { 0, 0, w, h };
- FillRect(dcDst, &rect, brush);
-
- BitBlt(dcDst, 0, 0, w, h, dcSrc, 0, 0, SRCINVERT);
-
- SelectObject(dcDst, NULL);
- SelectObject(dcSrc, NULL);
- DeleteDC(dcDst);
- DeleteDC(dcSrc);
-
- refData->m_bitmapMask = new wxMask((WXHBITMAP)hbmpMask);
+ refData->m_bitmapMask = new wxMask((WXHBITMAP)
+ wxInvertMask(iconInfo.hbmMask, w, h));
#if WXWIN_COMPATIBILITY_2
refData->m_ok = TRUE;
wxFAIL_MSG( _T("don't know how to convert cursor to bitmap") );
return FALSE;
-#endif // Win16
-
+#else
return CopyFromIconOrCursor(cursor);
+#endif // Win16
}
bool wxBitmap::CopyFromIcon(const wxIcon& icon)
wxTheBitmapList->DeleteObject(this);
}
-wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
+wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
{
Init();
wxBitmapRefData *refData = new wxBitmapRefData;
m_refData = refData;
- refData->m_width = the_width;
- refData->m_height = the_height;
- refData->m_depth = no_bits;
+ refData->m_width = width;
+ refData->m_height = height;
+ refData->m_depth = depth;
refData->m_numColors = 0;
refData->m_selectedInto = NULL;
- HBITMAP hbmp = ::CreateBitmap(the_width, the_height, 1, no_bits, bits);
+ char *data;
+ if ( depth == 1 )
+ {
+ // we assume that it is in XBM format which is not quite the same as
+ // the format CreateBitmap() wants because the order of bytes in the
+ // line is inversed!
+ static const size_t bytesPerLine = (width + 7) / 8;
+ static const size_t padding = bytesPerLine % 2;
+ static const size_t len = height * ( padding + bytesPerLine );
+ data = (char *)malloc(len);
+ const char *src = bits;
+ char *dst = data;
+
+ for ( int rows = 0; rows < height; rows++ )
+ {
+ for ( size_t cols = 0; cols < bytesPerLine; cols++ )
+ {
+ unsigned char val = *src++;
+ unsigned char reversed = 0;
+
+ for ( int bits = 0; bits < 8; bits++)
+ {
+ reversed <<= 1;
+ reversed |= (val & 0x01);
+ val >>= 1;
+ }
+ *dst++ = reversed;
+ }
+
+ if ( padding )
+ *dst++ = 0;
+ }
+ }
+ else
+ {
+ // bits should already be in Windows standard format
+ data = (char *)bits; // const_cast is harmless
+ }
+
+ HBITMAP hbmp = ::CreateBitmap(width, height, 1, depth, data);
if ( !hbmp )
{
wxLogLastError("CreateBitmap");
}
+ if ( data != bits )
+ {
+ free(data);
+ }
+
SetHBITMAP((WXHBITMAP)hbmp);
}
// Create from XPM data
-wxBitmap::wxBitmap(char **data, wxControl *WXUNUSED(anItem))
+bool wxBitmap::CreateFromXpm(const char **data)
{
Init();
- (void)Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
+ return Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
}
wxBitmap::wxBitmap(int w, int h, int d)
}
}
+// ----------------------------------------------------------------------------
+// sub bitmap extraction
+// ----------------------------------------------------------------------------
+
+wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
+{
+ wxCHECK_MSG( Ok() &&
+ (rect.x >= 0) && (rect.y >= 0) &&
+ (rect.x+rect.width <= GetWidth()) &&
+ (rect.y+rect.height <= GetHeight()),
+ wxNullBitmap, wxT("Invalid bitmap or bitmap region") );
+
+ wxBitmap ret( rect.width, rect.height, GetDepth() );
+ wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
+
+ // copy bitmap data
+ HDC dcSrc = ::CreateCompatibleDC(NULL);
+ HDC dcDst = ::CreateCompatibleDC(NULL);
+ SelectObject(dcSrc, (HBITMAP) GetHBITMAP());
+ SelectObject(dcDst, (HBITMAP) ret.GetHBITMAP());
+ BitBlt(dcDst, 0, 0, rect.width, rect.height, dcSrc, rect.x, rect.y, SRCCOPY);
+
+ // copy mask if there is one
+ if (GetMask())
+ {
+ HBITMAP hbmpMask = ::CreateBitmap(rect.width, rect.height, 1, 1, 0);
+
+ SelectObject(dcSrc, (HBITMAP) GetMask()->GetMaskBitmap());
+ SelectObject(dcDst, (HBITMAP) hbmpMask);
+ BitBlt(dcDst, 0, 0, rect.width, rect.height, dcSrc, rect.x, rect.y, SRCCOPY);
+
+ wxMask *mask = new wxMask((WXHBITMAP) hbmpMask);
+ ret.SetMask(mask);
+ }
+
+ SelectObject(dcDst, NULL);
+ SelectObject(dcSrc, NULL);
+ DeleteDC(dcDst);
+ DeleteDC(dcSrc);
+
+ return ret;
+}
+
// ----------------------------------------------------------------------------
// wxBitmap accessors
// ----------------------------------------------------------------------------
wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
{
wxMemoryDC memDC;
- wxBitmap tmpBitmap(this->GetWidth(), this->GetHeight(), dc.GetDepth());
+ wxBitmap tmpBitmap(GetWidth(), GetHeight(), dc.GetDepth());
HPALETTE hPal = (HPALETTE) NULL;
LPBITMAPINFO lpDib;
void *lpBits = (void*) NULL;
// Create a mask from a mono bitmap (copies the bitmap).
bool wxMask::Create(const wxBitmap& bitmap)
{
+ wxCHECK_MSG( bitmap.Ok() && bitmap.GetDepth() == 1, FALSE,
+ _T("can't create mask from invalid or not monochrome bitmap") );
+
if ( m_maskBitmap )
{
::DeleteObject((HBITMAP) m_maskBitmap);
m_maskBitmap = 0;
}
- if (!bitmap.Ok() || bitmap.GetDepth() != 1)
- {
- return FALSE;
- }
+
m_maskBitmap = (WXHBITMAP) CreateBitmap(
bitmap.GetWidth(),
bitmap.GetHeight(),
// the transparent area
bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
{
+ wxCHECK_MSG( bitmap.Ok(), FALSE, _T("invalid bitmap in wxMask::Create") );
+
if ( m_maskBitmap )
{
::DeleteObject((HBITMAP) m_maskBitmap);
m_maskBitmap = 0;
}
- if (!bitmap.Ok())
+
+ int width = bitmap.GetWidth(),
+ height = bitmap.GetHeight();
+
+ // scan the bitmap for the transparent colour and set the corresponding
+ // pixels in the mask to BLACK and the rest to WHITE
+ COLORREF maskColour = wxColourToRGB(colour);
+ m_maskBitmap = (WXHBITMAP)::CreateBitmap(width, height, 1, 1, 0);
+
+ HDC srcDC = ::CreateCompatibleDC(NULL);
+ HDC destDC = ::CreateCompatibleDC(NULL);
+ if ( !srcDC || !destDC )
{
- return FALSE;
+ wxLogLastError("CreateCompatibleDC");
}
- // scan the bitmap for the transparent colour and set
- // the corresponding pixels in the mask to BLACK and
- // the rest to WHITE
- COLORREF maskColour = RGB(colour.Red(), colour.Green(), colour.Blue());
- m_maskBitmap = (WXHBITMAP) ::CreateBitmap(
- bitmap.GetWidth(),
- bitmap.GetHeight(),
- 1, 1, 0
- );
- HDC srcDC = ::CreateCompatibleDC(0);
- ::SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP());
- HDC destDC = ::CreateCompatibleDC(0);
- ::SelectObject(destDC, (HBITMAP) m_maskBitmap);
-
- // this is not very efficient, but I can't think
- // of a better way of doing it
- for (int w = 0; w < bitmap.GetWidth(); w++)
+ bool ok = TRUE;
+
+ HGDIOBJ hbmpSrcOld = ::SelectObject(srcDC, GetHbitmapOf(bitmap));
+ if ( !hbmpSrcOld )
+ {
+ wxLogLastError("SelectObject");
+
+ ok = FALSE;
+ }
+
+ HGDIOBJ hbmpDstOld = ::SelectObject(destDC, (HBITMAP)m_maskBitmap);
+ if ( !hbmpDstOld )
+ {
+ wxLogLastError("SelectObject");
+
+ ok = FALSE;
+ }
+
+ // this is not very efficient, but I can't think of a better way of doing
+ // it
+ for ( int w = 0; ok && (w < width); w++ )
{
- for (int h = 0; h < bitmap.GetHeight(); h++)
+ for ( int h = 0; ok && (h < height); h++ )
{
COLORREF col = GetPixel(srcDC, w, h);
- if (col == maskColour)
+ if ( col == CLR_INVALID )
+ {
+ wxLogLastError("GetPixel");
+
+ // doesn't make sense to continue
+ ok = FALSE;
+
+ break;
+ }
+
+ if ( col == maskColour )
{
::SetPixel(destDC, w, h, RGB(0, 0, 0));
}
}
}
}
- ::SelectObject(srcDC, 0);
+
+ ::SelectObject(srcDC, hbmpSrcOld);
::DeleteDC(srcDC);
- ::SelectObject(destDC, 0);
+ ::SelectObject(destDC, hbmpDstOld);
::DeleteDC(destDC);
- return TRUE;
+
+ return ok;
}
// ----------------------------------------------------------------------------
free(lpDIBHeader);
}
+// ----------------------------------------------------------------------------
+// other helper functions
+// ----------------------------------------------------------------------------
+
+extern HBITMAP wxInvertMask(HBITMAP hbmpMask, int w, int h)
+{
+ wxCHECK_MSG( hbmpMask, 0, _T("invalid bitmap in wxInvertMask") );
+
+ // get width/height from the bitmap if not given
+ if ( !w || !h )
+ {
+ BITMAP bm;
+ ::GetObject(hbmpMask, sizeof(BITMAP), (LPVOID)&bm);
+ w = bm.bmWidth;
+ h = bm.bmHeight;
+ }
+
+ HDC hdcSrc = ::CreateCompatibleDC(NULL);
+ HDC hdcDst = ::CreateCompatibleDC(NULL);
+ if ( !hdcSrc || !hdcDst )
+ {
+ wxLogLastError("CreateCompatibleDC");
+ }
+
+ HBITMAP hbmpInvMask = ::CreateBitmap(w, h, 1, 1, 0);
+ if ( !hbmpInvMask )
+ {
+ wxLogLastError("CreateBitmap");
+ }
+
+ ::SelectObject(hdcSrc, hbmpMask);
+ ::SelectObject(hdcDst, hbmpInvMask);
+ if ( !::BitBlt(hdcDst, 0, 0, w, h,
+ hdcSrc, 0, 0,
+ NOTSRCCOPY) )
+ {
+ wxLogLastError("BitBlt");
+ }
+
+ ::DeleteDC(hdcSrc);
+ ::DeleteDC(hdcDst);
+ return hbmpInvMask;
+}
projects / wxWidgets.git / blobdiff