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

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

diff --git a/src/msw/graphics.cpp b/src/msw/graphics.cpp
index 94716dde7d7410c158dc9f303b36a497d9f13cd4..9d8aac3fbd6973cb017b5bece3cde81698b13496 100644 (file)
--- a/src/msw/graphics.cpp
+++ b/src/msw/graphics.cpp
@@ -23,20 +23,23 @@
     #include "wx/msw/wrapcdlg.h"
     #include "wx/image.h"
     #include "wx/window.h"
     #include "wx/msw/wrapcdlg.h"
     #include "wx/image.h"
     #include "wx/window.h"

-    #include "wx/dc.h"

     #include "wx/utils.h"
     #include "wx/dialog.h"
     #include "wx/app.h"
     #include "wx/bitmap.h"
     #include "wx/utils.h"
     #include "wx/dialog.h"
     #include "wx/app.h"
     #include "wx/bitmap.h"

-    #include "wx/dcmemory.h"

     #include "wx/log.h"
     #include "wx/icon.h"
     #include "wx/log.h"
     #include "wx/icon.h"

-    #include "wx/dcprint.h"

     #include "wx/module.h"
     #include "wx/module.h"

+    // include all dc types that are used as a param
+    #include "wx/dc.h"
+    #include "wx/dcclient.h"
+    #include "wx/dcmemory.h"
+    #include "wx/dcprint.h"

 #endif
 
 #endif
 

-#include "wx/graphics.h"
+#include "wx/private/graphics.h"

 #include "wx/msw/wrapgdip.h"
 #include "wx/msw/wrapgdip.h"

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

 
 #include "wx/stack.h"
 
 
 #include "wx/stack.h"
 


@@ -246,6 +249,20 @@ private :
     GraphicsPath* m_brushPath;
 };
 
     GraphicsPath* m_brushPath;
 };
 

+class WXDLLIMPEXP_CORE wxGDIPlusBitmapData : public wxGraphicsObjectRefData
+{
+public:
+    wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, Bitmap* bitmap );
+    wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, const wxBitmap &bmp );
+    ~wxGDIPlusBitmapData ();
+
+    virtual Bitmap* GetGDIPlusBitmap() { return m_bitmap; }
+
+private :
+    Bitmap* m_bitmap;
+    Bitmap* m_helper;
+};
+

 class wxGDIPlusFontData : public wxGraphicsObjectRefData
 {
 public:
 class wxGDIPlusFontData : public wxGraphicsObjectRefData
 {
 public:


@@ -300,6 +317,7 @@ public:
     // gets the matrix of this context
     virtual wxGraphicsMatrix GetTransform() const;
 
     // gets the matrix of this context
     virtual wxGraphicsMatrix GetTransform() const;
 

+    virtual void DrawBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h );

     virtual void DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
     virtual void DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
     virtual void PushState();
     virtual void DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
     virtual void DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
     virtual void PushState();


@@ -630,6 +648,115 @@ wxGDIPlusFontData::~wxGDIPlusFontData()
     delete m_font;
 }
 
     delete m_font;
 }
 

+// the built-in conversions functions create non-premultiplied bitmaps, while GDIPlus needs them in the
+// premultiplied format, therefore in the failing cases we create a new bitmap using the non-premultiplied
+// bytes as parameter, since there is no real copying of the data going in, only references are stored
+// m_helper has to be kept alive as well
+
+//-----------------------------------------------------------------------------
+// wxGDIPlusBitmapData implementation
+//-----------------------------------------------------------------------------
+
+wxGDIPlusBitmapData::wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, Bitmap* bitmap ) :
+    wxGraphicsObjectRefData( renderer ), m_bitmap( bitmap )
+{
+    m_helper = NULL;
+}
+
+wxGDIPlusBitmapData::wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, 
+                        const wxBitmap &bmp) : wxGraphicsObjectRefData( renderer )
+{
+    m_bitmap = NULL;
+    m_helper = NULL;
+
+    Bitmap* image = NULL;
+    if ( bmp.GetMask() )
+    {
+        Bitmap interim((HBITMAP)bmp.GetHBITMAP(),(HPALETTE)bmp.GetPalette()->GetHPALETTE()) ;
+
+        size_t width = interim.GetWidth();
+        size_t height = interim.GetHeight();
+        Rect bounds(0,0,width,height);
+
+        image = new Bitmap(width,height,PixelFormat32bppPARGB) ;
+
+        Bitmap interimMask((HBITMAP)bmp.GetMask()->GetMaskBitmap(),NULL);
+        wxASSERT(interimMask.GetPixelFormat() == PixelFormat1bppIndexed);
+
+        BitmapData dataMask ;
+        interimMask.LockBits(&bounds,ImageLockModeRead,
+            interimMask.GetPixelFormat(),&dataMask);
+
+
+        BitmapData imageData ;
+        image->LockBits(&bounds,ImageLockModeWrite, PixelFormat32bppPARGB, &imageData);
+
+        BYTE maskPattern = 0 ;
+        BYTE maskByte = 0;
+        size_t maskIndex ;
+
+        for ( size_t y = 0 ; y < height ; ++y)
+        {
+            maskIndex = 0 ;
+            for( size_t x = 0 ; x < width; ++x)
+            {
+                if ( x % 8 == 0)
+                {
+                    maskPattern = 0x80;
+                    maskByte = *((BYTE*)dataMask.Scan0 + dataMask.Stride*y + maskIndex);
+                    maskIndex++;
+                }
+                else
+                    maskPattern = maskPattern >> 1;
+
+                ARGB *dest = (ARGB*)((BYTE*)imageData.Scan0 + imageData.Stride*y + x*4);
+                if ( (maskByte & maskPattern) == 0 )
+                    *dest = 0x00000000;
+                else
+                {
+                    Color c ;
+                    interim.GetPixel(x,y,&c) ;
+                    *dest = (c.GetValue() | Color::AlphaMask);
+                }
+            }
+        }
+
+        image->UnlockBits(&imageData);
+
+        interimMask.UnlockBits(&dataMask);
+        interim.UnlockBits(&dataMask);
+    }
+    else
+    {
+        image = Bitmap::FromHBITMAP((HBITMAP)bmp.GetHBITMAP(),(HPALETTE)bmp.GetPalette()->GetHPALETTE());
+        if ( bmp.HasAlpha() && GetPixelFormatSize(image->GetPixelFormat()) == 32 )
+        {
+            size_t width = image->GetWidth();
+            size_t height = image->GetHeight();
+            Rect bounds(0,0,width,height);
+            static BitmapData data ;
+
+            m_helper = image ;
+            image = NULL ;
+            m_helper->LockBits(&bounds, ImageLockModeRead,
+                m_helper->GetPixelFormat(),&data);
+
+            image = new Bitmap(data.Width, data.Height, data.Stride,
+                PixelFormat32bppPARGB , (BYTE*) data.Scan0);
+
+            m_helper->UnlockBits(&data);
+        }
+    }
+    if ( image )
+        m_bitmap = image;
+}
+
+wxGDIPlusBitmapData::~wxGDIPlusBitmapData()
+{
+    delete m_bitmap;
+    delete m_helper;
+}
+

 //-----------------------------------------------------------------------------
 // wxGDIPlusPath implementation
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxGDIPlusPath implementation
 //-----------------------------------------------------------------------------


@@ -1048,95 +1175,27 @@ void wxGDIPlusContext::PopState()
     m_context->Restore(state);
 }
 
     m_context->Restore(state);
 }
 

-// the built-in conversions functions create non-premultiplied bitmaps, while GDIPlus needs them in the
-// premultiplied format, therefore in the failing cases we create a new bitmap using the non-premultiplied
-// bytes as parameter
-
-void wxGDIPlusContext::DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
+void wxGDIPlusContext::DrawBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h )

 {
 {

-    Bitmap* image = NULL;
-    Bitmap* helper = NULL;
-    if ( bmp.GetMask() )
+    Bitmap* image = static_cast<wxGDIPlusBitmapData*>(bmp.GetRefData())->GetGDIPlusBitmap();
+    if ( image )

     {
     {

-        Bitmap interim((HBITMAP)bmp.GetHBITMAP(),(HPALETTE)bmp.GetPalette()->GetHPALETTE()) ;
-
-        size_t width = interim.GetWidth();
-        size_t height = interim.GetHeight();
-        Rect bounds(0,0,width,height);
-
-        image = new Bitmap(width,height,PixelFormat32bppPARGB) ;
-
-        Bitmap interimMask((HBITMAP)bmp.GetMask()->GetMaskBitmap(),NULL);
-        wxASSERT(interimMask.GetPixelFormat() == PixelFormat1bppIndexed);
-
-        BitmapData dataMask ;
-        interimMask.LockBits(&bounds,ImageLockModeRead,
-            interimMask.GetPixelFormat(),&dataMask);
-
-
-        BitmapData imageData ;
-        image->LockBits(&bounds,ImageLockModeWrite, PixelFormat32bppPARGB, &imageData);
-
-        BYTE maskPattern = 0 ;
-        BYTE maskByte = 0;
-        size_t maskIndex ;
-
-        for ( size_t y = 0 ; y < height ; ++y)
+        if( image->GetWidth() != (UINT) w || image->GetHeight() != (UINT) h )

         {
         {

-            maskIndex = 0 ;
-            for( size_t x = 0 ; x < width; ++x)
-            {
-                if ( x % 8 == 0)
-                {
-                    maskPattern = 0x80;
-                    maskByte = *((BYTE*)dataMask.Scan0 + dataMask.Stride*y + maskIndex);
-                    maskIndex++;
-                }
-                else
-                    maskPattern = maskPattern >> 1;
-
-                ARGB *dest = (ARGB*)((BYTE*)imageData.Scan0 + imageData.Stride*y + x*4);
-                if ( (maskByte & maskPattern) == 0 )
-                    *dest = 0x00000000;
-                else
-                {
-                    Color c ;
-                    interim.GetPixel(x,y,&c) ;
-                    *dest = (c.GetValue() | Color::AlphaMask);
-                }
-            }
+            Rect drawRect((REAL) x, (REAL)y, (REAL)w, (REAL)h);
+            m_context->SetPixelOffsetMode( PixelOffsetModeNone );
+            m_context->DrawImage(image, drawRect, 0 , 0 , image->GetWidth()-1, image->GetHeight()-1, UnitPixel ) ;
+            m_context->SetPixelOffsetMode( PixelOffsetModeHalf );

         }
         }

-
-        image->UnlockBits(&imageData);
-
-        interimMask.UnlockBits(&dataMask);
-        interim.UnlockBits(&dataMask);
+        else
+            m_context->DrawImage(image,(REAL) x,(REAL) y,(REAL) w,(REAL) h) ;

     }
     }

-    else
-    {
-        image = Bitmap::FromHBITMAP((HBITMAP)bmp.GetHBITMAP(),(HPALETTE)bmp.GetPalette()->GetHPALETTE());
-        if ( bmp.HasAlpha() && GetPixelFormatSize(image->GetPixelFormat()) == 32 )
-        {
-            size_t width = image->GetWidth();
-            size_t height = image->GetHeight();
-            Rect bounds(0,0,width,height);
-            BitmapData data ;
-
-            helper = image ;
-            image = NULL ;
-            helper->LockBits(&bounds, ImageLockModeRead,
-                helper->GetPixelFormat(),&data);
-
-            image = new Bitmap(data.Width, data.Height, data.Stride,
-                PixelFormat32bppPARGB , (BYTE*) data.Scan0);
+}

 
 

-            helper->UnlockBits(&data);
-        }
-    }
-    if ( image )
-        m_context->DrawImage(image,(REAL) x,(REAL) y,(REAL) w,(REAL) h) ;
-    delete image ;
-    delete helper ;
+void wxGDIPlusContext::DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
+{
+    wxGraphicsBitmap bitmap = GetRenderer()->CreateBitmap(bmp);
+    DrawBitmap(bitmap, x, y, w, h);

 }
 
 void wxGDIPlusContext::DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
 }
 
 void wxGDIPlusContext::DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h )


@@ -1333,13 +1392,13 @@ class wxGDIPlusRenderer : public wxGraphicsRenderer
 public :
     wxGDIPlusRenderer()
     {
 public :
     wxGDIPlusRenderer()
     {

-        m_loaded = false;
+        m_loaded = -1;

         m_gditoken = 0;
     }
 
     virtual ~wxGDIPlusRenderer()
     {
         m_gditoken = 0;
     }
 
     virtual ~wxGDIPlusRenderer()
     {

-        if (m_loaded)
+        if ( m_loaded == 1 )

         {
             Unload();
         }
         {
             Unload();
         }


@@ -1351,6 +1410,8 @@ public :
 
     virtual wxGraphicsContext * CreateContext( const wxMemoryDC& dc);
 
 
     virtual wxGraphicsContext * CreateContext( const wxMemoryDC& dc);
 

+    virtual wxGraphicsContext * CreateContext( const wxPrinterDC& dc);
+    

     virtual wxGraphicsContext * CreateContextFromNativeContext( void * context );
 
     virtual wxGraphicsContext * CreateContextFromNativeWindow( void * window );
     virtual wxGraphicsContext * CreateContextFromNativeContext( void * context );
 
     virtual wxGraphicsContext * CreateContextFromNativeWindow( void * window );


@@ -1384,14 +1445,21 @@ public :
 
     // sets the font
     virtual wxGraphicsFont CreateFont( const wxFont &font , const wxColour &col = *wxBLACK ) ;
 
     // sets the font
     virtual wxGraphicsFont CreateFont( const wxFont &font , const wxColour &col = *wxBLACK ) ;

+
+    // create a native bitmap representation
+    virtual wxGraphicsBitmap CreateBitmap( const wxBitmap &bitmap );
+    
+    // create a subimage from a native image representation
+    virtual wxGraphicsBitmap CreateSubBitmap( const wxGraphicsBitmap &bitmap, wxDouble x, wxDouble y, wxDouble w, wxDouble h  );
+

 protected :
 protected :

-    void EnsureIsLoaded();
+    bool EnsureIsLoaded();

     void Load();
     void Unload();
     friend class wxGDIPlusRendererModule;
 
 private :
     void Load();
     void Unload();
     friend class wxGDIPlusRendererModule;
 
 private :

-    bool m_loaded;
+    int m_loaded;

     ULONG_PTR m_gditoken;
 
     DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusRenderer)
     ULONG_PTR m_gditoken;
 
     DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusRenderer)


@@ -1410,20 +1478,40 @@ wxGraphicsRenderer* wxGraphicsRenderer::GetDefaultRenderer()
     return &gs_GDIPlusRenderer;
 }
 
     return &gs_GDIPlusRenderer;
 }
 

-void wxGDIPlusRenderer::EnsureIsLoaded()
+bool wxGDIPlusRenderer::EnsureIsLoaded()

 {
 {

-    if (!m_loaded)
+    // load gdiplus.dll if not yet loaded, but don't bother doing it again
+    // if we already tried and failed (we don't want to spend lot of time
+    // returning NULL from wxGraphicsContext::Create(), which may be called
+    // relatively frequently):
+    if ( m_loaded == -1 )

     {
         Load();
     }
     {
         Load();
     }

+
+    return m_loaded == 1;

 }
 
 }
 

+// call EnsureIsLoaded() and return returnOnFail value if it fails
+#define ENSURE_LOADED_OR_RETURN(returnOnFail)  \
+    if ( !EnsureIsLoaded() )                   \
+        return (returnOnFail)
+
+

 void wxGDIPlusRenderer::Load()
 {
     GdiplusStartupInput input;
     GdiplusStartupOutput output;
 void wxGDIPlusRenderer::Load()
 {
     GdiplusStartupInput input;
     GdiplusStartupOutput output;

-    GdiplusStartup(&m_gditoken,&input,&output);
-    m_loaded = true;
+    if ( GdiplusStartup(&m_gditoken,&input,&output) == Gdiplus::Ok )
+    {
+        wxLogTrace("gdiplus", "successfully initialized GDI+");
+        m_loaded = 1;
+    }
+    else
+    {
+        wxLogTrace("gdiplus", "failed to initialize GDI+, missing gdiplus.dll?");
+        m_loaded = 0;
+    }

 }
 
 void wxGDIPlusRenderer::Unload()
 }
 
 void wxGDIPlusRenderer::Unload()


@@ -1433,45 +1521,52 @@ void wxGDIPlusRenderer::Unload()
         GdiplusShutdown(m_gditoken);
         m_gditoken = NULL;
     }
         GdiplusShutdown(m_gditoken);
         m_gditoken = NULL;
     }

-    m_loaded = false;
+    m_loaded = -1; // next Load() will try again

 }
 
 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxWindowDC& dc)
 {
 }
 
 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxWindowDC& dc)
 {

-    EnsureIsLoaded();
+    ENSURE_LOADED_OR_RETURN(NULL);
+    wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl );
+    return new wxGDIPlusContext(this,(HDC) msw->GetHDC());
+}
+
+wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxPrinterDC& dc)
+{
+    ENSURE_LOADED_OR_RETURN(NULL);

     wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl );
     return new wxGDIPlusContext(this,(HDC) msw->GetHDC());
 }
 
 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxMemoryDC& dc)
 {
     wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl );
     return new wxGDIPlusContext(this,(HDC) msw->GetHDC());
 }
 
 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxMemoryDC& dc)
 {

-    EnsureIsLoaded();
+    ENSURE_LOADED_OR_RETURN(NULL);

     wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl );
     return new wxGDIPlusContext(this,(HDC) msw->GetHDC());
 }
 
 wxGraphicsContext * wxGDIPlusRenderer::CreateMeasuringContext()
 {
     wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl );
     return new wxGDIPlusContext(this,(HDC) msw->GetHDC());
 }
 
 wxGraphicsContext * wxGDIPlusRenderer::CreateMeasuringContext()
 {

-    EnsureIsLoaded();
+    ENSURE_LOADED_OR_RETURN(NULL);

     return new wxGDIPlusMeasuringContext(this);
 }
 
 wxGraphicsContext * wxGDIPlusRenderer::CreateContextFromNativeContext( void * context )
 {
     return new wxGDIPlusMeasuringContext(this);
 }
 
 wxGraphicsContext * wxGDIPlusRenderer::CreateContextFromNativeContext( void * context )
 {

-    EnsureIsLoaded();
+    ENSURE_LOADED_OR_RETURN(NULL);

     return new wxGDIPlusContext(this,(Graphics*) context);
 }
 
 
 wxGraphicsContext * wxGDIPlusRenderer::CreateContextFromNativeWindow( void * window )
 {
     return new wxGDIPlusContext(this,(Graphics*) context);
 }
 
 
 wxGraphicsContext * wxGDIPlusRenderer::CreateContextFromNativeWindow( void * window )
 {

-    EnsureIsLoaded();
+    ENSURE_LOADED_OR_RETURN(NULL);

     return new wxGDIPlusContext(this,(HWND) window);
 }
 
 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( wxWindow* window )
 {
     return new wxGDIPlusContext(this,(HWND) window);
 }
 
 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( wxWindow* window )
 {

-    EnsureIsLoaded();
+    ENSURE_LOADED_OR_RETURN(NULL);

     return new wxGDIPlusContext(this, (HWND) window->GetHWND() );
 }
 
     return new wxGDIPlusContext(this, (HWND) window->GetHWND() );
 }
 


@@ -1479,7 +1574,7 @@ wxGraphicsContext * wxGDIPlusRenderer::CreateContext( wxWindow* window )
 
 wxGraphicsPath wxGDIPlusRenderer::CreatePath()
 {
 
 wxGraphicsPath wxGDIPlusRenderer::CreatePath()
 {

-    EnsureIsLoaded();
+    ENSURE_LOADED_OR_RETURN(wxNullGraphicsPath);

     wxGraphicsPath m;
     m.SetRefData( new wxGDIPlusPathData(this));
     return m;
     wxGraphicsPath m;
     m.SetRefData( new wxGDIPlusPathData(this));
     return m;


@@ -1492,7 +1587,7 @@ wxGraphicsMatrix wxGDIPlusRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDoub
                                                            wxDouble tx, wxDouble ty)
 
 {
                                                            wxDouble tx, wxDouble ty)
 
 {

-    EnsureIsLoaded();
+    ENSURE_LOADED_OR_RETURN(wxNullGraphicsMatrix);

     wxGraphicsMatrix m;
     wxGDIPlusMatrixData* data = new wxGDIPlusMatrixData( this );
     data->Set( a,b,c,d,tx,ty ) ;
     wxGraphicsMatrix m;
     wxGDIPlusMatrixData* data = new wxGDIPlusMatrixData( this );
     data->Set( a,b,c,d,tx,ty ) ;


@@ -1502,7 +1597,7 @@ wxGraphicsMatrix wxGDIPlusRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDoub
 
 wxGraphicsPen wxGDIPlusRenderer::CreatePen(const wxPen& pen)
 {
 
 wxGraphicsPen wxGDIPlusRenderer::CreatePen(const wxPen& pen)
 {

-    EnsureIsLoaded();
+    ENSURE_LOADED_OR_RETURN(wxNullGraphicsPen);

     if ( !pen.Ok() || pen.GetStyle() == wxTRANSPARENT )
         return wxNullGraphicsPen;
     else
     if ( !pen.Ok() || pen.GetStyle() == wxTRANSPARENT )
         return wxNullGraphicsPen;
     else


@@ -1515,7 +1610,7 @@ wxGraphicsPen wxGDIPlusRenderer::CreatePen(const wxPen& pen)
 
 wxGraphicsBrush wxGDIPlusRenderer::CreateBrush(const wxBrush& brush )
 {
 
 wxGraphicsBrush wxGDIPlusRenderer::CreateBrush(const wxBrush& brush )
 {

-    EnsureIsLoaded();
+    ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush);

     if ( !brush.Ok() || brush.GetStyle() == wxTRANSPARENT )
         return wxNullGraphicsBrush;
     else
     if ( !brush.Ok() || brush.GetStyle() == wxTRANSPARENT )
         return wxNullGraphicsBrush;
     else


@@ -1530,7 +1625,7 @@ wxGraphicsBrush wxGDIPlusRenderer::CreateBrush(const wxBrush& brush )
 wxGraphicsBrush wxGDIPlusRenderer::CreateLinearGradientBrush( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2,
                                                                       const wxColour&c1, const wxColour&c2)
 {
 wxGraphicsBrush wxGDIPlusRenderer::CreateLinearGradientBrush( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2,
                                                                       const wxColour&c1, const wxColour&c2)
 {

-    EnsureIsLoaded();
+    ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush);

     wxGraphicsBrush p;
     wxGDIPlusBrushData* d = new wxGDIPlusBrushData( this );
     d->CreateLinearGradientBrush(x1, y1, x2, y2, c1, c2);
     wxGraphicsBrush p;
     wxGDIPlusBrushData* d = new wxGDIPlusBrushData( this );
     d->CreateLinearGradientBrush(x1, y1, x2, y2, c1, c2);


@@ -1543,7 +1638,7 @@ wxGraphicsBrush wxGDIPlusRenderer::CreateLinearGradientBrush( wxDouble x1, wxDou
 wxGraphicsBrush wxGDIPlusRenderer::CreateRadialGradientBrush( wxDouble xo, wxDouble yo, wxDouble xc, wxDouble yc, wxDouble radius,
                                                                       const wxColour &oColor, const wxColour &cColor)
 {
 wxGraphicsBrush wxGDIPlusRenderer::CreateRadialGradientBrush( wxDouble xo, wxDouble yo, wxDouble xc, wxDouble yc, wxDouble radius,
                                                                       const wxColour &oColor, const wxColour &cColor)
 {

-    EnsureIsLoaded();
+    ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush);

     wxGraphicsBrush p;
     wxGDIPlusBrushData* d = new wxGDIPlusBrushData( this );
     d->CreateRadialGradientBrush(xo,yo,xc,yc,radius,oColor,cColor);
     wxGraphicsBrush p;
     wxGDIPlusBrushData* d = new wxGDIPlusBrushData( this );
     d->CreateRadialGradientBrush(xo,yo,xc,yc,radius,oColor,cColor);


@@ -1554,7 +1649,7 @@ wxGraphicsBrush wxGDIPlusRenderer::CreateRadialGradientBrush( wxDouble xo, wxDou
 // sets the font
 wxGraphicsFont wxGDIPlusRenderer::CreateFont( const wxFont &font , const wxColour &col )
 {
 // sets the font
 wxGraphicsFont wxGDIPlusRenderer::CreateFont( const wxFont &font , const wxColour &col )
 {

-    EnsureIsLoaded();
+    ENSURE_LOADED_OR_RETURN(wxNullGraphicsFont);

     if ( font.Ok() )
     {
         wxGraphicsFont p;
     if ( font.Ok() )
     {
         wxGraphicsFont p;


@@ -1565,6 +1660,33 @@ wxGraphicsFont wxGDIPlusRenderer::CreateFont( const wxFont &font , const wxColou
         return wxNullGraphicsFont;
 }
 
         return wxNullGraphicsFont;
 }
 

+wxGraphicsBitmap wxGDIPlusRenderer::CreateBitmap( const wxBitmap &bitmap )
+{
+    ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap);
+    if ( bitmap.Ok() )
+    {
+        wxGraphicsBitmap p;
+        p.SetRefData(new wxGDIPlusBitmapData( this , bitmap ));
+        return p;
+    }
+    else
+        return wxNullGraphicsBitmap;
+}
+
+wxGraphicsBitmap wxGDIPlusRenderer::CreateSubBitmap( const wxGraphicsBitmap &bitmap, wxDouble x, wxDouble y, wxDouble w, wxDouble h  )
+{
+    ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap);
+    Bitmap* image = static_cast<wxGDIPlusBitmapData*>(bitmap.GetRefData())->GetGDIPlusBitmap();
+    if ( image )
+    {
+        wxGraphicsBitmap p;
+        p.SetRefData(new wxGDIPlusBitmapData( this , image->Clone( (REAL) x , (REAL) y , (REAL) w , (REAL) h , PixelFormat32bppPARGB) ));
+        return p;
+    }
+    else
+        return wxNullGraphicsBitmap;
+}
+

 // Shutdown GDI+ at app exit, before possible dll unload
 class wxGDIPlusRendererModule : public wxModule
 {
 // Shutdown GDI+ at app exit, before possible dll unload
 class wxGDIPlusRendererModule : public wxModule
 {