Quote wxExecute() arguments in wxDebugReportUpload when using curl.

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

diff --git a/src/msw/graphics.cpp b/src/msw/graphics.cpp
index 423947ee239c7a7a8aab35f8312bab08b9a661d9..98134fb42fdf68b6a518c0bb07c75185bd83d86e 100644 (file)
--- a/src/msw/graphics.cpp
+++ b/src/msw/graphics.cpp
@@ -78,6 +78,39 @@ inline Color wxColourToColor(const wxColour& col)
     return Color(col.Alpha(), col.Red(), col.Green(), col.Blue());
 }
 
     return Color(col.Alpha(), col.Red(), col.Green(), col.Blue());
 }
 

+// Do not use this pointer directly, it's only used by
+// GetDrawTextStringFormat() and the cleanup code in wxGDIPlusRendererModule.
+StringFormat* gs_drawTextStringFormat = NULL;
+
+// Get the string format used for the text drawing and measuring functions:
+// notice that it must be the same one for all of them, otherwise the drawn
+// text might be of different size than what measuring it returned.
+inline StringFormat* GetDrawTextStringFormat()
+{
+    if ( !gs_drawTextStringFormat )
+    {
+        // We create this string format with exactly the same flags as
+        // StringFormat::GenericTypographic() is documented to use in MSDN
+        // except for the last one which doesn't make any difference for
+        // DrawText() but that we do want to use when measuring text.
+        //
+        // The reason for not just using GenericTypographic itself is that it
+        // does something else (what exactly is unfortunately not documented),
+        // which results in string being displayed quite differently from the
+        // default rendering, see #14537.
+        gs_drawTextStringFormat
+            = new StringFormat
+                  (
+                    StringFormatFlagsLineLimit |
+                    StringFormatFlagsNoClip |
+                    StringFormatFlagsNoFitBlackBox |
+                    StringFormatFlagsMeasureTrailingSpaces
+                  );
+    }
+
+    return gs_drawTextStringFormat;
+}
+

 } // anonymous namespace
 
 //-----------------------------------------------------------------------------
 } // anonymous namespace
 
 //-----------------------------------------------------------------------------


@@ -272,7 +305,7 @@ private:
     GraphicsPath* m_brushPath;
 };
 
     GraphicsPath* m_brushPath;
 };
 

-class WXDLLIMPEXP_CORE wxGDIPlusBitmapData : public wxGraphicsObjectRefData
+class WXDLLIMPEXP_CORE wxGDIPlusBitmapData : public wxGraphicsBitmapData

 {
 public:
     wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, Bitmap* bitmap );
 {
 public:
     wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, Bitmap* bitmap );


@@ -280,6 +313,11 @@ public:
     ~wxGDIPlusBitmapData ();
 
     virtual Bitmap* GetGDIPlusBitmap() { return m_bitmap; }
     ~wxGDIPlusBitmapData ();
 
     virtual Bitmap* GetGDIPlusBitmap() { return m_bitmap; }

+    virtual void* GetNativeBitmap() const { return m_bitmap; }
+
+#if wxUSE_IMAGE
+    wxImage ConvertToImage() const;
+#endif // wxUSE_IMAGE

 
 private :
     Bitmap* m_bitmap;
 
 private :
     Bitmap* m_bitmap;


@@ -290,14 +328,27 @@ class wxGDIPlusFontData : public wxGraphicsObjectRefData
 {
 public:
     wxGDIPlusFontData( wxGraphicsRenderer* renderer,
 {
 public:
     wxGDIPlusFontData( wxGraphicsRenderer* renderer,

-                       const wxGDIPlusContext* gc,

                        const wxFont &font,
                        const wxColour& col );
                        const wxFont &font,
                        const wxColour& col );

+    wxGDIPlusFontData(wxGraphicsRenderer* renderer,
+                      const wxString& name,
+                      REAL sizeInPixels,
+                      int style,
+                      const wxColour& col);

     ~wxGDIPlusFontData();
 
     virtual Brush* GetGDIPlusBrush() { return m_textBrush; }
     virtual Font* GetGDIPlusFont() { return m_font; }
     ~wxGDIPlusFontData();
 
     virtual Brush* GetGDIPlusBrush() { return m_textBrush; }
     virtual Font* GetGDIPlusFont() { return m_font; }

+

 private :
 private :

+    // Common part of all ctors, flags here is a combination of values of
+    // FontStyle GDI+ enum.
+    void Init(const wxString& name,
+              REAL size,
+              int style,
+              const wxColour& col,
+              Unit fontUnit);
+

     Brush* m_textBrush;
     Font* m_font;
 };
     Brush* m_textBrush;
     Font* m_font;
 };


@@ -309,7 +360,7 @@ public:
     wxGDIPlusContext( wxGraphicsRenderer* renderer, HDC hdc, wxDouble width, wxDouble height );
     wxGDIPlusContext( wxGraphicsRenderer* renderer, HWND hwnd );
     wxGDIPlusContext( wxGraphicsRenderer* renderer, Graphics* gr);
     wxGDIPlusContext( wxGraphicsRenderer* renderer, HDC hdc, wxDouble width, wxDouble height );
     wxGDIPlusContext( wxGraphicsRenderer* renderer, HWND hwnd );
     wxGDIPlusContext( wxGraphicsRenderer* renderer, Graphics* gr);

-    wxGDIPlusContext();
+    wxGDIPlusContext(wxGraphicsRenderer* renderer);

 
     virtual ~wxGDIPlusContext();
 
 
     virtual ~wxGDIPlusContext();
 


@@ -325,14 +376,25 @@ public:
     virtual void StrokePath( const wxGraphicsPath& p );
     virtual void FillPath( const wxGraphicsPath& p , wxPolygonFillMode fillStyle = wxODDEVEN_RULE );
 
     virtual void StrokePath( const wxGraphicsPath& p );
     virtual void FillPath( const wxGraphicsPath& p , wxPolygonFillMode fillStyle = wxODDEVEN_RULE );
 

+    virtual void DrawRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h ); 
+

     // stroke lines connecting each of the points
     virtual void StrokeLines( size_t n, const wxPoint2DDouble *points);
 
     // stroke lines connecting each of the points
     virtual void StrokeLines( size_t n, const wxPoint2DDouble *points);
 

+    // We don't have any specific implementation for this one in wxMSW but
+    // override it just to avoid warnings about hiding the base class virtual.
+    virtual void StrokeLines( size_t n, const wxPoint2DDouble *beginPoints, const wxPoint2DDouble *endPoints)
+    {
+        wxGraphicsContext::StrokeLines(n, beginPoints, endPoints);
+    }
+

     // draws a polygon
     virtual void DrawLines( size_t n, const wxPoint2DDouble *points, wxPolygonFillMode fillStyle = wxODDEVEN_RULE );
 
     virtual bool SetAntialiasMode(wxAntialiasMode antialias);
 
     // draws a polygon
     virtual void DrawLines( size_t n, const wxPoint2DDouble *points, wxPolygonFillMode fillStyle = wxODDEVEN_RULE );
 
     virtual bool SetAntialiasMode(wxAntialiasMode antialias);
 

+    virtual bool SetInterpolationQuality(wxInterpolationQuality interpolation);
+    

     virtual bool SetCompositionMode(wxCompositionMode op);
 
     virtual void BeginLayer(wxDouble opacity);
     virtual bool SetCompositionMode(wxCompositionMode op);
 
     virtual void BeginLayer(wxDouble opacity);


@@ -358,9 +420,6 @@ public:
     virtual void PushState();
     virtual void PopState();
 
     virtual void PushState();
     virtual void PopState();
 

-    // sets the font of this context
-    virtual wxGraphicsFont CreateFont( const wxFont &font , const wxColour &col = *wxBLACK ) const;
-

     virtual void GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height,
         wxDouble *descent, wxDouble *externalLeading ) const;
     virtual void GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const;
     virtual void GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height,
         wxDouble *descent, wxDouble *externalLeading ) const;
     virtual void GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const;


@@ -373,30 +432,57 @@ protected:
 
     wxDouble m_fontScaleRatio;
 
 
     wxDouble m_fontScaleRatio;
 

-private:
-    void    Init();
-    void    SetDefaults();
+    // Used from ctors (including those in the derived classes) and takes
+    // ownership of the graphics pointer that must be non-NULL.
+    void Init(Graphics* graphics, int width, int height);

 
 

-    virtual void DoDrawText(const wxString& str, wxDouble x, wxDouble y)
-        { DoDrawFilledText(str, x, y, wxNullGraphicsBrush); }
-    virtual void DoDrawFilledText(const wxString& str, wxDouble x, wxDouble y,
-                                  const wxGraphicsBrush& backgroundBrush);
+private:
+    virtual void DoDrawText(const wxString& str, wxDouble x, wxDouble y);

 
     Graphics* m_context;
     wxStack<GraphicsState> m_stateStack;
     GraphicsState m_state1;
     GraphicsState m_state2;
 
 
     Graphics* m_context;
     wxStack<GraphicsState> m_stateStack;
     GraphicsState m_state1;
     GraphicsState m_state2;
 

-    DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusContext)
+    wxDECLARE_NO_COPY_CLASS(wxGDIPlusContext);

 };
 
 };
 

-class wxGDIPlusMeasuringContext : public wxGDIPlusContext
+#if wxUSE_IMAGE
+
+class wxGDIPlusImageContext : public wxGDIPlusContext

 {
 public:
 {
 public:

-    wxGDIPlusMeasuringContext( wxGraphicsRenderer* renderer ) : wxGDIPlusContext( renderer , m_hdc = GetDC(NULL), 1000, 1000 )
+    wxGDIPlusImageContext(wxGraphicsRenderer* renderer, wxImage& image) :
+        wxGDIPlusContext(renderer),
+        m_image(image),
+        m_bitmap(renderer, image)
+    {
+        Init
+        (
+            new Graphics(m_bitmap.GetGDIPlusBitmap()),
+            image.GetWidth(),
+            image.GetHeight()
+        );
+    }
+
+    virtual ~wxGDIPlusImageContext()

     {
     {

+        m_image = m_bitmap.ConvertToImage();

     }
     }

-    wxGDIPlusMeasuringContext()
+
+private:
+    wxImage& m_image;
+    wxGDIPlusBitmapData m_bitmap;
+
+    wxDECLARE_NO_COPY_CLASS(wxGDIPlusImageContext);
+};
+
+#endif // wxUSE_IMAGE
+
+class wxGDIPlusMeasuringContext : public wxGDIPlusContext
+{
+public:
+    wxGDIPlusMeasuringContext( wxGraphicsRenderer* renderer ) : wxGDIPlusContext( renderer , m_hdc = GetDC(NULL), 1000, 1000 )

     {
     }
 
     {
     }
 


@@ -407,7 +493,6 @@ public:
 
 private:
     HDC m_hdc ;
 
 private:
     HDC m_hdc ;

-    DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusMeasuringContext)

 } ;
 
 class wxGDIPlusPrintingContext : public wxGDIPlusContext
 } ;
 
 class wxGDIPlusPrintingContext : public wxGDIPlusContext


@@ -459,6 +544,10 @@ public :
 
     virtual wxGraphicsContext * CreateContext( wxWindow* window );
 
 
     virtual wxGraphicsContext * CreateContext( wxWindow* window );
 

+#if wxUSE_IMAGE
+    virtual wxGraphicsContext * CreateContextFromImage(wxImage& image);
+#endif // wxUSE_IMAGE
+

     virtual wxGraphicsContext * CreateMeasuringContext();
 
     // Path
     virtual wxGraphicsContext * CreateMeasuringContext();
 
     // Path


@@ -488,16 +577,18 @@ public :
 
     // create a native bitmap representation
     virtual wxGraphicsBitmap CreateBitmap( const wxBitmap &bitmap );
 
     // create a native bitmap representation
     virtual wxGraphicsBitmap CreateBitmap( const wxBitmap &bitmap );

+#if wxUSE_IMAGE
+    virtual wxGraphicsBitmap CreateBitmapFromImage(const wxImage& image);
+    virtual wxImage CreateImageFromBitmap(const wxGraphicsBitmap& bmp);
+#endif // wxUSE_IMAGE

 
 

-    // stub: should not be called directly
-    virtual wxGraphicsFont CreateFont( const wxFont& WXUNUSED(font),
-                                       const wxColour& WXUNUSED(col) )
-        { wxFAIL; return wxNullGraphicsFont; }
+    virtual wxGraphicsFont CreateFont( const wxFont& font,
+                                       const wxColour& col);

 
 

-    // this is used to really create the font
-    wxGraphicsFont CreateGDIPlusFont( const wxGDIPlusContext* gc,
-                                      const wxFont &font,
-                                      const wxColour &col );
+    virtual wxGraphicsFont CreateFont(double size,
+                                      const wxString& facename,
+                                      int flags = wxFONTFLAG_DEFAULT,
+                                      const wxColour& col = *wxBLACK);

 
     // create a graphics bitmap from a native bitmap
     virtual wxGraphicsBitmap CreateBitmapFromNativeBitmap( void* bitmap );
 
     // create a graphics bitmap from a native bitmap
     virtual wxGraphicsBitmap CreateBitmapFromNativeBitmap( void* bitmap );


@@ -594,25 +685,25 @@ wxGDIPlusPenData::wxGDIPlusPenData( wxGraphicsRenderer* renderer, const wxPen &p
     DashStyle dashStyle = DashStyleSolid;
     switch ( pen.GetStyle() )
     {
     DashStyle dashStyle = DashStyleSolid;
     switch ( pen.GetStyle() )
     {

-    case wxSOLID :
+    case wxPENSTYLE_SOLID :

         break;
 
         break;
 

-    case wxDOT :
+    case wxPENSTYLE_DOT :

         dashStyle = DashStyleDot;
         break;
 
         dashStyle = DashStyleDot;
         break;
 

-    case wxLONG_DASH :
+    case wxPENSTYLE_LONG_DASH :

         dashStyle = DashStyleDash; // TODO verify
         break;
 
         dashStyle = DashStyleDash; // TODO verify
         break;
 

-    case wxSHORT_DASH :
+    case wxPENSTYLE_SHORT_DASH :

         dashStyle = DashStyleDash;
         break;
 
         dashStyle = DashStyleDash;
         break;
 

-    case wxDOT_DASH :
+    case wxPENSTYLE_DOT_DASH :

         dashStyle = DashStyleDashDot;
         break;
         dashStyle = DashStyleDashDot;
         break;

-    case wxUSER_DASH :
+    case wxPENSTYLE_USER_DASH :

         {
             dashStyle = DashStyleCustom;
             wxDash *dashes;
         {
             dashStyle = DashStyleCustom;
             wxDash *dashes;


@@ -629,10 +720,10 @@ wxGDIPlusPenData::wxGDIPlusPenData( wxGraphicsRenderer* renderer, const wxPen &p
             }
         }
         break;
             }
         }
         break;

-    case wxSTIPPLE :
+    case wxPENSTYLE_STIPPLE :

         {
             wxBitmap* bmp = pen.GetStipple();
         {
             wxBitmap* bmp = pen.GetStipple();

-            if ( bmp && bmp->Ok() )
+            if ( bmp && bmp->IsOk() )

             {
                 m_penImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),
 #if wxUSE_PALETTE
             {
                 m_penImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),
 #if wxUSE_PALETTE


@@ -648,30 +739,32 @@ wxGDIPlusPenData::wxGDIPlusPenData( wxGraphicsRenderer* renderer, const wxPen &p
         }
         break;
     default :
         }
         break;
     default :

-        if ( pen.GetStyle() >= wxFIRST_HATCH && pen.GetStyle() <= wxLAST_HATCH )
+        if ( pen.GetStyle() >= wxPENSTYLE_FIRST_HATCH &&
+             pen.GetStyle() <= wxPENSTYLE_LAST_HATCH )

         {
         {

-            HatchStyle style = HatchStyleHorizontal;
+            HatchStyle style;

             switch( pen.GetStyle() )
             {
             switch( pen.GetStyle() )
             {

-            case wxBDIAGONAL_HATCH :
+            case wxPENSTYLE_BDIAGONAL_HATCH :

                 style = HatchStyleBackwardDiagonal;
                 break ;
                 style = HatchStyleBackwardDiagonal;
                 break ;

-            case wxCROSSDIAG_HATCH :
+            case wxPENSTYLE_CROSSDIAG_HATCH :

                 style = HatchStyleDiagonalCross;
                 break ;
                 style = HatchStyleDiagonalCross;
                 break ;

-            case wxFDIAGONAL_HATCH :
+            case wxPENSTYLE_FDIAGONAL_HATCH :

                 style = HatchStyleForwardDiagonal;
                 break ;
                 style = HatchStyleForwardDiagonal;
                 break ;

-            case wxCROSS_HATCH :
+            case wxPENSTYLE_CROSS_HATCH :

                 style = HatchStyleCross;
                 break ;
                 style = HatchStyleCross;
                 break ;

-            case wxHORIZONTAL_HATCH :
+            case wxPENSTYLE_HORIZONTAL_HATCH :

                 style = HatchStyleHorizontal;
                 break ;
                 style = HatchStyleHorizontal;
                 break ;

-            case wxVERTICAL_HATCH :
+            case wxPENSTYLE_VERTICAL_HATCH :

                 style = HatchStyleVertical;
                 break ;
                 style = HatchStyleVertical;
                 break ;

-
+            default:
+                style = HatchStyleHorizontal;

             }
             m_penBrush = new HatchBrush
                              (
             }
             m_penBrush = new HatchBrush
                              (


@@ -707,28 +800,29 @@ wxGDIPlusBrushData::wxGDIPlusBrushData( wxGraphicsRenderer* renderer , const wxB
     }
     else if ( brush.IsHatch() )
     {
     }
     else if ( brush.IsHatch() )
     {

-        HatchStyle style = HatchStyleHorizontal;
+        HatchStyle style;

         switch( brush.GetStyle() )
         {
         switch( brush.GetStyle() )
         {

-        case wxBDIAGONAL_HATCH :
+        case wxBRUSHSTYLE_BDIAGONAL_HATCH :

             style = HatchStyleBackwardDiagonal;
             break ;
             style = HatchStyleBackwardDiagonal;
             break ;

-        case wxCROSSDIAG_HATCH :
+        case wxBRUSHSTYLE_CROSSDIAG_HATCH :

             style = HatchStyleDiagonalCross;
             break ;
             style = HatchStyleDiagonalCross;
             break ;

-        case wxFDIAGONAL_HATCH :
+        case wxBRUSHSTYLE_FDIAGONAL_HATCH :

             style = HatchStyleForwardDiagonal;
             break ;
             style = HatchStyleForwardDiagonal;
             break ;

-        case wxCROSS_HATCH :
+        case wxBRUSHSTYLE_CROSS_HATCH :

             style = HatchStyleCross;
             break ;
             style = HatchStyleCross;
             break ;

-        case wxHORIZONTAL_HATCH :
+        case wxBRUSHSTYLE_HORIZONTAL_HATCH :

             style = HatchStyleHorizontal;
             break ;
             style = HatchStyleHorizontal;
             break ;

-        case wxVERTICAL_HATCH :
+        case wxBRUSHSTYLE_VERTICAL_HATCH :

             style = HatchStyleVertical;
             break ;
             style = HatchStyleVertical;
             break ;

-
+        default:
+            style = HatchStyleHorizontal;

         }
         m_brush = new HatchBrush
                       (
         }
         m_brush = new HatchBrush
                       (


@@ -740,7 +834,7 @@ wxGDIPlusBrushData::wxGDIPlusBrushData( wxGraphicsRenderer* renderer , const wxB
     else
     {
         wxBitmap* bmp = brush.GetStipple();
     else
     {
         wxBitmap* bmp = brush.GetStipple();

-        if ( bmp && bmp->Ok() )
+        if ( bmp && bmp->IsOk() )

         {
             wxDELETE( m_brushImage );
             m_brushImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),
         {
             wxDELETE( m_brushImage );
             m_brushImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),


@@ -836,13 +930,23 @@ wxGDIPlusBrushData::CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
 // wxGDIPlusFont implementation
 //-----------------------------------------------------------------------------
 
 // wxGDIPlusFont implementation
 //-----------------------------------------------------------------------------
 

+void
+wxGDIPlusFontData::Init(const wxString& name,
+                        REAL size,
+                        int style,
+                        const wxColour& col,
+                        Unit fontUnit)
+{
+    m_font = new Font(name.wc_str(), size, style, fontUnit);
+
+    m_textBrush = new SolidBrush(wxColourToColor(col));
+}
+

 wxGDIPlusFontData::wxGDIPlusFontData( wxGraphicsRenderer* renderer,
 wxGDIPlusFontData::wxGDIPlusFontData( wxGraphicsRenderer* renderer,

-                                      const wxGDIPlusContext* gc,

                                       const wxFont &font,
                                       const wxColour& col )
     : wxGraphicsObjectRefData( renderer )
 {
                                       const wxFont &font,
                                       const wxColour& col )
     : wxGraphicsObjectRefData( renderer )
 {

-    wxWCharBuffer s = font.GetFaceName().wc_str( *wxConvUI );

     int style = FontStyleRegular;
     if ( font.GetStyle() == wxFONTSTYLE_ITALIC )
         style |= FontStyleItalic;
     int style = FontStyleRegular;
     if ( font.GetStyle() == wxFONTSTYLE_ITALIC )
         style |= FontStyleItalic;


@@ -851,25 +955,17 @@ wxGDIPlusFontData::wxGDIPlusFontData( wxGraphicsRenderer* renderer,
     if ( font.GetWeight() == wxFONTWEIGHT_BOLD )
         style |= FontStyleBold;
 
     if ( font.GetWeight() == wxFONTWEIGHT_BOLD )
         style |= FontStyleBold;
 

-    Graphics* context = gc->GetGraphics();
-
-    Unit fontUnit = context->GetPageUnit();
-    // if fontUnit is UnitDisplay, then specify UnitPixel, otherwise
-    // you'll get a "InvalidParameter" from GDI+
-    if ( fontUnit == UnitDisplay )
-        fontUnit = UnitPixel;
-
-    REAL points = font.GetPointSize();
-
-    // This scaling is needed when we use unit other than the
-    // default UnitPoint. It works for both display and printing.
-    REAL size = points * (100.0 / 72.0);
-
-    // NB: font unit should match context's unit. We can use UnitPixel,
-    //     as that is what the print context should use.
-    m_font = new Font( s, size, style, fontUnit );
+    Init(font.GetFaceName(), font.GetPointSize(), style, col, UnitPoint);
+}

 
 

-    m_textBrush = new SolidBrush(wxColourToColor(col));
+wxGDIPlusFontData::wxGDIPlusFontData(wxGraphicsRenderer* renderer,
+                                     const wxString& name,
+                                     REAL sizeInPixels,
+                                     int style,
+                                     const wxColour& col) :
+    wxGraphicsObjectRefData(renderer)
+{
+    Init(name, sizeInPixels, style, col, UnitPixel);

 }
 
 wxGDIPlusFontData::~wxGDIPlusFontData()
 }
 
 wxGDIPlusFontData::~wxGDIPlusFontData()


@@ -888,13 +984,13 @@ wxGDIPlusFontData::~wxGDIPlusFontData()
 //-----------------------------------------------------------------------------
 
 wxGDIPlusBitmapData::wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, Bitmap* bitmap ) :
 //-----------------------------------------------------------------------------
 
 wxGDIPlusBitmapData::wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, Bitmap* bitmap ) :

-    wxGraphicsObjectRefData( renderer ), m_bitmap( bitmap )
+    wxGraphicsBitmapData( renderer ), m_bitmap( bitmap )

 {
     m_helper = NULL;
 }
 
 wxGDIPlusBitmapData::wxGDIPlusBitmapData( wxGraphicsRenderer* renderer,
 {
     m_helper = NULL;
 }
 
 wxGDIPlusBitmapData::wxGDIPlusBitmapData( wxGraphicsRenderer* renderer,

-                        const wxBitmap &bmp) : wxGraphicsObjectRefData( renderer )
+                        const wxBitmap &bmp) : wxGraphicsBitmapData( renderer )

 {
     m_bitmap = NULL;
     m_helper = NULL;
 {
     m_bitmap = NULL;
     m_helper = NULL;


@@ -993,6 +1089,28 @@ wxGDIPlusBitmapData::wxGDIPlusBitmapData( wxGraphicsRenderer* renderer,
         m_bitmap = image;
 }
 
         m_bitmap = image;
 }
 

+#if wxUSE_IMAGE
+
+wxImage wxGDIPlusBitmapData::ConvertToImage() const
+{
+    // We could use Bitmap::LockBits() and convert to wxImage directly but
+    // passing by wxBitmap is easier. It would be nice to measure performance
+    // of the two methods but for this the second one would need to be written
+    // first...
+    HBITMAP hbmp;
+    if ( m_bitmap->GetHBITMAP(Color(0xffffffff), &hbmp) != Gdiplus::Ok )
+        return wxNullImage;
+
+    wxBitmap bmp;
+    bmp.SetWidth(m_bitmap->GetWidth());
+    bmp.SetHeight(m_bitmap->GetHeight());
+    bmp.SetHBITMAP(hbmp);
+    bmp.SetDepth(IsAlphaPixelFormat(m_bitmap->GetPixelFormat()) ? 32 : 24);
+    return bmp.ConvertToImage();
+}
+
+#endif // wxUSE_IMAGE
+

 wxGDIPlusBitmapData::~wxGDIPlusBitmapData()
 {
     delete m_bitmap;
 wxGDIPlusBitmapData::~wxGDIPlusBitmapData()
 {
     delete m_bitmap;


@@ -1240,9 +1358,6 @@ void * wxGDIPlusMatrixData::GetNativeMatrix() const
 // wxGDIPlusContext implementation
 //-----------------------------------------------------------------------------
 
 // wxGDIPlusContext implementation
 //-----------------------------------------------------------------------------
 

-IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusContext,wxGraphicsContext)
-IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusMeasuringContext,wxGDIPlusContext)
-

 class wxGDIPlusOffsetHelper
 {
 public :
 class wxGDIPlusOffsetHelper
 {
 public :


@@ -1266,68 +1381,54 @@ public :
 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, HDC hdc, wxDouble width, wxDouble height   )
     : wxGraphicsContext(renderer)
 {
 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, HDC hdc, wxDouble width, wxDouble height   )
     : wxGraphicsContext(renderer)
 {

-    Init();
-    m_context = new Graphics( hdc);
-    m_width = width;
-    m_height = height;
-    SetDefaults();
+    Init(new Graphics(hdc), width, height);

 }
 
 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, const wxDC& dc )
     : wxGraphicsContext(renderer)
 {
 }
 
 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, const wxDC& dc )
     : wxGraphicsContext(renderer)
 {

-    Init();
-

     wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl );
     HDC hdc = (HDC) msw->GetHDC();
     wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl );
     HDC hdc = (HDC) msw->GetHDC();

-
-    m_context = new Graphics(hdc);

     wxSize sz = dc.GetSize();
     wxSize sz = dc.GetSize();

-    m_width = sz.x;
-    m_height = sz.y;

 
 

-    SetDefaults();
+    Init(new Graphics(hdc), sz.x, sz.y);

 }
 
 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, HWND hwnd  )
     : wxGraphicsContext(renderer)
 {
 }
 
 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, HWND hwnd  )
     : wxGraphicsContext(renderer)
 {

-    Init();
-    m_context = new Graphics( hwnd);

     RECT rect = wxGetWindowRect(hwnd);
     RECT rect = wxGetWindowRect(hwnd);

-    m_width = rect.right - rect.left;
-    m_height = rect.bottom - rect.top;
-    SetDefaults();
+    Init(new Graphics(hwnd), rect.right - rect.left, rect.bottom - rect.top);
+    m_enableOffset = true;

 }
 
 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, Graphics* gr  )
     : wxGraphicsContext(renderer)
 {
 }
 
 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, Graphics* gr  )
     : wxGraphicsContext(renderer)
 {

-    Init();
-    m_context = gr;
-    SetDefaults();
+    Init(gr, 0, 0);

 }
 
 }
 

-wxGDIPlusContext::wxGDIPlusContext() : wxGraphicsContext(NULL)
+wxGDIPlusContext::wxGDIPlusContext(wxGraphicsRenderer* renderer)
+    : wxGraphicsContext(renderer)

 {
 {

-    Init();
+    // Derived class must call Init() later but just set m_context to NULL for
+    // safety to avoid crashing in our dtor if Init() ends up not being called.
+    m_context = NULL;

 }
 
 }
 

-void wxGDIPlusContext::Init()
+void wxGDIPlusContext::Init(Graphics* graphics, int width, int height)

 {
 {

-    m_context = NULL;
+    m_context = graphics;

     m_state1 = 0;
     m_state1 = 0;

-    m_state2= 0;
-    m_height = 0;
-    m_width = 0;
+    m_state2 = 0;
+    m_width = width;
+    m_height = height;

     m_fontScaleRatio = 1.0;
     m_fontScaleRatio = 1.0;

-}

 
 

-void wxGDIPlusContext::SetDefaults()
-{

     m_context->SetTextRenderingHint(TextRenderingHintSystemDefault);
     m_context->SetPixelOffsetMode(PixelOffsetModeHalf);
     m_context->SetSmoothingMode(SmoothingModeHighQuality);
     m_context->SetTextRenderingHint(TextRenderingHintSystemDefault);
     m_context->SetPixelOffsetMode(PixelOffsetModeHalf);
     m_context->SetSmoothingMode(SmoothingModeHighQuality);

+    m_context->SetInterpolationMode(InterpolationModeHighQuality);

     m_state1 = m_context->Save();
     m_state2 = m_context->Save();
 }
     m_state1 = m_context->Save();
     m_state2 = m_context->Save();
 }


@@ -1359,6 +1460,31 @@ void wxGDIPlusContext::ResetClip()
     m_context->ResetClip();
 }
 
     m_context->ResetClip();
 }
 

+void wxGDIPlusContext::DrawRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
+{
+    if (m_composition == wxCOMPOSITION_DEST)
+        return;
+
+    wxGDIPlusOffsetHelper helper( m_context , ShouldOffset() );
+    Brush *brush = m_brush.IsNull() ? NULL : ((wxGDIPlusBrushData*)m_brush.GetRefData())->GetGDIPlusBrush();
+    Pen *pen = m_pen.IsNull() ? NULL : ((wxGDIPlusPenData*)m_pen.GetGraphicsData())->GetGDIPlusPen();
+
+    if ( brush )
+    {
+        // the offset is used to fill only the inside of the rectangle and not paint underneath
+        // its border which may influence a transparent Pen
+        REAL offset = 0;
+        if ( pen )
+             offset = pen->GetWidth();
+        m_context->FillRectangle( brush, (REAL)x + offset/2, (REAL)y + offset/2, (REAL)w - offset, (REAL)h - offset);
+    }
+
+    if ( pen )
+    {
+        m_context->DrawRectangle( pen, (REAL)x, (REAL)y, (REAL)w, (REAL)h );
+    }
+}
+

 void wxGDIPlusContext::StrokeLines( size_t n, const wxPoint2DDouble *points)
 {
    if (m_composition == wxCOMPOSITION_DEST)
 void wxGDIPlusContext::StrokeLines( size_t n, const wxPoint2DDouble *points)
 {
    if (m_composition == wxCOMPOSITION_DEST)


@@ -1448,6 +1574,46 @@ bool wxGDIPlusContext::SetAntialiasMode(wxAntialiasMode antialias)
     return true;
 }
 
     return true;
 }
 

+bool wxGDIPlusContext::SetInterpolationQuality(wxInterpolationQuality interpolation)
+{
+    if (m_interpolation == interpolation)
+        return true;
+
+    InterpolationMode interpolationMode = InterpolationModeDefault;
+    switch (interpolation)
+    {
+        case wxINTERPOLATION_DEFAULT:
+            interpolationMode = InterpolationModeDefault;
+            break;
+
+        case wxINTERPOLATION_NONE:
+            interpolationMode = InterpolationModeNearestNeighbor;
+            break;
+
+        case wxINTERPOLATION_FAST:
+            interpolationMode = InterpolationModeLowQuality;
+            break;
+
+        case wxINTERPOLATION_GOOD:
+            interpolationMode = InterpolationModeHighQuality;
+            break;
+
+        case wxINTERPOLATION_BEST:
+            interpolationMode = InterpolationModeHighQualityBicubic;
+            break;
+
+        default:
+            return false;
+    }
+
+    if ( m_context->SetInterpolationMode(interpolationMode) != Gdiplus::Ok )
+        return false;
+
+    m_interpolation = interpolation;
+
+    return true;
+}
+

 bool wxGDIPlusContext::SetCompositionMode(wxCompositionMode op)
 {
     if ( m_composition == op )
 bool wxGDIPlusContext::SetCompositionMode(wxCompositionMode op)
 {
     if ( m_composition == op )


@@ -1508,6 +1674,8 @@ void wxGDIPlusContext::PushState()
 
 void wxGDIPlusContext::PopState()
 {
 
 void wxGDIPlusContext::PopState()
 {

+    wxCHECK_RET( !m_stateStack.empty(), wxT("No state to pop") );
+

     GraphicsState state = m_stateStack.top();
     m_stateStack.pop();
     m_context->Restore(state);
     GraphicsState state = m_stateStack.top();
     m_stateStack.pop();
     m_context->Restore(state);


@@ -1525,7 +1693,7 @@ void wxGDIPlusContext::DrawBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDo
         {
             Rect drawRect((REAL) x, (REAL)y, (REAL)w, (REAL)h);
             m_context->SetPixelOffsetMode( PixelOffsetModeNone );
         {
             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->DrawImage(image, drawRect, 0 , 0 , image->GetWidth(), image->GetHeight(), UnitPixel ) ;

             m_context->SetPixelOffsetMode( PixelOffsetModeHalf );
         }
         else
             m_context->SetPixelOffsetMode( PixelOffsetModeHalf );
         }
         else


@@ -1603,17 +1771,8 @@ void wxGDIPlusContext::DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxD
     DeleteObject(iconInfo.hbmMask);
 }
 
     DeleteObject(iconInfo.hbmMask);
 }
 

-wxGraphicsFont wxGDIPlusContext::CreateFont( const wxFont &font,
-                                             const wxColour &col ) const
-{
-    wxGDIPlusRenderer* renderer =
-        static_cast<wxGDIPlusRenderer*>(GetRenderer());
-    return renderer->CreateGDIPlusFont(this, font, col);
-}
-
-void wxGDIPlusContext::DoDrawFilledText(const wxString& str,
-                                        wxDouble x, wxDouble y,
-                                        const wxGraphicsBrush& brush)
+void wxGDIPlusContext::DoDrawText(const wxString& str,
+                                        wxDouble x, wxDouble y )

 {
    if (m_composition == wxCOMPOSITION_DEST)
         return;
 {
    if (m_composition == wxCOMPOSITION_DEST)
         return;


@@ -1626,18 +1785,15 @@ void wxGDIPlusContext::DoDrawFilledText(const wxString& str,
 
     wxGDIPlusFontData * const
         fontData = (wxGDIPlusFontData *)m_font.GetRefData();
 
     wxGDIPlusFontData * const
         fontData = (wxGDIPlusFontData *)m_font.GetRefData();

-    wxGDIPlusBrushData * const
-        brushData = (wxGDIPlusBrushData *)brush.GetRefData();
-
+ 

     m_context->DrawString
                (
                     str.wc_str(*wxConvUI),  // string to draw, always Unicode
                     -1,                     // length: string is NUL-terminated
                     fontData->GetGDIPlusFont(),
                     PointF(x, y),
     m_context->DrawString
                (
                     str.wc_str(*wxConvUI),  // string to draw, always Unicode
                     -1,                     // length: string is NUL-terminated
                     fontData->GetGDIPlusFont(),
                     PointF(x, y),

-                    StringFormat::GenericTypographic(),
-                    brushData ? brushData->GetGDIPlusBrush()
-                              : fontData->GetGDIPlusBrush()
+                    GetDrawTextStringFormat(),
+                    fontData->GetGDIPlusBrush()

                );
 }
 
                );
 }
 


@@ -1654,12 +1810,14 @@ void wxGDIPlusContext::GetTextExtent( const wxString &str, wxDouble *width, wxDo
 
     REAL factorY = m_fontScaleRatio;
 
 
     REAL factorY = m_fontScaleRatio;
 

-    REAL rDescent = ffamily.GetCellDescent(FontStyleRegular) *
-        f->GetSize() / ffamily.GetEmHeight(FontStyleRegular);
-    REAL rAscent = ffamily.GetCellAscent(FontStyleRegular) *
-        f->GetSize() / ffamily.GetEmHeight(FontStyleRegular);
-    REAL rHeight = ffamily.GetLineSpacing(FontStyleRegular) *
-        f->GetSize() / ffamily.GetEmHeight(FontStyleRegular);
+    // Notice that we must use the real font style or the results would be
+    // incorrect for italic/bold fonts.
+    const INT style = f->GetStyle();
+    const REAL size = f->GetSize();
+    const REAL emHeight = ffamily.GetEmHeight(style);
+    REAL rDescent = ffamily.GetCellDescent(style) * size / emHeight;
+    REAL rAscent = ffamily.GetCellAscent(style) * size / emHeight;
+    REAL rHeight = ffamily.GetLineSpacing(style) * size / emHeight;

 
     if ( height )
         *height = rHeight * factorY;
 
     if ( height )
         *height = rHeight * factorY;


@@ -1676,11 +1834,9 @@ void wxGDIPlusContext::GetTextExtent( const wxString &str, wxDouble *width, wxDo
     else
     {
         RectF layoutRect(0,0, 100000.0f, 100000.0f);
     else
     {
         RectF layoutRect(0,0, 100000.0f, 100000.0f);

-        StringFormat strFormat( StringFormat::GenericTypographic() );
-        strFormat.SetFormatFlags( StringFormatFlagsMeasureTrailingSpaces | strFormat.GetFormatFlags() );

 
         RectF bounds ;
 
         RectF bounds ;

-        m_context->MeasureString((const wchar_t *) s , wcslen(s) , f, layoutRect, &strFormat, &bounds ) ;
+        m_context->MeasureString((const wchar_t *) s , wcslen(s) , f, layoutRect, GetDrawTextStringFormat(), &bounds ) ;

         if ( width )
             *width = bounds.Width;
         if ( height )
         if ( width )
             *width = bounds.Width;
         if ( height )


@@ -1704,7 +1860,7 @@ void wxGDIPlusContext::GetPartialTextExtents(const wxString& text, wxArrayDouble
     wxASSERT_MSG(text.length() == len , wxT("GetPartialTextExtents not yet implemented for multichar situations"));
 
     RectF layoutRect(0,0, 100000.0f, 100000.0f);
     wxASSERT_MSG(text.length() == len , wxT("GetPartialTextExtents not yet implemented for multichar situations"));
 
     RectF layoutRect(0,0, 100000.0f, 100000.0f);

-    StringFormat strFormat( StringFormat::GenericTypographic() );
+    StringFormat strFormat( GetDrawTextStringFormat() );

 
     size_t startPosition = 0;
     size_t remainder = len;
 
     size_t startPosition = 0;
     size_t remainder = len;


@@ -1722,7 +1878,6 @@ void wxGDIPlusContext::GetPartialTextExtents(const wxString& text, wxArrayDouble
             ranges[i].Length = startPosition+i+1 ;
         }
         strFormat.SetMeasurableCharacterRanges(span,ranges);
             ranges[i].Length = startPosition+i+1 ;
         }
         strFormat.SetMeasurableCharacterRanges(span,ranges);

-        strFormat.SetFormatFlags( StringFormatFlagsMeasureTrailingSpaces | strFormat.GetFormatFlags() );

         m_context->MeasureCharacterRanges(ws, -1 , f,layoutRect, &strFormat,span,regions) ;
 
         RectF bbox ;
         m_context->MeasureCharacterRanges(ws, -1 , f,layoutRect, &strFormat,span,regions) ;
 
         RectF bbox ;


@@ -1741,6 +1896,9 @@ void wxGDIPlusContext::GetPartialTextExtents(const wxString& text, wxArrayDouble
 
 bool wxGDIPlusContext::ShouldOffset() const
 {
 
 bool wxGDIPlusContext::ShouldOffset() const
 {

+    if ( !m_enableOffset )
+        return false;
+    

     int penwidth = 0 ;
     if ( !m_pen.IsNull() )
     {
     int penwidth = 0 ;
     if ( !m_pen.IsNull() )
     {


@@ -1862,7 +2020,7 @@ void wxGDIPlusRenderer::Unload()
     if ( m_gditoken )
     {
         GdiplusShutdown(m_gditoken);
     if ( m_gditoken )
     {
         GdiplusShutdown(m_gditoken);

-        m_gditoken = NULL;
+        m_gditoken = 0;

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


@@ -1870,7 +2028,9 @@ void wxGDIPlusRenderer::Unload()
 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxWindowDC& dc)
 {
     ENSURE_LOADED_OR_RETURN(NULL);
 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxWindowDC& dc)
 {
     ENSURE_LOADED_OR_RETURN(NULL);

-    return new wxGDIPlusContext(this, dc);
+    wxGDIPlusContext* context = new wxGDIPlusContext(this, dc);
+    context->EnableOffset(true);
+    return context;

 }
 
 #if wxUSE_PRINTING_ARCHITECTURE
 }
 
 #if wxUSE_PRINTING_ARCHITECTURE


@@ -1894,9 +2054,22 @@ wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxEnhMetaFileDC& dc)
 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxMemoryDC& dc)
 {
     ENSURE_LOADED_OR_RETURN(NULL);
 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxMemoryDC& dc)
 {
     ENSURE_LOADED_OR_RETURN(NULL);

-    return new wxGDIPlusContext(this, dc);
+    wxGDIPlusContext* context = new wxGDIPlusContext(this, dc);
+    context->EnableOffset(true);
+    return context;
+}
+
+#if wxUSE_IMAGE
+wxGraphicsContext * wxGDIPlusRenderer::CreateContextFromImage(wxImage& image)
+{
+    ENSURE_LOADED_OR_RETURN(NULL);
+    wxGDIPlusContext* context = new wxGDIPlusImageContext(this, image);
+    context->EnableOffset(true);
+    return context;

 }
 
 }
 

+#endif // wxUSE_IMAGE
+

 wxGraphicsContext * wxGDIPlusRenderer::CreateMeasuringContext()
 {
     ENSURE_LOADED_OR_RETURN(NULL);
 wxGraphicsContext * wxGDIPlusRenderer::CreateMeasuringContext()
 {
     ENSURE_LOADED_OR_RETURN(NULL);


@@ -1950,7 +2123,7 @@ wxGraphicsMatrix wxGDIPlusRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDoub
 wxGraphicsPen wxGDIPlusRenderer::CreatePen(const wxPen& pen)
 {
     ENSURE_LOADED_OR_RETURN(wxNullGraphicsPen);
 wxGraphicsPen wxGDIPlusRenderer::CreatePen(const wxPen& pen)
 {
     ENSURE_LOADED_OR_RETURN(wxNullGraphicsPen);

-    if ( !pen.Ok() || pen.GetStyle() == wxTRANSPARENT )
+    if ( !pen.IsOk() || pen.GetStyle() == wxTRANSPARENT )

         return wxNullGraphicsPen;
     else
     {
         return wxNullGraphicsPen;
     else
     {


@@ -1963,7 +2136,7 @@ wxGraphicsPen wxGDIPlusRenderer::CreatePen(const wxPen& pen)
 wxGraphicsBrush wxGDIPlusRenderer::CreateBrush(const wxBrush& brush )
 {
     ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush);
 wxGraphicsBrush wxGDIPlusRenderer::CreateBrush(const wxBrush& brush )
 {
     ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush);

-    if ( !brush.Ok() || brush.GetStyle() == wxTRANSPARENT )
+    if ( !brush.IsOk() || brush.GetStyle() == wxTRANSPARENT )

         return wxNullGraphicsBrush;
     else
     {
         return wxNullGraphicsBrush;
     else
     {


@@ -2001,25 +2174,49 @@ wxGDIPlusRenderer::CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
 }
 
 wxGraphicsFont
 }
 
 wxGraphicsFont

-wxGDIPlusRenderer::CreateGDIPlusFont( const wxGDIPlusContext* gc,
-                                      const wxFont &font,
-                                      const wxColour &col )
+wxGDIPlusRenderer::CreateFont( const wxFont &font,
+                               const wxColour &col )

 {
     ENSURE_LOADED_OR_RETURN(wxNullGraphicsFont);
 {
     ENSURE_LOADED_OR_RETURN(wxNullGraphicsFont);

-    if ( font.Ok() )
+    if ( font.IsOk() )

     {
         wxGraphicsFont p;
     {
         wxGraphicsFont p;

-        p.SetRefData(new wxGDIPlusFontData( this, gc, font, col ));
+        p.SetRefData(new wxGDIPlusFontData( this, font, col ));

         return p;
     }
     else
         return wxNullGraphicsFont;
 }
 
         return p;
     }
     else
         return wxNullGraphicsFont;
 }
 

+wxGraphicsFont
+wxGDIPlusRenderer::CreateFont(double size,
+                              const wxString& facename,
+                              int flags,
+                              const wxColour& col)
+{
+    ENSURE_LOADED_OR_RETURN(wxNullGraphicsFont);
+
+    // Convert wxFont flags to GDI+ style:
+    int style = FontStyleRegular;
+    if ( flags & wxFONTFLAG_ITALIC )
+        style |= FontStyleItalic;
+    if ( flags & wxFONTFLAG_UNDERLINED )
+        style |= FontStyleUnderline;
+    if ( flags & wxFONTFLAG_BOLD )
+        style |= FontStyleBold;
+    if ( flags & wxFONTFLAG_STRIKETHROUGH )
+        style |= FontStyleStrikeout;
+
+
+    wxGraphicsFont f;
+    f.SetRefData(new wxGDIPlusFontData(this, facename, size, style, col));
+    return f;
+}
+

 wxGraphicsBitmap wxGDIPlusRenderer::CreateBitmap( const wxBitmap &bitmap )
 {
     ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap);
 wxGraphicsBitmap wxGDIPlusRenderer::CreateBitmap( const wxBitmap &bitmap )
 {
     ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap);

-    if ( bitmap.Ok() )
+    if ( bitmap.IsOk() )

     {
         wxGraphicsBitmap p;
         p.SetRefData(new wxGDIPlusBitmapData( this , bitmap ));
     {
         wxGraphicsBitmap p;
         p.SetRefData(new wxGDIPlusBitmapData( this , bitmap ));


@@ -2029,6 +2226,40 @@ wxGraphicsBitmap wxGDIPlusRenderer::CreateBitmap( const wxBitmap &bitmap )
         return wxNullGraphicsBitmap;
 }
 
         return wxNullGraphicsBitmap;
 }
 

+#if wxUSE_IMAGE
+
+wxGraphicsBitmap wxGDIPlusRenderer::CreateBitmapFromImage(const wxImage& image)
+{
+    ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap);
+    if ( image.IsOk() )
+    {
+        // Notice that we rely on conversion from wxImage to wxBitmap here but
+        // we could probably do it more efficiently by converting from wxImage
+        // to GDI+ Bitmap directly, i.e. copying wxImage pixels to the buffer
+        // returned by Bitmap::LockBits(). However this would require writing
+        // code specific for this task while like this we can reuse existing
+        // code (see also wxGDIPlusBitmapData::ConvertToImage()).
+        wxGraphicsBitmap gb;
+        gb.SetRefData(new wxGDIPlusBitmapData(this, image));
+        return gb;
+    }
+    else
+        return wxNullGraphicsBitmap;
+}
+
+
+wxImage wxGDIPlusRenderer::CreateImageFromBitmap(const wxGraphicsBitmap& bmp)
+{
+    ENSURE_LOADED_OR_RETURN(wxNullImage);
+    const wxGDIPlusBitmapData* const
+        data = static_cast<wxGDIPlusBitmapData*>(bmp.GetGraphicsData());
+
+    return data ? data->ConvertToImage() : wxNullImage;
+}
+
+#endif // wxUSE_IMAGE
+
+

 wxGraphicsBitmap wxGDIPlusRenderer::CreateBitmapFromNativeBitmap( void *bitmap )
 {
     ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap);
 wxGraphicsBitmap wxGDIPlusRenderer::CreateBitmapFromNativeBitmap( void *bitmap )
 {
     ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap);


@@ -2061,7 +2292,12 @@ class wxGDIPlusRendererModule : public wxModule
 {
 public:
     virtual bool OnInit() { return true; }
 {
 public:
     virtual bool OnInit() { return true; }

-    virtual void OnExit() { gs_GDIPlusRenderer.Unload(); }
+    virtual void OnExit()
+    {
+        wxDELETE(gs_drawTextStringFormat);
+
+        gs_GDIPlusRenderer.Unload();
+    }

 
 private:
     DECLARE_DYNAMIC_CLASS(wxGDIPlusRendererModule)
 
 private:
     DECLARE_DYNAMIC_CLASS(wxGDIPlusRendererModule)


@@ -2079,6 +2315,14 @@ WXHDC wxGCDC::AcquireHDC()
     if ( !gc )
         return NULL;
 
     if ( !gc )
         return NULL;
 

+#if wxUSE_CAIRO
+    // we can't get the HDC if it is not a GDI+ context
+    wxGraphicsRenderer* r1 = gc->GetRenderer();
+    wxGraphicsRenderer* r2 = wxGraphicsRenderer::GetCairoRenderer();
+    if (r1 == r2)
+        return NULL;
+#endif
+

     Graphics * const g = static_cast<Graphics *>(gc->GetNativeContext());
     return g ? g->GetHDC() : NULL;
 }
     Graphics * const g = static_cast<Graphics *>(gc->GetNativeContext());
     return g ? g->GetHDC() : NULL;
 }


@@ -2091,6 +2335,14 @@ void wxGCDC::ReleaseHDC(WXHDC hdc)
     wxGraphicsContext * const gc = GetGraphicsContext();
     wxCHECK_RET( gc, "can't release HDC because there is no wxGraphicsContext" );
 
     wxGraphicsContext * const gc = GetGraphicsContext();
     wxCHECK_RET( gc, "can't release HDC because there is no wxGraphicsContext" );
 

+#if wxUSE_CAIRO
+    // we can't get the HDC if it is not a GDI+ context
+    wxGraphicsRenderer* r1 = gc->GetRenderer();
+    wxGraphicsRenderer* r2 = wxGraphicsRenderer::GetCairoRenderer();
+    if (r1 == r2)
+        return;
+#endif
+

     Graphics * const g = static_cast<Graphics *>(gc->GetNativeContext());
     wxCHECK_RET( g, "can't release HDC because there is no Graphics" );
 
     Graphics * const g = static_cast<Graphics *>(gc->GetNativeContext());
     wxCHECK_RET( g, "can't release HDC because there is no Graphics" );