use (new) safer GetTraitsIfExists() in wxMutexGuiEnter/Leave() to avoid crashing...

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

diff --git a/src/msw/bitmap.cpp b/src/msw/bitmap.cpp
index 875fe9ff6aa287c040551cd2ff1043c1b741a080..5a46ab36d7b841cda55c77f7ca4c276bd2170207 100644 (file)
--- a/src/msw/bitmap.cpp
+++ b/src/msw/bitmap.cpp
@@ -40,12 +40,13 @@
 #endif
 
 #include "wx/msw/private.h"
 #endif
 
 #include "wx/msw/private.h"

+#include "wx/msw/dc.h"

 
 #if wxUSE_WXDIB
     #include "wx/msw/dib.h"
 #endif
 
 
 #if wxUSE_WXDIB
     #include "wx/msw/dib.h"
 #endif
 

-#ifdef wxHAVE_RAW_BITMAP
+#ifdef wxHAS_RAW_BITMAP

     #include "wx/rawbmp.h"
 #endif
 
     #include "wx/rawbmp.h"
 #endif
 


@@ -211,7 +212,7 @@ wxBitmapRefData::wxBitmapRefData(const wxBitmapRefData& data)
         m_bitmapMask = new wxMask(*data.m_bitmapMask);
 
     // FIXME: we don't copy m_hBitmap currently but we should, see wxBitmap::
         m_bitmapMask = new wxMask(*data.m_bitmapMask);
 
     // FIXME: we don't copy m_hBitmap currently but we should, see wxBitmap::

-    //        CloneRefData()
+    //        CloneGDIRefData()

 
     wxASSERT_MSG( !data.m_isDIB,
                     _T("can't copy bitmap locked for raw access!") );
 
     wxASSERT_MSG( !data.m_isDIB,
                     _T("can't copy bitmap locked for raw access!") );


@@ -250,7 +251,7 @@ wxGDIImageRefData *wxBitmap::CreateData() const
     return new wxBitmapRefData;
 }
 
     return new wxBitmapRefData;
 }
 

-wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *dataOrig) const
+wxGDIRefData *wxBitmap::CloneGDIRefData(const wxGDIRefData *dataOrig) const

 {
     const wxBitmapRefData *
         data = wx_static_cast(const wxBitmapRefData *, dataOrig);
 {
     const wxBitmapRefData *
         data = wx_static_cast(const wxBitmapRefData *, dataOrig);


@@ -277,16 +278,17 @@ wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *dataOrig) const
         self->m_refData = new wxBitmapRefData(*data);
     }
 
         self->m_refData = new wxBitmapRefData(*data);
     }
 

+    wxBitmapRefData * const
+        selfdata = wx_static_cast(wxBitmapRefData *, m_refData);
+

     // copy also the mask
     wxMask * const maskSrc = data->GetMask();
     if ( maskSrc )
     {
     // copy also the mask
     wxMask * const maskSrc = data->GetMask();
     if ( maskSrc )
     {

-        wxBitmapRefData *selfdata = wx_static_cast(wxBitmapRefData *, m_refData);
-

         selfdata->SetMask(new wxMask(*maskSrc));
     }
 
         selfdata->SetMask(new wxMask(*maskSrc));
     }
 

-    return m_refData;
+    return selfdata;

 }
 
 bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& icon,
 }
 
 bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& icon,


@@ -518,14 +520,14 @@ wxBitmap::wxBitmap(int w, int h, const wxDC& dc)
     (void)Create(w, h, dc);
 }
 
     (void)Create(w, h, dc);
 }
 

-wxBitmap::wxBitmap(const void* data, long type, int width, int height, int depth)
+wxBitmap::wxBitmap(const void* data, wxBitmapType type, int width, int height, int depth)

 {
     (void)Create(data, type, width, height, depth);
 }
 
 wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
 {
 {
     (void)Create(data, type, width, height, depth);
 }
 
 wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
 {

-    LoadFile(filename, (int)type);
+    LoadFile(filename, type);

 }
 
 bool wxBitmap::Create(int width, int height, int depth)
 }
 
 bool wxBitmap::Create(int width, int height, int depth)


@@ -535,9 +537,14 @@ bool wxBitmap::Create(int width, int height, int depth)
 
 bool wxBitmap::Create(int width, int height, const wxDC& dc)
 {
 
 bool wxBitmap::Create(int width, int height, const wxDC& dc)
 {

-    wxCHECK_MSG( dc.Ok(), false, _T("invalid HDC in wxBitmap::Create()") );
+    wxCHECK_MSG( dc.IsOk(), false, _T("invalid HDC in wxBitmap::Create()") );

 
 

-    return DoCreate(width, height, -1, dc.GetHDC());
+    const wxMSWDCImpl *impl = wxDynamicCast( dc.GetImpl(), wxMSWDCImpl );
+    
+    if (impl)
+        return DoCreate(width, height, -1, impl->GetHDC());
+    else
+        return false;

 }
 
 bool wxBitmap::DoCreate(int w, int h, int d, WXHDC hdc)
 }
 
 bool wxBitmap::DoCreate(int w, int h, int d, WXHDC hdc)


@@ -805,10 +812,15 @@ bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
 
 bool wxBitmap::CreateFromImage(const wxImage& image, const wxDC& dc)
 {
 
 bool wxBitmap::CreateFromImage(const wxImage& image, const wxDC& dc)
 {

-    wxCHECK_MSG( dc.Ok(), false,
+    wxCHECK_MSG( dc.IsOk(), false,

                     _T("invalid HDC in wxBitmap::CreateFromImage()") );
 
                     _T("invalid HDC in wxBitmap::CreateFromImage()") );
 

-    return CreateFromImage(image, -1, dc.GetHDC());
+    const wxMSWDCImpl *impl = wxDynamicCast( dc.GetImpl(), wxMSWDCImpl );
+    
+    if (impl)
+        return CreateFromImage(image, -1, impl->GetHDC());
+    else
+        return false;

 }
 
 #if wxUSE_WXDIB
 }
 
 #if wxUSE_WXDIB


@@ -1015,7 +1027,7 @@ wxImage wxBitmap::ConvertToImage() const
 // loading and saving bitmaps
 // ----------------------------------------------------------------------------
 
 // loading and saving bitmaps
 // ----------------------------------------------------------------------------
 

-bool wxBitmap::LoadFile(const wxString& filename, long type)
+bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)

 {
     UnRef();
 
 {
     UnRef();
 


@@ -1043,7 +1055,7 @@ bool wxBitmap::LoadFile(const wxString& filename, long type)
     return false;
 }
 
     return false;
 }
 

-bool wxBitmap::Create(const void* data, long type, int width, int height, int depth)
+bool wxBitmap::Create(const void* data, wxBitmapType type, int width, int height, int depth)

 {
     UnRef();
 
 {
     UnRef();
 


@@ -1062,8 +1074,8 @@ bool wxBitmap::Create(const void* data, long type, int width, int height, int de
 }
 
 bool wxBitmap::SaveFile(const wxString& filename,
 }
 
 bool wxBitmap::SaveFile(const wxString& filename,

-                        int type,
-                        const wxPalette *palette)
+                        wxBitmapType type,
+                        const wxPalette *palette) const

 {
     wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
 
 {
     wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
 


@@ -1089,8 +1101,14 @@ bool wxBitmap::SaveFile(const wxString& filename,
 // ----------------------------------------------------------------------------
 // sub bitmap extraction
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // sub bitmap extraction
 // ----------------------------------------------------------------------------

+wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect ) const
+{
+        MemoryHDC dcSrc;
+        SelectInHDC selectSrc(dcSrc, GetHbitmap());
+        return GetSubBitmapOfHDC( rect, (WXHDC)dcSrc );
+}

 
 

-wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
+wxBitmap wxBitmap::GetSubBitmapOfHDC( const wxRect& rect, WXHDC hdc ) const

 {
     wxCHECK_MSG( Ok() &&
                  (rect.x >= 0) && (rect.y >= 0) &&
 {
     wxCHECK_MSG( Ok() &&
                  (rect.x >= 0) && (rect.y >= 0) &&


@@ -1111,16 +1129,15 @@ wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
               dcDst;
 
     {
               dcDst;
 
     {

-        SelectInHDC selectSrc(dcSrc, GetHbitmap()),
-                    selectDst(dcDst, GetHbitmapOf(ret));
-
-        if ( !selectSrc || !selectDst )
+        SelectInHDC selectDst(dcDst, GetHbitmapOf(ret));
+               
+        if ( !selectDst )

         {
         {

-            wxLogLastError(_T("SelectObjct(hBitmap)"));
+            wxLogLastError(_T("SelectObject(destBitmap)"));

         }
 
         if ( !::BitBlt(dcDst, 0, 0, rect.width, rect.height,
         }
 
         if ( !::BitBlt(dcDst, 0, 0, rect.width, rect.height,

-                       dcSrc, rect.x, rect.y, SRCCOPY) )
+                       (HDC)hdc, rect.x, rect.y, SRCCOPY) )

         {
             wxLogLastError(_T("BitBlt"));
         }
         {
             wxLogLastError(_T("BitBlt"));
         }


@@ -1230,7 +1247,8 @@ void wxBitmap::SetMask(wxMask *mask)
 // raw bitmap access support
 // ----------------------------------------------------------------------------
 
 // raw bitmap access support
 // ----------------------------------------------------------------------------
 

-#ifdef wxHAVE_RAW_BITMAP
+#ifdef wxHAS_RAW_BITMAP
+

 void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
 {
 #if wxUSE_WXDIB
 void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
 {
 #if wxUSE_WXDIB


@@ -1336,7 +1354,7 @@ void wxBitmap::UngetRawData(wxPixelDataBase& dataBase)
     }
 #endif // wxUSE_WXDIB
 }
     }
 #endif // wxUSE_WXDIB
 }

-#endif // #ifdef wxHAVE_RAW_BITMAP
+#endif // wxHAS_RAW_BITMAP

 
 // ----------------------------------------------------------------------------
 // wxMask
 
 // ----------------------------------------------------------------------------
 // wxMask


@@ -1546,27 +1564,27 @@ bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
 
 bool wxBitmapHandler::Create(wxGDIImage *image,
                              const void* data,
 
 bool wxBitmapHandler::Create(wxGDIImage *image,
                              const void* data,

-                             long flags,
+                             wxBitmapType type,

                              int width, int height, int depth)
 {
     wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
 
                              int width, int height, int depth)
 {
     wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
 

-    return bitmap && Create(bitmap, data, flags, width, height, depth);
+    return bitmap && Create(bitmap, data, type, width, height, depth);

 }
 
 bool wxBitmapHandler::Load(wxGDIImage *image,
                            const wxString& name,
 }
 
 bool wxBitmapHandler::Load(wxGDIImage *image,
                            const wxString& name,

-                           long flags,
+                           wxBitmapType type,

                            int width, int height)
 {
     wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
 
                            int width, int height)
 {
     wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
 

-    return bitmap && LoadFile(bitmap, name, flags, width, height);
+    return bitmap && LoadFile(bitmap, name, type, width, height);

 }
 
 }
 

-bool wxBitmapHandler::Save(wxGDIImage *image,
+bool wxBitmapHandler::Save(const wxGDIImage *image,

                            const wxString& name,
                            const wxString& name,

-                           int type)
+                           wxBitmapType type) const

 {
     wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
 
 {
     wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
 


@@ -1575,7 +1593,7 @@ bool wxBitmapHandler::Save(wxGDIImage *image,
 
 bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap),
                              const void* WXUNUSED(data),
 
 bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap),
                              const void* WXUNUSED(data),

-                             long WXUNUSED(type),
+                             wxBitmapType WXUNUSED(type),

                              int WXUNUSED(width),
                              int WXUNUSED(height),
                              int WXUNUSED(depth))
                              int WXUNUSED(width),
                              int WXUNUSED(height),
                              int WXUNUSED(depth))


@@ -1585,17 +1603,17 @@ bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap),
 
 bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap),
                                const wxString& WXUNUSED(name),
 
 bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap),
                                const wxString& WXUNUSED(name),

-                               long WXUNUSED(type),
+                               wxBitmapType WXUNUSED(type),

                                int WXUNUSED(desiredWidth),
                                int WXUNUSED(desiredHeight))
 {
     return false;
 }
 
                                int WXUNUSED(desiredWidth),
                                int WXUNUSED(desiredHeight))
 {
     return false;
 }
 

-bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap),
+bool wxBitmapHandler::SaveFile(const wxBitmap *WXUNUSED(bitmap),

                                const wxString& WXUNUSED(name),
                                const wxString& WXUNUSED(name),

-                               int WXUNUSED(type),
-                               const wxPalette *WXUNUSED(palette))
+                               wxBitmapType WXUNUSED(type),
+                               const wxPalette *WXUNUSED(palette)) const

 {
     return false;
 }
 {
     return false;
 }