wxExecute may only be called from the main thread

[wxWidgets.git] / src / msw / bitmap.cpp

diff --git a/src/msw/bitmap.cpp b/src/msw/bitmap.cpp
index 717fc89c3e1159af7ae9a089a8bd24efb892bac9..bdff57bb688e8b2a97496cf272081baeb22cfb73 100644 (file)
--- a/src/msw/bitmap.cpp
+++ b/src/msw/bitmap.cpp
@@ -1,4 +1,4 @@
-/////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////

 // Name:        bitmap.cpp
 // Purpose:     wxBitmap
 // Author:      Julian Smart
 // Name:        bitmap.cpp
 // Purpose:     wxBitmap
 // Author:      Julian Smart


@@ -55,6 +55,60 @@
     #define CLR_INVALID ((COLORREF)-1)
 #endif // no CLR_INVALID
 
     #define CLR_INVALID ((COLORREF)-1)
 #endif // no CLR_INVALID
 

+// ----------------------------------------------------------------------------
+// Bitmap data
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxBitmapRefData : public wxGDIImageRefData
+{
+public:
+    wxBitmapRefData();
+    virtual ~wxBitmapRefData() { Free(); }
+
+    virtual void Free();
+
+    // set the mask object to use as the mask, we take ownership of it
+    void SetMask(wxMask *mask)
+    {
+        delete m_bitmapMask;
+        m_bitmapMask = mask;
+    }
+
+    // set the HBITMAP to use as the mask
+    void SetMask(HBITMAP hbmpMask)
+    {
+        SetMask(new wxMask((WXHBITMAP)hbmpMask));
+    }
+
+    // return the mask
+    wxMask *GetMask() const { return m_bitmapMask; }
+
+public:
+    int           m_numColors;
+#if wxUSE_PALETTE
+    wxPalette     m_bitmapPalette;
+#endif // wxUSE_PALETTE
+
+    // MSW-specific
+    // ------------
+
+    // this field is solely for error checking: we detect selecting a bitmap
+    // into more than one DC at once or deleting a bitmap still selected into a
+    // DC (both are serious programming errors under Windows)
+    wxDC         *m_selectedInto;
+
+#if wxUSE_DIB_FOR_BITMAP
+    // file mapping handle for large DIB's
+    HANDLE        m_hFileMap;
+#endif // wxUSE_DIB_FOR_BITMAP
+
+private:
+    // optional mask for transparent drawing
+    wxMask       *m_bitmapMask;
+
+    DECLARE_NO_COPY_CLASS(wxBitmapRefData)
+};
+

 // ----------------------------------------------------------------------------
 // macros
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // macros
 // ----------------------------------------------------------------------------


@@ -74,11 +128,13 @@ IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
 
 wxBitmapRefData::wxBitmapRefData()
 {
 
 wxBitmapRefData::wxBitmapRefData()
 {

-    m_quality = 0;

     m_selectedInto = NULL;
     m_numColors = 0;
     m_bitmapMask = NULL;
     m_hBitmap = (WXHBITMAP) NULL;
     m_selectedInto = NULL;
     m_numColors = 0;
     m_bitmapMask = NULL;
     m_hBitmap = (WXHBITMAP) NULL;

+#if wxUSE_DIB_FOR_BITMAP
+    m_hFileMap = 0;
+#endif // wxUSE_DIB_FOR_BITMAP

 }
 
 void wxBitmapRefData::Free()
 }
 
 void wxBitmapRefData::Free()


@@ -94,6 +150,15 @@ void wxBitmapRefData::Free()
         }
     }
 
         }
     }
 

+#if wxUSE_DIB_FOR_BITMAP
+    if ( m_hFileMap )
+    {
+      ::CloseHandle(m_hFileMap);
+
+      m_hFileMap = 0;
+    }
+#endif // wxUSE_DIB_FOR_BITMAP
+

     delete m_bitmapMask;
     m_bitmapMask = NULL;
 }
     delete m_bitmapMask;
     m_bitmapMask = NULL;
 }


@@ -109,6 +174,11 @@ void wxBitmap::Init()
 
 }
 
 
 }
 

+wxGDIImageRefData *wxBitmap::CreateData() const
+{
+    return new wxBitmapRefData;
+}
+

 #ifdef __WIN32__
 
 bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& icon)
 #ifdef __WIN32__
 
 bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& icon)


@@ -139,8 +209,7 @@ bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& icon)
 
     // the mask returned by GetIconInfo() is inversed compared to the usual
     // wxWin convention
 
     // the mask returned by GetIconInfo() is inversed compared to the usual
     // wxWin convention

-    refData->m_bitmapMask = new wxMask((WXHBITMAP)
-                                        wxInvertMask(iconInfo.hbmMask, w, h));
+    refData->SetMask(wxInvertMask(iconInfo.hbmMask, w, h));

 
 
     // delete the old one now as we don't need it any more
 
 
     // delete the old one now as we don't need it any more


@@ -332,48 +401,125 @@ wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
 
 bool wxBitmap::Create(int w, int h, int d)
 {
 
 bool wxBitmap::Create(int w, int h, int d)
 {

-#ifndef __WXMICROWIN__

     UnRef();
 
     m_refData = new wxBitmapRefData;
 
     UnRef();
 
     m_refData = new wxBitmapRefData;
 

-    GetBitmapData()->m_width = w;
-    GetBitmapData()->m_height = h;
-    GetBitmapData()->m_depth = d;
-
-    HBITMAP hbmp;
-
-    if ( d > 0 )
+#if wxUSE_DIB_FOR_BITMAP
+    if ( w && h && d >= 16 )

     {
     {

-        hbmp = ::CreateBitmap(w, h, 1, d, NULL);
-        if ( !hbmp )
-        {
-            wxLogLastError(wxT("CreateBitmap"));
-        }
+        if ( !CreateDIB(w, h, d) )
+           return FALSE;

     }
     else
     }
     else

+#endif // wxUSE_DIB_FOR_BITMAP

     {
     {

-        ScreenHDC dc;
-        hbmp = ::CreateCompatibleBitmap(dc, w, h);
-        if ( !hbmp )
+        GetBitmapData()->m_width = w;
+        GetBitmapData()->m_height = h;
+        GetBitmapData()->m_depth = d;
+
+        HBITMAP hbmp;
+#ifndef __WXMICROWIN__
+        if ( d > 0 )

         {
         {

-            wxLogLastError(wxT("CreateCompatibleBitmap"));
+            hbmp = ::CreateBitmap(w, h, 1, d, NULL);
+            if ( !hbmp )
+            {
+                wxLogLastError(wxT("CreateBitmap"));
+            }

         }
         }

+        else
+#endif // !__WXMICROWIN__
+        {
+            ScreenHDC dc;
+            hbmp = ::CreateCompatibleBitmap(dc, w, h);
+            if ( !hbmp )
+            {
+                wxLogLastError(wxT("CreateCompatibleBitmap"));
+            }

 
 

-        GetBitmapData()->m_depth = wxDisplayDepth();
-    }
+            GetBitmapData()->m_depth = wxDisplayDepth();
+        }

 
 

-    SetHBITMAP((WXHBITMAP)hbmp);
+        SetHBITMAP((WXHBITMAP)hbmp);

 
 #if WXWIN_COMPATIBILITY_2
 
 #if WXWIN_COMPATIBILITY_2

-    GetBitmapData()->m_ok = hbmp != 0;
+        GetBitmapData()->m_ok = hbmp != 0;

 #endif // WXWIN_COMPATIBILITY_2
 #endif // WXWIN_COMPATIBILITY_2

+    }
+

     return Ok();
     return Ok();

-#else
-    return FALSE;
-#endif

 }
 
 }
 

+#if wxUSE_DIB_FOR_BITMAP
+
+void *wxBitmap::CreateDIB(int width, int height, int depth)
+{
+    void *dibBits;
+    const int infosize = sizeof(BITMAPINFOHEADER);
+
+    BITMAPINFO *info = (BITMAPINFO *)malloc(infosize);
+    if ( info )
+    {
+        memset(info, 0, infosize);
+
+        info->bmiHeader.biSize = infosize;
+        info->bmiHeader.biWidth = width;
+        info->bmiHeader.biHeight = height;
+        info->bmiHeader.biPlanes = 1;
+        info->bmiHeader.biBitCount = depth;
+        info->bmiHeader.biCompression = BI_RGB;
+        info->bmiHeader.biSizeImage =
+            (((width * (depth/8)) + sizeof(DWORD) - 1) /
+                sizeof(DWORD) * sizeof(DWORD)) * height;
+        info->bmiHeader.biXPelsPerMeter = 0;
+        info->bmiHeader.biYPelsPerMeter = 0;
+        info->bmiHeader.biClrUsed = 0;
+        info->bmiHeader.biClrImportant = 0;
+        GetBitmapData()->m_hFileMap = ::CreateFileMapping
+                                        (
+                                            INVALID_HANDLE_VALUE,
+                                            0,
+                                            PAGE_READWRITE | SEC_COMMIT,
+                                            0,
+                                            info->bmiHeader.biSizeImage,
+                                            0
+                                        );
+
+        // No need to report an error here.  If it fails, we just won't use a
+        // file mapping and CreateDIBSection will just allocate memory for us.
+        GetBitmapData()->m_handle =
+            (WXHANDLE)::CreateDIBSection
+                        (
+                            0,
+                            info,
+                            DIB_RGB_COLORS,
+                            &dibBits,
+                            GetBitmapData()->m_hFileMap,
+                            0
+                        );
+
+        if ( !GetBitmapData()->m_handle )
+          wxLogLastError(wxT("CreateDIBSection"));
+
+        SetWidth(width);
+        SetHeight(height);
+        SetDepth(depth);
+
+        free(info);
+    }
+    else
+    {
+        wxFAIL_MSG( wxT("could not allocate memory for DIB header") );
+
+        dibBits = NULL;
+    }
+
+    return dibBits;
+}
+
+#endif // wxUSE_DIB_FOR_BITMAP
+

 // ----------------------------------------------------------------------------
 // wxImage to/from conversions
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxImage to/from conversions
 // ----------------------------------------------------------------------------


@@ -383,18 +529,173 @@ bool wxBitmap::Create(int w, int h, int d)
 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 {
 #ifdef __WXMICROWIN__
 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 {
 #ifdef __WXMICROWIN__

-    // TODO
-    return FALSE;
+
+  // Set this to 1 to experiment with mask code,
+  // which currently doesn't work
+#define USE_MASKS 0
+
+    m_refData = new wxBitmapRefData();
+
+    // Initial attempt at a simple-minded implementation.
+    // The bitmap will always be created at the screen depth,
+    // so the 'depth' argument is ignored.
+
+    HDC hScreenDC = ::GetDC(NULL);
+    int screenDepth = ::GetDeviceCaps(hScreenDC, BITSPIXEL);
+
+    HBITMAP hBitmap = ::CreateCompatibleBitmap(hScreenDC, image.GetWidth(), image.GetHeight());
+    HBITMAP hMaskBitmap = NULL;
+    HBITMAP hOldMaskBitmap = NULL;
+    HDC hMaskDC = NULL;
+    unsigned char maskR = 0;
+    unsigned char maskG = 0;
+    unsigned char maskB = 0;
+
+    //    printf("Created bitmap %d\n", (int) hBitmap);
+    if (hBitmap == NULL)
+    {
+        ::ReleaseDC(NULL, hScreenDC);
+        return FALSE;
+    }
+    HDC hMemDC = ::CreateCompatibleDC(hScreenDC);
+
+    HBITMAP hOldBitmap = ::SelectObject(hMemDC, hBitmap);
+    ::ReleaseDC(NULL, hScreenDC);
+
+    // created an mono-bitmap for the possible mask
+    bool hasMask = image.HasMask();
+
+    if ( hasMask )
+    {
+#if USE_MASKS
+        // FIXME: we should be able to pass bpp = 1, but
+        // GdBlit can't handle a different depth
+#if 0
+        hMaskBitmap = ::CreateBitmap( (WORD)image.GetWidth(), (WORD)image.GetHeight(), 1, 1, NULL );

 #else
 #else

+        hMaskBitmap = ::CreateCompatibleBitmap( hMemDC, (WORD)image.GetWidth(), (WORD)image.GetHeight());
+#endif
+        maskR = image.GetMaskRed();
+        maskG = image.GetMaskGreen();
+        maskB = image.GetMaskBlue();
+
+        if (!hMaskBitmap)
+        {
+            hasMask = FALSE;
+        }
+        else
+        {
+            hScreenDC = ::GetDC(NULL);
+            hMaskDC = ::CreateCompatibleDC(hScreenDC);
+           ::ReleaseDC(NULL, hScreenDC);
+
+            hOldMaskBitmap = ::SelectObject( hMaskDC, hMaskBitmap);
+        }
+#else
+        hasMask = FALSE;
+#endif
+    }
+
+    int i, j;
+    for (i = 0; i < image.GetWidth(); i++)
+    {
+        for (j = 0; j < image.GetHeight(); j++)
+        {
+            unsigned char red = image.GetRed(i, j);
+            unsigned char green = image.GetGreen(i, j);
+            unsigned char blue = image.GetBlue(i, j);
+
+            ::SetPixel(hMemDC, i, j, PALETTERGB(red, green, blue));
+
+            if (hasMask)
+            {
+                // scan the bitmap for the transparent colour and set the corresponding
+                // pixels in the mask to BLACK and the rest to WHITE
+                if (maskR == red && maskG == green && maskB == blue)
+                    ::SetPixel(hMaskDC, i, j, PALETTERGB(0, 0, 0));
+                else
+                    ::SetPixel(hMaskDC, i, j, PALETTERGB(255, 255, 255));
+            }
+        }
+    }
+
+    ::SelectObject(hMemDC, hOldBitmap);
+    ::DeleteDC(hMemDC);
+    if (hasMask)
+    {
+        ::SelectObject(hMaskDC, hOldMaskBitmap);
+        ::DeleteDC(hMaskDC);
+
+        ((wxBitmapRefData*)m_refData)->SetMask(hMaskBitmap);
+    }
+
+    SetWidth(image.GetWidth());
+    SetHeight(image.GetHeight());
+    SetDepth(screenDepth);
+    SetHBITMAP( (WXHBITMAP) hBitmap );
+
+#if wxUSE_PALETTE
+    // Copy the palette from the source image
+    SetPalette(image.GetPalette());
+#endif // wxUSE_PALETTE
+
+#if WXWIN_COMPATIBILITY_2
+    // check the wxBitmap object
+    GetBitmapData()->SetOk();
+#endif // WXWIN_COMPATIBILITY_2
+
+    return TRUE;
+
+#else // !__WXMICROWIN__

     wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
 
     m_refData = new wxBitmapRefData();
 
     wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
 
     m_refData = new wxBitmapRefData();
 

+#if wxUSE_DIB_FOR_BITMAP
+    int h = image.GetHeight();
+    int w = image.GetWidth();
+    unsigned char *dibBits = (unsigned char*)CreateDIB(w, h, 24);
+    if ( !dibBits )
+        return FALSE;
+
+    // DIBs are stored in bottom to top order so we need to copy bits line by
+    // line and starting from the end
+    const int srcBytesPerLine = w * 3;
+    const int dstBytesPerLine = (srcBytesPerLine + sizeof(DWORD) - 1) /
+                                    sizeof(DWORD) * sizeof(DWORD);
+    const unsigned char *src = image.GetData() + ((h - 1) * srcBytesPerLine);
+    for ( int i = 0; i < h; i++ )
+    {
+        // copy one DIB line
+        int x = w;
+        const unsigned char *rgbBits = src;
+        while ( x-- )
+        {
+            // also, the order of RGB is inversed for DIBs
+            *dibBits++ = rgbBits[2];
+            *dibBits++ = rgbBits[1];
+            *dibBits++ = rgbBits[0];
+
+            rgbBits += 3;
+        }
+
+        // pass to the next line
+        src -= srcBytesPerLine;
+        dibBits += dstBytesPerLine - srcBytesPerLine;
+    }
+
+    if ( image.HasMask() )
+    {
+        SetMask(new wxMask(*this, wxColour(image.GetMaskRed(),
+                                           image.GetMaskGreen(),
+                                           image.GetMaskBlue())));
+    }
+#else // wxUSE_DIB_FOR_BITMAP

     // sizeLimit is the MS upper limit for the DIB size
 #ifdef  WIN32
     int sizeLimit = 1024*768*3;
 #else
     // sizeLimit is the MS upper limit for the DIB size
 #ifdef  WIN32
     int sizeLimit = 1024*768*3;
 #else

-    int sizeLimit = 0x7fff ;
+    int sizeLimit = 0x7fff;

 #endif
 
     // width and height of the device-dependent bitmap
 #endif
 
     // width and height of the device-dependent bitmap


@@ -431,8 +732,10 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
     if (depth == -1) depth = wxDisplayDepth();
     SetDepth( depth );
 
     if (depth == -1) depth = wxDisplayDepth();
     SetDepth( depth );
 

+#if wxUSE_PALETTE

     // Copy the palette from the source image
     SetPalette(image.GetPalette());
     // Copy the palette from the source image
     SetPalette(image.GetPalette());

+#endif // wxUSE_PALETTE

 
     // create a DIB header
     int headersize = sizeof(BITMAPINFOHEADER);
 
     // create a DIB header
     int headersize = sizeof(BITMAPINFOHEADER);


@@ -606,6 +909,7 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
     ::ReleaseDC(NULL, hdc);
     free(lpDIBh);
     free(lpBits);
     ::ReleaseDC(NULL, hdc);
     free(lpDIBh);
     free(lpBits);

+#endif // wxUSE_DIB_FOR_BITMAP

 
 #if WXWIN_COMPATIBILITY_2
     // check the wxBitmap object
 
 #if WXWIN_COMPATIBILITY_2
     // check the wxBitmap object


@@ -613,15 +917,73 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 #endif // WXWIN_COMPATIBILITY_2
 
     return TRUE;
 #endif // WXWIN_COMPATIBILITY_2
 
     return TRUE;

-#endif
+#endif // __WXMICROWIN__/!__WXMICROWIN__

 }
 
 wxImage wxBitmap::ConvertToImage() const
 {
 #ifdef __WXMICROWIN__
 }
 
 wxImage wxBitmap::ConvertToImage() const
 {
 #ifdef __WXMICROWIN__

-    // TODO
-    return wxImage();
-#else
+    // Initial attempt at a simple-minded implementation.
+    // The bitmap will always be created at the screen depth,
+    // so the 'depth' argument is ignored.
+    // TODO: transparency (create a mask image)
+
+    if (!Ok())
+    {
+        wxFAIL_MSG( wxT("bitmap is invalid") );
+        return wxNullImage;
+    }
+
+    wxImage image;
+
+    wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
+
+    // create an wxImage object
+    int width = GetWidth();
+    int height = GetHeight();
+    image.Create( width, height );
+    unsigned char *data = image.GetData();
+    if( !data )
+    {
+        wxFAIL_MSG( wxT("could not allocate data for image") );
+        return wxNullImage;
+    }
+
+    HDC hScreenDC = ::GetDC(NULL);
+
+    HDC hMemDC = ::CreateCompatibleDC(hScreenDC);
+    ::ReleaseDC(NULL, hScreenDC);
+
+    HBITMAP hBitmap = (HBITMAP) GetHBITMAP();
+
+    HBITMAP hOldBitmap = ::SelectObject(hMemDC, hBitmap);
+
+    int i, j;
+    for (i = 0; i < GetWidth(); i++)
+    {
+        for (j = 0; j < GetHeight(); j++)
+        {
+            COLORREF color = ::GetPixel(hMemDC, i, j);
+            unsigned char red = GetRValue(color);
+            unsigned char green = GetGValue(color);
+            unsigned char blue = GetBValue(color);
+
+            image.SetRGB(i, j, red, green, blue);
+        }
+    }
+
+    ::SelectObject(hMemDC, hOldBitmap);
+    ::DeleteDC(hMemDC);
+
+#if wxUSE_PALETTE
+    // Copy the palette from the source image
+    if (GetPalette())
+        image.SetPalette(* GetPalette());
+#endif // wxUSE_PALETTE
+
+    return image;
+
+#else // !__WXMICROWIN__

     wxImage image;
 
     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
     wxImage image;
 
     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );


@@ -746,7 +1108,7 @@ wxImage wxBitmap::ConvertToImage() const
     free(lpBits);
 
     return image;
     free(lpBits);
 
     return image;

-#endif
+#endif // __WXMICROWIN__/!__WXMICROWIN__

 }
 
 #endif // wxUSE_IMAGE
 }
 
 #endif // wxUSE_IMAGE


@@ -769,7 +1131,7 @@ bool wxBitmap::LoadFile(const wxString& filename, long type)
         wxImage image;
         if ( image.LoadFile( filename, type ) && image.Ok() )
         {
         wxImage image;
         if ( image.LoadFile( filename, type ) && image.Ok() )
         {

-            *this = image.ConvertToBitmap();
+            *this = wxBitmap(image);

 
             return TRUE;
         }
 
             return TRUE;
         }


@@ -787,7 +1149,7 @@ bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
 
     if ( !handler )
     {
 
     if ( !handler )
     {

-        wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for type %d defined."), type);
+        wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for type %ld defined."), type);

 
         return FALSE;
     }
 
         return FALSE;
     }


@@ -811,7 +1173,7 @@ bool wxBitmap::SaveFile(const wxString& filename,
     else
     {
         // FIXME what about palette? shouldn't we use it?
     else
     {
         // FIXME what about palette? shouldn't we use it?

-        wxImage image( *this );
+        wxImage image = ConvertToImage();

         if ( image.Ok() )
         {
             return image.SaveFile(filename, type);
         if ( image.Ok() )
         {
             return image.SaveFile(filename, type);


@@ -828,7 +1190,6 @@ bool wxBitmap::SaveFile(const wxString& filename,
 
 wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
 {
 
 wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
 {

-#ifndef __WXMICROWIN__

     wxCHECK_MSG( Ok() &&
                  (rect.x >= 0) && (rect.y >= 0) &&
                  (rect.x+rect.width <= GetWidth()) &&
     wxCHECK_MSG( Ok() &&
                  (rect.x >= 0) && (rect.y >= 0) &&
                  (rect.x+rect.width <= GetWidth()) &&


@@ -838,56 +1199,90 @@ wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
     wxBitmap ret( rect.width, rect.height, GetDepth() );
     wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
 
     wxBitmap ret( rect.width, rect.height, GetDepth() );
     wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
 

+#ifndef __WXMICROWIN__

     // copy bitmap data
     // 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);
+    MemoryHDC dcSrc, dcDst;
+
+    {
+        SelectInHDC selectSrc(dcSrc, GetHbitmap()),
+                    selectDst(dcDst, GetHbitmapOf(ret));
+
+        if ( !::BitBlt(dcDst, 0, 0, rect.width, rect.height,
+                       dcSrc, rect.x, rect.y, SRCCOPY) )
+        {
+            wxLogLastError(_T("BitBlt"));
+        }
+    }

 
     // copy mask if there is one
 
     // copy mask if there is one

-    if (GetMask())
+    if ( GetMask() )

     {
         HBITMAP hbmpMask = ::CreateBitmap(rect.width, rect.height, 1, 1, 0);
 
     {
         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);
+        SelectInHDC selectSrc(dcSrc, (HBITMAP) GetMask()->GetMaskBitmap()),
+                    selectDst(dcDst, hbmpMask);
+
+        if ( !::BitBlt(dcDst, 0, 0, rect.width, rect.height,
+                       dcSrc, rect.x, rect.y, SRCCOPY) )
+        {
+            wxLogLastError(_T("BitBlt"));
+        }

 
         wxMask *mask = new wxMask((WXHBITMAP) hbmpMask);
         ret.SetMask(mask);
     }
 
         wxMask *mask = new wxMask((WXHBITMAP) hbmpMask);
         ret.SetMask(mask);
     }

-
-    SelectObject(dcDst, NULL);
-    SelectObject(dcSrc, NULL);
-    DeleteDC(dcDst);
-    DeleteDC(dcSrc);
+#endif // !__WXMICROWIN__

 
     return ret;
 
     return ret;

-#else
-    return wxBitmap();
-#endif

 }
 
 // ----------------------------------------------------------------------------
 // wxBitmap accessors
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // wxBitmap accessors
 // ----------------------------------------------------------------------------
 

-void wxBitmap::SetQuality(int q)
+wxPalette* wxBitmap::GetPalette() const

 {
 {

-    EnsureHasData();
+    return GetBitmapData() ? &GetBitmapData()->m_bitmapPalette
+                           : (wxPalette *) NULL;
+}

 
 

-    GetBitmapData()->m_quality = q;
+wxMask *wxBitmap::GetMask() const
+{
+    return GetBitmapData() ? GetBitmapData()->GetMask() : (wxMask *) NULL;

 }
 
 }
 

-#if WXWIN_COMPATIBILITY_2
-void wxBitmap::SetOk(bool isOk)
+wxDC *wxBitmap::GetSelectedInto() const

 {
 {

-    EnsureHasData();
+    return GetBitmapData() ? GetBitmapData()->m_selectedInto : (wxDC *) NULL;
+}

 
 

-    GetBitmapData()->m_ok = isOk;
+#if wxUSE_DIB_FOR_BITMAP
+
+bool wxBitmap::IsDIB() const
+{
+    return GetBitmapData() && GetBitmapData()->m_hFileMap != NULL;
+}
+
+#endif // wxUSE_DIB_FOR_BITMAP
+
+#if WXWIN_COMPATIBILITY_2_4
+
+int wxBitmap::GetQuality() const
+{
+    return 0;
+}
+
+#endif // WXWIN_COMPATIBILITY_2_4
+
+// ----------------------------------------------------------------------------
+// wxBitmap setters
+// ----------------------------------------------------------------------------
+
+void wxBitmap::SetSelectedInto(wxDC *dc)
+{
+    if ( GetBitmapData() )
+        GetBitmapData()->m_selectedInto = dc;

 }
 }

-#endif // WXWIN_COMPATIBILITY_2

 
 #if wxUSE_PALETTE
 
 
 #if wxUSE_PALETTE
 


@@ -904,9 +1299,32 @@ void wxBitmap::SetMask(wxMask *mask)
 {
     EnsureHasData();
 
 {
     EnsureHasData();
 

-    GetBitmapData()->m_bitmapMask = mask;
+    GetBitmapData()->SetMask(mask);
+}
+
+#if WXWIN_COMPATIBILITY_2
+
+void wxBitmap::SetOk(bool isOk)
+{
+    EnsureHasData();
+
+    GetBitmapData()->m_ok = isOk;

 }
 
 }
 

+#endif // WXWIN_COMPATIBILITY_2
+
+#if WXWIN_COMPATIBILITY_2_4
+
+void wxBitmap::SetQuality(int WXUNUSED(quality))
+{
+}
+
+#endif // WXWIN_COMPATIBILITY_2_4
+
+// ----------------------------------------------------------------------------
+// TODO: to be replaced by something better
+// ----------------------------------------------------------------------------
+

 // Creates a bitmap that matches the device context, from
 // an arbitray bitmap. At present, the original bitmap must have an
 // associated palette. TODO: use a default palette if no palette exists.
 // Creates a bitmap that matches the device context, from
 // an arbitray bitmap. At present, the original bitmap must have an
 // associated palette. TODO: use a default palette if no palette exists.


@@ -914,7 +1332,7 @@ void wxBitmap::SetMask(wxMask *mask)
 wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
 {
 #ifdef __WXMICROWIN__
 wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
 {
 #ifdef __WXMICROWIN__

-    return wxBitmap();
+    return *this;

 #else
     wxMemoryDC      memDC;
     wxBitmap        tmpBitmap(GetWidth(), GetHeight(), dc.GetDepth());
 #else
     wxMemoryDC      memDC;
     wxBitmap        tmpBitmap(GetWidth(), GetHeight(), dc.GetDepth());


@@ -1081,7 +1499,7 @@ bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
 
     // scan the bitmap for the transparent colour and set the corresponding
     // pixels in the mask to BLACK and the rest to WHITE
 
     // 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());
+    COLORREF maskColour = wxColourToPalRGB(colour);

     m_maskBitmap = (WXHBITMAP)::CreateBitmap(width, height, 1, 1, 0);
 
     HDC srcDC = ::CreateCompatibleDC(NULL);
     m_maskBitmap = (WXHBITMAP)::CreateBitmap(width, height, 1, 1, 0);
 
     HDC srcDC = ::CreateCompatibleDC(NULL);


@@ -1113,32 +1531,13 @@ bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
         ok = FALSE;
     }
 
         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++ )
+    if ( ok )

     {
     {

-        for ( int h = 0; ok && (h < height); h++ )
-        {
-            COLORREF col = GetPixel(srcDC, w, h);
-            if ( col == CLR_INVALID )
-            {
-                wxLogLastError(wxT("GetPixel"));
-
-                // doesn't make sense to continue
-                ok = FALSE;
-
-                break;
-            }
-
-            if ( col == maskColour )
-            {
-                ::SetPixel(destDC, w, h, RGB(0, 0, 0));
-            }
-            else
-            {
-                ::SetPixel(destDC, w, h, RGB(255, 255, 255));
-            }
-        }
+        // this will create a monochrome bitmap with 0 points for the pixels
+        // which have the same value as the background colour and 1 for the
+        // others
+        ::SetBkColor(srcDC, maskColour);
+        ::BitBlt(destDC, 0, 0, width, height, srcDC, 0, 0, NOTSRCCOPY);

     }
 
     ::SelectObject(srcDC, hbmpSrcOld);
     }
 
     ::SelectObject(srcDC, hbmpSrcOld);


@@ -1147,9 +1546,9 @@ bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
     ::DeleteDC(destDC);
 
     return ok;
     ::DeleteDC(destDC);
 
     return ok;

-#else
+#else // __WXMICROWIN__

     return FALSE;
     return FALSE;

-#endif
+#endif // __WXMICROWIN__/!__WXMICROWIN__

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------