]> git.saurik.com Git - wxWidgets.git/blobdiff - src/generic/graphicc.cpp
missing commit
[wxWidgets.git] / src / generic / graphicc.cpp
index 9b9e88b22feda74941714ab168c9a2bebe847612..5e7da3dcba2654ae70349dea4a19e51820e43c1d 100644 (file)
 
 #if wxUSE_CAIRO
 
-#include "wx/cairo.h"
+// keep cairo.h from defining dllimport as we're defining the symbols inside
+// the wx dll in order to load them dynamically.
+#define cairo_public 
+
+#include <cairo.h>
+
+bool wxCairoInit();
 
 #ifndef WX_PRECOMP
     #include "wx/bitmap.h"
@@ -29,6 +35,7 @@
     #include "wx/dcclient.h"
     #include "wx/dcmemory.h"
     #include "wx/dcprint.h"
+    #include "wx/window.h"
 #endif
 
 #include "wx/private/graphics.h"
@@ -66,16 +73,18 @@ using namespace std;
 #include <cairo.h>
 #ifdef __WXMSW__
 #include <cairo-win32.h>
+// Notice that the order is important: cairo-win32.h includes windows.h which
+// pollutes the global name space with macros so include our own header which
+// #undefines them after it.
+#include "wx/msw/private.h"
 #endif
 
 #ifdef __WXGTK__
 #include <gtk/gtk.h>
 #include "wx/fontutil.h"
+#ifndef __WXGTK3__
 #include "wx/gtk/dc.h"
 #endif
-
-#ifdef __WXMSW__
-#include <cairo-win32.h>
 #endif
 
 #ifdef __WXMAC__
@@ -209,7 +218,44 @@ private:
     cairo_matrix_t m_matrix ;
 } ;
 
-class WXDLLIMPEXP_CORE wxCairoPenData : public wxGraphicsObjectRefData
+// Common base class for pens and brushes.
+class wxCairoPenBrushBaseData : public wxGraphicsObjectRefData
+{
+public:
+    wxCairoPenBrushBaseData(wxGraphicsRenderer* renderer,
+                            const wxColour& col,
+                            bool isTransparent);
+    virtual ~wxCairoPenBrushBaseData();
+
+    virtual void Apply( wxGraphicsContext* context );
+
+protected:
+    // Call this to use the given bitmap as stipple. Bitmap must be non-null
+    // and valid.
+    void InitStipple(wxBitmap* bmp);
+
+    // Call this to use the given hatch style. Hatch style must be valid.
+    void InitHatch(wxHatchStyle hatchStyle);
+
+
+    double m_red;
+    double m_green;
+    double m_blue;
+    double m_alpha;
+
+    cairo_pattern_t* m_pattern;
+    class wxCairoBitmapData* m_bmpdata;
+
+private:
+    // Called once to allocate m_pattern if needed.
+    void InitHatchPattern(cairo_t* ctext);
+
+    wxHatchStyle m_hatchStyle;
+
+    wxDECLARE_NO_COPY_CLASS(wxCairoPenBrushBaseData);
+};
+
+class WXDLLIMPEXP_CORE wxCairoPenData : public wxCairoPenBrushBaseData
 {
 public:
     wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen );
@@ -223,11 +269,6 @@ public:
 private :
     double m_width;
 
-    double m_red;
-    double m_green;
-    double m_blue;
-    double m_alpha;
-
     cairo_line_cap_t m_cap;
     cairo_line_join_t m_join;
 
@@ -235,19 +276,14 @@ private :
     const double *m_lengths;
     double *m_userLengths;
 
-    wxPen m_pen;
-
     wxDECLARE_NO_COPY_CLASS(wxCairoPenData);
 };
 
-class WXDLLIMPEXP_CORE wxCairoBrushData : public wxGraphicsObjectRefData
+class WXDLLIMPEXP_CORE wxCairoBrushData : public wxCairoPenBrushBaseData
 {
 public:
     wxCairoBrushData( wxGraphicsRenderer* renderer );
     wxCairoBrushData( wxGraphicsRenderer* renderer, const wxBrush &brush );
-    ~wxCairoBrushData ();
-
-    virtual void Apply( wxGraphicsContext* context );
 
     void CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
                                    wxDouble x2, wxDouble y2,
@@ -261,30 +297,30 @@ protected:
 
     // common part of Create{Linear,Radial}GradientBrush()
     void AddGradientStops(const wxGraphicsGradientStops& stops);
-
-private :
-    double m_red;
-    double m_green;
-    double m_blue;
-    double m_alpha;
-
-    cairo_pattern_t* m_brushPattern;
 };
 
 class wxCairoFontData : public wxGraphicsObjectRefData
 {
 public:
     wxCairoFontData( wxGraphicsRenderer* renderer, const wxFont &font, const wxColour& col );
+    wxCairoFontData(wxGraphicsRenderer* renderer,
+                    double sizeInPixels,
+                    const wxString& facename,
+                    int flags,
+                    const wxColour& col);
     ~wxCairoFontData();
 
-    virtual void Apply( wxGraphicsContext* context );
+    virtual bool Apply( wxGraphicsContext* context );
 #ifdef __WXGTK__
-    const PangoFontDescription* GetFont() const { return m_font; }
-    bool GetUnderlined() const { return m_underlined; }
+    const wxFont& GetFont() const { return m_wxfont; }
 #endif
 private :
+    void InitColour(const wxColour& col);
+    void InitFontComponents(const wxString& facename,
+                            cairo_font_slant_t slant,
+                            cairo_font_weight_t weight);
+
     double m_size;
-    bool m_underlined;
     double m_red;
     double m_green;
     double m_blue;
@@ -292,28 +328,54 @@ private :
 #ifdef __WXMAC__
     cairo_font_face_t *m_font;
 #elif defined(__WXGTK__)
-    PangoFontDescription* m_font;
-#else
+    wxFont m_wxfont;
+#endif
+
+    // These members are used when the font is created from its face name and
+    // flags (and not from wxFont) and also even when creating it from wxFont
+    // on the platforms not covered above.
+    //
+    // Notice that we can't use cairo_font_face_t instead of storing those,
+    // even though it would be simpler and need less #ifdefs, because
+    // cairo_toy_font_face_create() that we'd need to create it is only
+    // available in Cairo 1.8 and we require just 1.2 currently. If we do drop
+    // support for < 1.8 versions in the future it would be definitely better
+    // to use cairo_toy_font_face_create() instead.
     wxCharBuffer m_fontName;
     cairo_font_slant_t m_slant;
     cairo_font_weight_t m_weight;
-#endif
-#ifdef __WXMSW__
-    wxCairoContext( wxGraphicsRenderer* renderer, HDC context );
-#endif
 };
 
-class wxCairoBitmapData : public wxGraphicsObjectRefData
+class wxCairoBitmapData : public wxGraphicsBitmapData
 {
 public:
     wxCairoBitmapData( wxGraphicsRenderer* renderer, const wxBitmap& bmp );
+#if wxUSE_IMAGE
+    wxCairoBitmapData(wxGraphicsRenderer* renderer, const wxImage& image);
+#endif // wxUSE_IMAGE
     wxCairoBitmapData( wxGraphicsRenderer* renderer, cairo_surface_t* bitmap );
     ~wxCairoBitmapData();
 
     virtual cairo_surface_t* GetCairoSurface() { return m_surface; }
     virtual cairo_pattern_t* GetCairoPattern() { return m_pattern; }
+    virtual void* GetNativeBitmap() const { return m_surface; }
     virtual wxSize GetSize() { return wxSize(m_width, m_height); }
+
+#if wxUSE_IMAGE
+    wxImage ConvertToImage() const;
+#endif // wxUSE_IMAGE
+
 private :
+    // Allocate m_buffer for the bitmap of the given size in the given format.
+    //
+    // Returns the stride used for the buffer.
+    int InitBuffer(int width, int height, cairo_format_t format);
+
+    // Really create the surface using the buffer (which was supposed to be
+    // filled since InitBuffer() call).
+    void InitSurface(cairo_format_t format, int stride);
+
+
     cairo_surface_t* m_surface;
     cairo_pattern_t* m_pattern;
     int m_width;
@@ -328,15 +390,24 @@ public:
     wxCairoContext( wxGraphicsRenderer* renderer, const wxMemoryDC& dc );
     wxCairoContext( wxGraphicsRenderer* renderer, const wxPrinterDC& dc );
 #ifdef __WXGTK__
-    wxCairoContext( wxGraphicsRenderer* renderer, GdkDrawable *drawable );
+    wxCairoContext( wxGraphicsRenderer* renderer, GdkWindow *window );
+#endif
+#ifdef __WXMSW__
+    wxCairoContext( wxGraphicsRenderer* renderer, HDC context );
 #endif
     wxCairoContext( wxGraphicsRenderer* renderer, cairo_t *context );
     wxCairoContext( wxGraphicsRenderer* renderer, wxWindow *window);
-    wxCairoContext();
+
+    // If this ctor is used, Init() must be called by the derived class later.
+    wxCairoContext( wxGraphicsRenderer* renderer );
+
     virtual ~wxCairoContext();
 
     virtual bool ShouldOffset() const
     {
+        if ( !m_enableOffset )
+            return false;
+        
         int penwidth = 0 ;
         if ( !m_pen.IsNull() )
         {
@@ -350,6 +421,7 @@ public:
     virtual void Clip( const wxRegion &region );
 #ifdef __WXMSW__
     cairo_surface_t* m_mswSurface;
+    WindowHDC m_mswWindowHDC;
 #endif
 
     // clips drawings to the rect
@@ -362,6 +434,8 @@ public:
 
     virtual bool SetAntialiasMode(wxAntialiasMode antialias);
 
+    virtual bool SetInterpolationQuality(wxInterpolationQuality interpolation);
+
     virtual bool SetCompositionMode(wxCompositionMode op);
 
     virtual void BeginLayer(wxDouble opacity);
@@ -397,9 +471,9 @@ public:
 protected:
     virtual void DoDrawText( const wxString &str, wxDouble x, wxDouble y );
 
-private:
     void Init(cairo_t *context);
 
+private:
     cairo_t* m_context;
 
     wxVector<float> m_layerOpacities;
@@ -407,6 +481,168 @@ private:
     wxDECLARE_NO_COPY_CLASS(wxCairoContext);
 };
 
+#if wxUSE_IMAGE
+// ----------------------------------------------------------------------------
+// wxCairoImageContext: context associated with a wxImage.
+// ----------------------------------------------------------------------------
+
+class wxCairoImageContext : public wxCairoContext
+{
+public:
+    wxCairoImageContext(wxGraphicsRenderer* renderer, wxImage& image) :
+        wxCairoContext(renderer),
+        m_image(image),
+        m_data(renderer, image)
+    {
+        Init(cairo_create(m_data.GetCairoSurface()));
+    }
+
+    virtual ~wxCairoImageContext()
+    {
+        m_image = m_data.ConvertToImage();
+    }
+
+private:
+    wxImage& m_image;
+    wxCairoBitmapData m_data;
+
+    wxDECLARE_NO_COPY_CLASS(wxCairoImageContext);
+};
+#endif // wxUSE_IMAGE
+
+// ----------------------------------------------------------------------------
+// wxCairoPenBrushBaseData implementation
+//-----------------------------------------------------------------------------
+
+wxCairoPenBrushBaseData::wxCairoPenBrushBaseData(wxGraphicsRenderer* renderer,
+                                                 const wxColour& col,
+                                                 bool isTransparent)
+    : wxGraphicsObjectRefData(renderer)
+{
+    m_hatchStyle = wxHATCHSTYLE_INVALID;
+    m_pattern = NULL;
+    m_bmpdata = NULL;
+
+    if ( isTransparent )
+    {
+        m_red =
+        m_green =
+        m_blue =
+        m_alpha = 0;
+    }
+    else // non-transparent
+    {
+        m_red = col.Red()/255.0;
+        m_green = col.Green()/255.0;
+        m_blue = col.Blue()/255.0;
+        m_alpha = col.Alpha()/255.0;
+    }
+}
+
+wxCairoPenBrushBaseData::~wxCairoPenBrushBaseData()
+{
+    if (m_bmpdata)
+    {
+        // Deleting the bitmap data also deletes the pattern referenced by
+        // m_pattern, so set it to NULL to avoid deleting it twice.
+        delete m_bmpdata;
+        m_pattern = NULL;
+    }
+    if (m_pattern)
+        cairo_pattern_destroy(m_pattern);
+}
+
+void wxCairoPenBrushBaseData::InitHatchPattern(cairo_t* ctext)
+{
+    cairo_surface_t* const
+        surface = cairo_surface_create_similar(
+                    cairo_get_target(ctext), CAIRO_CONTENT_COLOR_ALPHA, 10, 10
+                );
+
+    cairo_t* const cr = cairo_create(surface);
+    cairo_set_line_cap(cr, CAIRO_LINE_CAP_SQUARE);
+    cairo_set_line_width(cr, 1);
+    cairo_set_line_join(cr,CAIRO_LINE_JOIN_MITER);
+
+    switch ( m_hatchStyle )
+    {
+        case wxHATCHSTYLE_CROSS:
+            cairo_move_to(cr, 5, 0);
+            cairo_line_to(cr, 5, 10);
+            cairo_move_to(cr, 0, 5);
+            cairo_line_to(cr, 10, 5);
+            break;
+
+        case wxHATCHSTYLE_BDIAGONAL:
+            cairo_move_to(cr, 0, 10);
+            cairo_line_to(cr, 10, 0);
+            break;
+
+        case wxHATCHSTYLE_FDIAGONAL:
+            cairo_move_to(cr, 0, 0);
+            cairo_line_to(cr, 10, 10);
+            break;
+
+        case wxHATCHSTYLE_CROSSDIAG:
+            cairo_move_to(cr, 0, 0);
+            cairo_line_to(cr, 10, 10);
+            cairo_move_to(cr, 10, 0);
+            cairo_line_to(cr, 0, 10);
+            break;
+
+        case wxHATCHSTYLE_HORIZONTAL:
+            cairo_move_to(cr, 0, 5);
+            cairo_line_to(cr, 10, 5);
+            break;
+
+        case wxHATCHSTYLE_VERTICAL:
+            cairo_move_to(cr, 5, 0);
+            cairo_line_to(cr, 5, 10);
+            break;
+
+        default:
+            wxFAIL_MSG(wxS("Invalid hatch pattern style."));
+    }
+
+    cairo_set_source_rgba(cr, m_red, m_green, m_blue, m_alpha);
+    cairo_stroke(cr);
+
+    cairo_destroy(cr);
+
+    m_pattern = cairo_pattern_create_for_surface(surface);
+    cairo_surface_destroy(surface);
+    cairo_pattern_set_extend(m_pattern, CAIRO_EXTEND_REPEAT);
+}
+
+void wxCairoPenBrushBaseData::InitStipple(wxBitmap* bmp)
+{
+    wxCHECK_RET( bmp && bmp->IsOk(), wxS("Invalid stippled bitmap") );
+
+    m_bmpdata = new wxCairoBitmapData(GetRenderer(), *bmp);
+    m_pattern = m_bmpdata->GetCairoPattern();
+    cairo_pattern_set_extend(m_pattern, CAIRO_EXTEND_REPEAT);
+}
+
+void wxCairoPenBrushBaseData::InitHatch(wxHatchStyle hatchStyle)
+{
+    // We can't create m_pattern right now as we don't have the Cairo context
+    // needed for it, so just remember that we need to do it.
+    m_hatchStyle = hatchStyle;
+}
+
+void wxCairoPenBrushBaseData::Apply( wxGraphicsContext* context )
+{
+    cairo_t* const ctext = (cairo_t*) context->GetNativeContext();
+
+    if ( m_hatchStyle != wxHATCHSTYLE_INVALID && !m_pattern )
+        InitHatchPattern(ctext);
+
+    if ( m_pattern )
+        cairo_set_source(ctext, m_pattern);
+    else
+        cairo_set_source_rgba(ctext, m_red, m_green, m_blue, m_alpha);
+}
+
 //-----------------------------------------------------------------------------
 // wxCairoPenData implementation
 //-----------------------------------------------------------------------------
@@ -425,20 +661,14 @@ void wxCairoPenData::Init()
 }
 
 wxCairoPenData::wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
-: wxGraphicsObjectRefData(renderer)
+    : wxCairoPenBrushBaseData(renderer, pen.GetColour(), pen.IsTransparent())
 {
     Init();
-    m_pen = pen;
-    m_width = m_pen.GetWidth();
+    m_width = pen.GetWidth();
     if (m_width <= 0.0)
         m_width = 0.1;
 
-    m_red = m_pen.GetColour().Red()/255.0;
-    m_green = m_pen.GetColour().Green()/255.0;
-    m_blue = m_pen.GetColour().Blue()/255.0;
-    m_alpha = m_pen.GetColour().Alpha()/255.0;
-
-    switch ( m_pen.GetCap() )
+    switch ( pen.GetCap() )
     {
     case wxCAP_ROUND :
         m_cap = CAIRO_LINE_CAP_ROUND;
@@ -457,7 +687,7 @@ wxCairoPenData::wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
         break;
     }
 
-    switch ( m_pen.GetJoin() )
+    switch ( pen.GetJoin() )
     {
     case wxJOIN_BEVEL :
         m_join = CAIRO_LINE_JOIN_BEVEL;
@@ -494,7 +724,7 @@ wxCairoPenData::wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
         9.0 , 6.0 , 3.0 , 3.0
     };
 
-    switch ( m_pen.GetStyle() )
+    switch ( pen.GetStyle() )
     {
     case wxPENSTYLE_SOLID :
         break;
@@ -524,7 +754,7 @@ wxCairoPenData::wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
     case wxPENSTYLE_USER_DASH :
         {
             wxDash *wxdashes ;
-            m_count = m_pen.GetDashes( &wxdashes ) ;
+            m_count = pen.GetDashes( &wxdashes ) ;
             if ((wxdashes != NULL) && (m_count > 0))
             {
                 m_userLengths = new double[m_count] ;
@@ -541,54 +771,18 @@ wxCairoPenData::wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
             m_lengths = m_userLengths ;
         }
         break;
+
     case wxPENSTYLE_STIPPLE :
-        {
-            /*
-            wxBitmap* bmp = pen.GetStipple();
-            if ( bmp && bmp->Ok() )
-            {
-            wxDELETE( m_penImage );
-            wxDELETE( m_penBrush );
-            m_penImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),(HPALETTE)bmp->GetPalette()->GetHPALETTE());
-            m_penBrush = new TextureBrush(m_penImage);
-            m_pen->SetBrush( m_penBrush );
-            }
-            */
-        }
+    case wxPENSTYLE_STIPPLE_MASK :
+    case wxPENSTYLE_STIPPLE_MASK_OPAQUE :
+        InitStipple(pen.GetStipple());
         break;
+
     default :
-        if ( m_pen.GetStyle() >= wxPENSTYLE_FIRST_HATCH
-            && m_pen.GetStyle() <= wxPENSTYLE_LAST_HATCH )
+        if ( pen.GetStyle() >= wxPENSTYLE_FIRST_HATCH
+            && pen.GetStyle() <= wxPENSTYLE_LAST_HATCH )
         {
-            /*
-            wxDELETE( m_penBrush );
-            HatchStyle style = HatchStyleHorizontal;
-            switch( pen.GetStyle() )
-            {
-            case wxPENSTYLE_BDIAGONAL_HATCH :
-            style = HatchStyleBackwardDiagonal;
-            break ;
-            case wxPENSTYLE_CROSSDIAG_HATCH :
-            style = HatchStyleDiagonalCross;
-            break ;
-            case wxPENSTYLE_FDIAGONAL_HATCH :
-            style = HatchStyleForwardDiagonal;
-            break ;
-            case wxPENSTYLE_CROSS_HATCH :
-            style = HatchStyleCross;
-            break ;
-            case wxPENSTYLE_HORIZONTAL_HATCH :
-            style = HatchStyleHorizontal;
-            break ;
-            case wxPENSTYLE_VERTICAL_HATCH :
-            style = HatchStyleVertical;
-            break ;
-
-            }
-            m_penBrush = new HatchBrush(style,Color( pen.GetColour().Alpha() , pen.GetColour().Red() ,
-            pen.GetColour().Green() , pen.GetColour().Blue() ), Color.Transparent );
-            m_pen->SetBrush( m_penBrush )
-            */
+            InitHatch(static_cast<wxHatchStyle>(pen.GetStyle()));
         }
         break;
     }
@@ -596,9 +790,10 @@ wxCairoPenData::wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
 
 void wxCairoPenData::Apply( wxGraphicsContext* context )
 {
+    wxCairoPenBrushBaseData::Apply(context);
+
     cairo_t * ctext = (cairo_t*) context->GetNativeContext();
     cairo_set_line_width(ctext,m_width);
-    cairo_set_source_rgba(ctext,m_red,m_green, m_blue,m_alpha);
     cairo_set_line_cap(ctext,m_cap);
     cairo_set_line_join(ctext,m_join);
     cairo_set_dash(ctext,(double*)m_lengths,m_count,0.0);
@@ -609,83 +804,29 @@ void wxCairoPenData::Apply( wxGraphicsContext* context )
 //-----------------------------------------------------------------------------
 
 wxCairoBrushData::wxCairoBrushData( wxGraphicsRenderer* renderer )
-  : wxGraphicsObjectRefData( renderer )
+    : wxCairoPenBrushBaseData(renderer, wxColour(), true /* transparent */)
 {
     Init();
 }
 
-wxCairoBrushData::wxCairoBrushData( wxGraphicsRenderer* renderer, const wxBrush &brush )
-  : wxGraphicsObjectRefData(renderer)
+wxCairoBrushData::wxCairoBrushData( wxGraphicsRenderer* renderer,
+                                    const wxBrush &brush )
+    : wxCairoPenBrushBaseData(renderer, brush.GetColour(), brush.IsTransparent())
 {
     Init();
 
-    m_red = brush.GetColour().Red()/255.0;
-    m_green = brush.GetColour().Green()/255.0;
-    m_blue = brush.GetColour().Blue()/255.0;
-    m_alpha = brush.GetColour().Alpha()/255.0;
-    /*
-    if ( brush.GetStyle() == wxBRUSHSTYLE_SOLID)
-    {
-    m_brush = new SolidBrush( Color( brush.GetColour().Alpha() , brush.GetColour().Red() ,
-    brush.GetColour().Green() , brush.GetColour().Blue() ) );
-    }
-    else if ( brush.IsHatch() )
-    {
-    HatchStyle style = HatchStyleHorizontal;
-    switch( brush.GetStyle() )
-    {
-    case wxBRUSHSTYLE_BDIAGONAL_HATCH :
-    style = HatchStyleBackwardDiagonal;
-    break ;
-    case wxBRUSHSTYLE_CROSSDIAG_HATCH :
-    style = HatchStyleDiagonalCross;
-    break ;
-    case wxBRUSHSTYLE_FDIAGONAL_HATCH :
-    style = HatchStyleForwardDiagonal;
-    break ;
-    case wxBRUSHSTYLE_CROSS_HATCH :
-    style = HatchStyleCross;
-    break ;
-    case wxBRUSHSTYLE_HORIZONTAL_HATCH :
-    style = HatchStyleHorizontal;
-    break ;
-    case wxBRUSHSTYLE_VERTICAL_HATCH :
-    style = HatchStyleVertical;
-    break ;
-
-    }
-    m_brush = new HatchBrush(style,Color( brush.GetColour().Alpha() , brush.GetColour().Red() ,
-    brush.GetColour().Green() , brush.GetColour().Blue() ), Color.Transparent );
-    }
-    else
+    switch ( brush.GetStyle() )
     {
-    wxBitmap* bmp = brush.GetStipple();
-    if ( bmp && bmp->Ok() )
-    {
-    wxDELETE( m_brushImage );
-    m_brushImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),(HPALETTE)bmp->GetPalette()->GetHPALETTE());
-    m_brush = new TextureBrush(m_brushImage);
-    }
-    }
-    */
-}
-
-wxCairoBrushData::~wxCairoBrushData ()
-{
-    if (m_brushPattern)
-        cairo_pattern_destroy(m_brushPattern);
-}
+        case wxBRUSHSTYLE_STIPPLE:
+        case wxBRUSHSTYLE_STIPPLE_MASK:
+        case wxBRUSHSTYLE_STIPPLE_MASK_OPAQUE:
+            InitStipple(brush.GetStipple());
+            break;
 
-void wxCairoBrushData::Apply( wxGraphicsContext* context )
-{
-    cairo_t * ctext = (cairo_t*) context->GetNativeContext();
-    if ( m_brushPattern )
-    {
-        cairo_set_source(ctext,m_brushPattern);
-    }
-    else
-    {
-        cairo_set_source_rgba(ctext,m_red,m_green, m_blue,m_alpha);
+        default:
+            if ( brush.IsHatch() )
+                InitHatch(static_cast<wxHatchStyle>(brush.GetStyle()));
+            break;
     }
 }
 
@@ -701,7 +842,7 @@ void wxCairoBrushData::AddGradientStops(const wxGraphicsGradientStops& stops)
 
         cairo_pattern_add_color_stop_rgba
         (
-            m_brushPattern,
+            m_pattern,
             stop.GetPosition(),
             col.Red()/255.0,
             col.Green()/255.0,
@@ -710,7 +851,7 @@ void wxCairoBrushData::AddGradientStops(const wxGraphicsGradientStops& stops)
         );
     }
 
-    wxASSERT_MSG(cairo_pattern_status(m_brushPattern) == CAIRO_STATUS_SUCCESS,
+    wxASSERT_MSG(cairo_pattern_status(m_pattern) == CAIRO_STATUS_SUCCESS,
                  wxT("Couldn't create cairo pattern"));
 }
 
@@ -719,7 +860,7 @@ wxCairoBrushData::CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
                                             wxDouble x2, wxDouble y2,
                                             const wxGraphicsGradientStops& stops)
 {
-    m_brushPattern = cairo_pattern_create_linear(x1,y1,x2,y2);
+    m_pattern = cairo_pattern_create_linear(x1,y1,x2,y2);
 
     AddGradientStops(stops);
 }
@@ -730,64 +871,132 @@ wxCairoBrushData::CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
                                             wxDouble radius,
                                             const wxGraphicsGradientStops& stops)
 {
-    m_brushPattern = cairo_pattern_create_radial(xo,yo,0.0,xc,yc,radius);
+    m_pattern = cairo_pattern_create_radial(xo,yo,0.0,xc,yc,radius);
 
     AddGradientStops(stops);
 }
 
 void wxCairoBrushData::Init()
 {
-    m_brushPattern = NULL;
+    m_pattern = NULL;
+    m_bmpdata = NULL;
 }
 
 //-----------------------------------------------------------------------------
 // wxCairoFontData implementation
 //-----------------------------------------------------------------------------
 
-wxCairoFontData::wxCairoFontData( wxGraphicsRenderer* renderer, const wxFont &font,
-                         const wxColour& col ) : wxGraphicsObjectRefData(renderer)
+void wxCairoFontData::InitColour(const wxColour& col)
 {
     m_red = col.Red()/255.0;
     m_green = col.Green()/255.0;
     m_blue = col.Blue()/255.0;
     m_alpha = col.Alpha()/255.0;
+}
+
+void
+wxCairoFontData::InitFontComponents(const wxString& facename,
+                                    cairo_font_slant_t slant,
+                                    cairo_font_weight_t weight)
+{
+    m_fontName = facename.mb_str(wxConvUTF8);
+    m_slant = slant;
+    m_weight = weight;
+}
+
+wxCairoFontData::wxCairoFontData( wxGraphicsRenderer* renderer, const wxFont &font,
+                         const wxColour& col )
+    : wxGraphicsObjectRefData(renderer)
+#ifdef __WXGTK__
+    , m_wxfont(font)
+#endif
+{
+    InitColour(col);
+
     m_size = font.GetPointSize();
-    m_underlined = font.GetUnderlined();
 
 #ifdef __WXMAC__
     m_font = cairo_quartz_font_face_create_for_cgfont( font.OSXGetCGFont() );
 #elif defined(__WXGTK__)
-    m_font = pango_font_description_copy( font.GetNativeFontInfo()->description );
 #else
-    m_fontName = font.GetFaceName().mb_str(wxConvUTF8);
-    m_slant = font.GetStyle() == wxFONTSTYLE_ITALIC ? CAIRO_FONT_SLANT_ITALIC:CAIRO_FONT_SLANT_NORMAL;
-    m_weight = font.GetWeight() == wxFONTWEIGHT_BOLD ? CAIRO_FONT_WEIGHT_BOLD:CAIRO_FONT_WEIGHT_NORMAL;
+    InitFontComponents
+    (
+        font.GetFaceName(),
+        font.GetStyle() == wxFONTSTYLE_ITALIC ? CAIRO_FONT_SLANT_ITALIC
+                                              : CAIRO_FONT_SLANT_NORMAL,
+        font.GetWeight() == wxFONTWEIGHT_BOLD ? CAIRO_FONT_WEIGHT_BOLD
+                                              : CAIRO_FONT_WEIGHT_NORMAL
+    );
 #endif
 }
 
+wxCairoFontData::wxCairoFontData(wxGraphicsRenderer* renderer,
+                                 double sizeInPixels,
+                                 const wxString& facename,
+                                 int flags,
+                                 const wxColour& col) :
+    wxGraphicsObjectRefData(renderer)
+{
+    InitColour(col);
+
+    // Resolution for Cairo image surfaces is 72 DPI meaning that the sizes in
+    // points and pixels are identical, so we can just pass the size in pixels
+    // directly to cairo_set_font_size().
+    m_size = sizeInPixels;
+
+#if defined(__WXMAC__)
+    m_font = NULL;
+#endif
+
+    // There is no need to set m_underlined under wxGTK in this case, it can
+    // only be used if m_font != NULL.
+
+    InitFontComponents
+    (
+        facename,
+        flags & wxFONTFLAG_ITALIC ? CAIRO_FONT_SLANT_ITALIC
+                                  : CAIRO_FONT_SLANT_NORMAL,
+        flags & wxFONTFLAG_BOLD ? CAIRO_FONT_WEIGHT_BOLD
+                                : CAIRO_FONT_WEIGHT_NORMAL
+    );
+}
+
 wxCairoFontData::~wxCairoFontData()
 {
 #ifdef __WXMAC__
-    cairo_font_face_destroy( m_font );
-#elif defined(__WXGTK__)
-    pango_font_description_free( m_font );
-#else
+    if ( m_font )
+        cairo_font_face_destroy( m_font );
 #endif
 }
 
-void wxCairoFontData::Apply( wxGraphicsContext* context )
+bool wxCairoFontData::Apply( wxGraphicsContext* context )
 {
     cairo_t * ctext = (cairo_t*) context->GetNativeContext();
     cairo_set_source_rgba(ctext,m_red,m_green, m_blue,m_alpha);
 #ifdef __WXGTK__
-    // the rest is done using Pango layouts
+    if (m_wxfont.IsOk())
+    {
+        // Nothing to do, the caller uses Pango layout functions to do
+        // everything.
+        return true;
+    }
 #elif defined(__WXMAC__)
-    cairo_set_font_face(ctext, m_font);
-    cairo_set_font_size(ctext, m_size );
-#else
-    cairo_select_font_face(ctext, m_fontName, m_slant, m_weights );
-    cairo_set_font_size(ctext, m_size );
+    if ( m_font )
+    {
+        cairo_set_font_face(ctext, m_font);
+        cairo_set_font_size(ctext, m_size );
+        return true;
+    }
 #endif
+
+    // If we get here, we must be on a platform without native font support or
+    // we're using toy Cairo API even under wxGTK/wxMac.
+    cairo_select_font_face(ctext, m_fontName, m_slant, m_weight );
+    cairo_set_font_size(ctext, m_size );
+
+    // Indicate that we don't use native fonts for the platforms which care
+    // about this (currently only wxGTK).
+    return false;
 }
 
 //-----------------------------------------------------------------------------
@@ -1057,41 +1266,90 @@ void * wxCairoMatrixData::GetNativeMatrix() const
     return (void*) &m_matrix;
 }
 
+// ----------------------------------------------------------------------------
 // wxCairoBitmap implementation
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+int wxCairoBitmapData::InitBuffer(int width, int height, cairo_format_t format)
+{
+    wxUnusedVar(format); // Only really unused with Cairo < 1.6.
+
+    // Determine the stride: use cairo_format_stride_for_width() if available
+    // but fall back to 4*width for the earlier versions as this is what that
+    // function always returns, even in latest Cairo, anyhow.
+    int stride;
+#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 6, 0)
+    if ( cairo_version() >= CAIRO_VERSION_ENCODE(1, 6, 0) )
+    {
+        stride = cairo_format_stride_for_width(format, width);
+
+        // All our code would totally break if stride were not a multiple of 4
+        // so ensure this is the case.
+        if ( stride % 4 )
+        {
+            wxFAIL_MSG("Unexpected Cairo image surface stride.");
+
+            stride += 4 - stride % 4;
+        }
+    }
+    else
+#endif
+        stride = 4*width;
+
+    m_width = width;
+    m_height = height;
+    m_buffer = new unsigned char[height*stride];
+
+    return stride;
+}
+
+void wxCairoBitmapData::InitSurface(cairo_format_t format, int stride)
+{
+    m_surface = cairo_image_surface_create_for_data(
+                            m_buffer, format, m_width, m_height, stride);
+    m_pattern = cairo_pattern_create_for_surface(m_surface);
+}
 
 wxCairoBitmapData::wxCairoBitmapData( wxGraphicsRenderer* renderer, cairo_surface_t* bitmap ) :
-    wxGraphicsObjectRefData( renderer )
+    wxGraphicsBitmapData( renderer )
 {
     m_surface = bitmap;
     m_pattern = cairo_pattern_create_for_surface(m_surface);
 }
 
-wxCairoBitmapData::wxCairoBitmapData( wxGraphicsRenderer* renderer, const wxBitmap& bmp ) : wxGraphicsObjectRefData( renderer )
+wxCairoBitmapData::wxCairoBitmapData( wxGraphicsRenderer* renderer, const wxBitmap& bmp ) : wxGraphicsBitmapData( renderer )
 {
     wxCHECK_RET( bmp.IsOk(), wxT("Invalid bitmap in wxCairoContext::DrawBitmap"));
 
-    int bw = m_width = bmp.GetWidth();
-    int bh = m_height = bmp.GetHeight();
-    wxBitmap bmpSource = bmp;  // we need a non-const instance
-    m_buffer = new unsigned char[bw*bh*4];
-    wxUint32* data = (wxUint32*)m_buffer;
-
+#ifdef wxHAS_RAW_BITMAP
     // Create a surface object and copy the bitmap pixel data to it.  if the
     // image has alpha (or a mask represented as alpha) then we'll use a
     // different format and iterator than if it doesn't...
-    if (bmpSource.HasAlpha() || bmpSource.GetMask())
+    cairo_format_t bufferFormat = bmp.GetDepth() == 32
+#if defined(__WXGTK__) && !defined(__WXGTK3__)
+                                            || bmp.GetMask()
+#endif
+                                        ? CAIRO_FORMAT_ARGB32
+                                        : CAIRO_FORMAT_RGB24;
+
+    int stride = InitBuffer(bmp.GetWidth(), bmp.GetHeight(), bufferFormat);
+
+    wxBitmap bmpSource = bmp;  // we need a non-const instance
+    wxUint32* data = (wxUint32*)m_buffer;
+
+    if ( bufferFormat == CAIRO_FORMAT_ARGB32 )
     {
-        m_surface = cairo_image_surface_create_for_data(
-            m_buffer, CAIRO_FORMAT_ARGB32, bw, bh, bw*4);
-        wxAlphaPixelData pixData(bmpSource, wxPoint(0,0), wxSize(bw, bh));
+        // use the bitmap's alpha
+        wxAlphaPixelData
+            pixData(bmpSource, wxPoint(0, 0), wxSize(m_width, m_height));
         wxCHECK_RET( pixData, wxT("Failed to gain raw access to bitmap data."));
 
         wxAlphaPixelData::Iterator p(pixData);
-        for (int y=0; y<bh; y++)
+        for (int y=0; y<m_height; y++)
         {
             wxAlphaPixelData::Iterator rowStart = p;
-            for (int x=0; x<bw; x++)
+            wxUint32* const rowStartDst = data;
+            for (int x=0; x<m_width; x++)
             {
                 // Each pixel in CAIRO_FORMAT_ARGB32 is a 32-bit quantity,
                 // with alpha in the upper 8 bits, then red, then green, then
@@ -1108,22 +1366,24 @@ wxCairoBitmapData::wxCairoBitmapData( wxGraphicsRenderer* renderer, const wxBitm
                 ++data;
                 ++p;
             }
+
+            data = rowStartDst + stride / 4;
             p = rowStart;
             p.OffsetY(pixData, 1);
         }
     }
     else  // no alpha
     {
-        m_surface = cairo_image_surface_create_for_data(
-            m_buffer, CAIRO_FORMAT_RGB24, bw, bh, bw*4);
-        wxNativePixelData pixData(bmpSource, wxPoint(0,0), wxSize(bw, bh));
+        wxNativePixelData
+            pixData(bmpSource, wxPoint(0, 0), wxSize(m_width, m_height));
         wxCHECK_RET( pixData, wxT("Failed to gain raw access to bitmap data."));
 
         wxNativePixelData::Iterator p(pixData);
-        for (int y=0; y<bh; y++)
+        for (int y=0; y<m_height; y++)
         {
             wxNativePixelData::Iterator rowStart = p;
-            for (int x=0; x<bw; x++)
+            wxUint32* const rowStartDst = data;
+            for (int x=0; x<m_width; x++)
             {
                 // Each pixel in CAIRO_FORMAT_RGB24 is a 32-bit quantity, with
                 // the upper 8 bits unused. Red, Green, and Blue are stored in
@@ -1133,13 +1393,218 @@ wxCairoBitmapData::wxCairoBitmapData( wxGraphicsRenderer* renderer, const wxBitm
                 ++data;
                 ++p;
             }
+
+            data = rowStartDst + stride / 4;
             p = rowStart;
             p.OffsetY(pixData, 1);
         }
     }
-    m_pattern = cairo_pattern_create_for_surface(m_surface);
+#if defined(__WXMSW__) || defined(__WXGTK3__)
+    // if there is a mask, set the alpha bytes in the target buffer to 
+    // fully transparent or fully opaque
+    if (bmpSource.GetMask())
+    {
+        wxBitmap bmpMask = bmpSource.GetMask()->GetBitmap();
+        bufferFormat = CAIRO_FORMAT_ARGB32;
+        data = (wxUint32*)m_buffer;
+        wxNativePixelData
+            pixData(bmpMask, wxPoint(0, 0), wxSize(m_width, m_height));
+        wxCHECK_RET( pixData, wxT("Failed to gain raw access to mask data."));
+
+        wxNativePixelData::Iterator p(pixData);
+        for (int y=0; y<m_height; y++)
+        {
+            wxNativePixelData::Iterator rowStart = p;
+            wxUint32* const rowStartDst = data;
+            for (int x=0; x<m_width; x++)
+            {
+                if (p.Red()+p.Green()+p.Blue() == 0)
+                    *data = 0;
+                else
+                    *data = (wxALPHA_OPAQUE << 24) | (*data & 0x00FFFFFF);
+                ++data;
+                ++p;
+            }
+
+            data = rowStartDst + stride / 4;
+            p = rowStart;
+            p.OffsetY(pixData, 1);
+        }
+    }
+#endif
+
+    InitSurface(bufferFormat, stride);
+#endif // wxHAS_RAW_BITMAP
+}
+
+#if wxUSE_IMAGE
+
+// Helper functions for dealing with alpha pre-multiplication.
+namespace
+{
+
+inline unsigned char Premultiply(unsigned char alpha, unsigned char data)
+{
+    return alpha ? (data * alpha)/0xff : data;
+}
+
+inline unsigned char Unpremultiply(unsigned char alpha, unsigned char data)
+{
+    return alpha ? (data * 0xff)/alpha : data;
+}
+
+} // anonymous namespace
+
+wxCairoBitmapData::wxCairoBitmapData(wxGraphicsRenderer* renderer,
+                                     const wxImage& image)
+    : wxGraphicsBitmapData(renderer)
+{
+    const cairo_format_t bufferFormat = image.HasAlpha()
+                                            ? CAIRO_FORMAT_ARGB32
+                                            : CAIRO_FORMAT_RGB24;
+
+    int stride = InitBuffer(image.GetWidth(), image.GetHeight(), bufferFormat);
+
+    // Copy wxImage data into the buffer. Notice that we work with wxUint32
+    // values and not bytes becase Cairo always works with buffers in native
+    // endianness.
+    wxUint32* dst = reinterpret_cast<wxUint32*>(m_buffer);
+    const unsigned char* src = image.GetData();
+
+    if ( bufferFormat == CAIRO_FORMAT_ARGB32 )
+    {
+        const unsigned char* alpha = image.GetAlpha();
+
+        for ( int y = 0; y < m_height; y++ )
+        {
+            wxUint32* const rowStartDst = dst;
+
+            for ( int x = 0; x < m_width; x++ )
+            {
+                const unsigned char a = *alpha++;
+
+                *dst++ = a                      << 24 |
+                         Premultiply(a, src[0]) << 16 |
+                         Premultiply(a, src[1]) <<  8 |
+                         Premultiply(a, src[2]);
+                src += 3;
+            }
+
+            dst = rowStartDst + stride / 4;
+        }
+    }
+    else // RGB
+    {
+        for ( int y = 0; y < m_height; y++ )
+        {
+            wxUint32* const rowStartDst = dst;
+
+            for ( int x = 0; x < m_width; x++ )
+            {
+                *dst++ = src[0] << 16 |
+                         src[1] <<  8 |
+                         src[2];
+                src += 3;
+            }
+
+            dst = rowStartDst + stride / 4;
+        }
+    }
+
+    InitSurface(bufferFormat, stride);
+}
+
+wxImage wxCairoBitmapData::ConvertToImage() const
+{
+    wxImage image(m_width, m_height, false /* don't clear */);
+
+    // Get the surface type and format.
+    wxCHECK_MSG( cairo_surface_get_type(m_surface) == CAIRO_SURFACE_TYPE_IMAGE,
+                 wxNullImage,
+                 wxS("Can't convert non-image surface to image.") );
+
+    switch ( cairo_image_surface_get_format(m_surface) )
+    {
+        case CAIRO_FORMAT_ARGB32:
+            image.SetAlpha();
+            break;
+
+        case CAIRO_FORMAT_RGB24:
+            // Nothing to do, we don't use alpha by default.
+            break;
+
+        case CAIRO_FORMAT_A8:
+        case CAIRO_FORMAT_A1:
+            wxFAIL_MSG(wxS("Unsupported Cairo image surface type."));
+            return wxNullImage;
+
+        default:
+            wxFAIL_MSG(wxS("Unknown Cairo image surface type."));
+            return wxNullImage;
+    }
+
+    // Prepare for copying data.
+    const wxUint32* src = (wxUint32*)cairo_image_surface_get_data(m_surface);
+    wxCHECK_MSG( src, wxNullImage, wxS("Failed to get Cairo surface data.") );
+
+    int stride = cairo_image_surface_get_stride(m_surface);
+    wxCHECK_MSG( stride > 0, wxNullImage,
+                 wxS("Failed to get Cairo surface stride.") );
+
+    // As we work with wxUint32 pointers and not char ones, we need to adjust
+    // the stride accordingly. This should be lossless as the stride must be a
+    // multiple of pixel size.
+    wxASSERT_MSG( !(stride % sizeof(wxUint32)), wxS("Unexpected stride.") );
+    stride /= sizeof(wxUint32);
+
+    unsigned char* dst = image.GetData();
+    unsigned char *alpha = image.GetAlpha();
+    if ( alpha )
+    {
+        // We need to also copy alpha and undo the pre-multiplication as Cairo
+        // stores pre-multiplied values in this format while wxImage does not.
+        for ( int y = 0; y < m_height; y++ )
+        {
+            const wxUint32* const rowStart = src;
+            for ( int x = 0; x < m_width; x++ )
+            {
+                const wxUint32 argb = *src++;
+
+                *alpha++ = (argb & 0xff000000) >> 24;
+
+                // Copy the RGB data undoing the pre-multiplication.
+                *dst++ = Unpremultiply(*alpha, (argb & 0x00ff0000) >> 16);
+                *dst++ = Unpremultiply(*alpha, (argb & 0x0000ff00) >>  8);
+                *dst++ = Unpremultiply(*alpha, (argb & 0x000000ff));
+            }
+
+            src = rowStart + stride;
+        }
+    }
+    else // RGB
+    {
+        // Things are pretty simple in this case, just copy RGB bytes.
+        for ( int y = 0; y < m_height; y++ )
+        {
+            const wxUint32* const rowStart = src;
+            for ( int x = 0; x < m_width; x++ )
+            {
+                const wxUint32 argb = *src++;
+
+                *dst++ = (argb & 0x00ff0000) >> 16;
+                *dst++ = (argb & 0x0000ff00) >>  8;
+                *dst++ = (argb & 0x000000ff);
+            }
+
+            src = rowStart + stride;
+        }
+    }
+
+    return image;
 }
 
+#endif // wxUSE_IMAGE
+
 wxCairoBitmapData::~wxCairoBitmapData()
 {
     if (m_pattern)
@@ -1151,8 +1616,6 @@ wxCairoBitmapData::~wxCairoBitmapData()
     delete [] m_buffer;
 }
 
-
-
 //-----------------------------------------------------------------------------
 // wxCairoContext implementation
 //-----------------------------------------------------------------------------
@@ -1180,26 +1643,66 @@ public :
 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, const wxPrinterDC& dc )
 : wxGraphicsContext(renderer)
 {
+#ifdef __WXMSW__
+    // wxMSW contexts always use MM_ANISOTROPIC, which messes up 
+    // text rendering when printing using Cairo. Switch it to MM_TEXT
+    // map mode to avoid this problem.
+    HDC hdc = (HDC)dc.GetHDC();
+    ::SetMapMode(hdc, MM_TEXT);
+    m_mswSurface = cairo_win32_printing_surface_create(hdc);
+    Init( cairo_create(m_mswSurface) );
+#endif
+
 #ifdef __WXGTK20__
     const wxDCImpl *impl = dc.GetImpl();
     Init( (cairo_t*) impl->GetCairoContext() );
+#endif
+    wxSize sz = dc.GetSize();
+    m_width = sz.x;
+    m_height = sz.y;
 
     wxPoint org = dc.GetDeviceOrigin();
     cairo_translate( m_context, org.x, org.y );
 
     double sx,sy;
     dc.GetUserScale( &sx, &sy );
+
+// TODO: Determine if these fixes are needed on other platforms too.
+// On MSW, without this the printer context will not respect wxDC SetMapMode calls.
+// For example, using dc.SetMapMode(wxMM_POINTS) can let us share printer and screen
+// drawing code
+#ifdef __WXMSW__
+    double lsx,lsy;
+    dc.GetLogicalScale( &lsx, &lsy );
+    sx *= lsx;
+    sy *= lsy;
+#endif
     cairo_scale( m_context, sx, sy );
 
     org = dc.GetLogicalOrigin();
     cairo_translate( m_context, -org.x, -org.y );
-#endif
 }
 
 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, const wxWindowDC& dc )
 : wxGraphicsContext(renderer)
 {
-#ifdef __WXGTK20__
+    int width, height;
+    dc.GetSize( &width, &height );
+    m_width = width;
+    m_height = height;
+
+    m_enableOffset = true;
+
+#ifdef __WXMSW__
+    m_mswSurface = cairo_win32_surface_create((HDC)dc.GetHDC());
+    Init( cairo_create(m_mswSurface) );
+#endif
+
+#ifdef __WXGTK3__
+    cairo_t* cr = static_cast<cairo_t*>(dc.GetImpl()->GetCairoContext());
+    if (cr)
+        Init(cr);
+#elif defined __WXGTK20__
     wxGTKDCImpl *impldc = (wxGTKDCImpl*) dc.GetImpl();
     Init( gdk_cairo_create( impldc->GetGDKWindow() ) );
 
@@ -1221,8 +1724,6 @@ wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, const wxWindowDC&
 #endif
 
 #ifdef __WXMAC__
-    int width, height;
-    dc.GetSize( &width, &height );
     CGContextRef cgcontext = (CGContextRef)dc.GetWindow()->MacGetCGContextRef();
     cairo_surface_t* surface = cairo_quartz_surface_create_for_cg_context(cgcontext, width, height);
     Init( cairo_create( surface ) );
@@ -1233,7 +1734,50 @@ wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, const wxWindowDC&
 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, const wxMemoryDC& dc )
 : wxGraphicsContext(renderer)
 {
-#ifdef __WXGTK20__
+    int width, height;
+    dc.GetSize( &width, &height );
+    m_width = width;
+    m_height = height;
+
+    m_enableOffset = true;
+
+#ifdef __WXMSW__
+
+    HDC hdc = (HDC)dc.GetHDC();
+
+    HBITMAP bitmap = (HBITMAP)GetCurrentObject(hdc, OBJ_BITMAP);
+
+    BITMAP info;
+    bool hasBitmap = false;
+
+    // cairo_win32_surface_create creates a 24-bit bitmap,
+    // so if we have alpha, we need to create a 32-bit surface instead.
+    if (!GetObject(bitmap, sizeof(info), &info) || info.bmBitsPixel < 32)
+        m_mswSurface = cairo_win32_surface_create(hdc);
+    else {
+        hasBitmap = true;
+        m_mswSurface = cairo_image_surface_create_for_data((unsigned char*)info.bmBits,
+                                               CAIRO_FORMAT_ARGB32,
+                                               info.bmWidth,
+                                               info.bmHeight,
+                                               info.bmWidthBytes);
+    }
+
+    Init( cairo_create(m_mswSurface) );
+    // If we've created a image surface, we need to flip the Y axis so that 
+    // all drawing will appear right side up.
+    if (hasBitmap) {
+        cairo_matrix_t matrix;
+        cairo_matrix_init(&matrix, 1.0, 0.0, 0.0, -1.0, 0.0, height);
+        cairo_set_matrix(m_context, &matrix);
+    }
+#endif
+    
+#ifdef __WXGTK3__
+    cairo_t* cr = static_cast<cairo_t*>(dc.GetImpl()->GetCairoContext());
+    if (cr)
+        Init(cr);
+#elif defined __WXGTK20__
     wxGTKDCImpl *impldc = (wxGTKDCImpl*) dc.GetImpl();
     Init( gdk_cairo_create( impldc->GetGDKWindow() ) );
 
@@ -1255,8 +1799,6 @@ wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, const wxMemoryDC&
 #endif
 
 #ifdef __WXMAC__
-    int width, height;
-    dc.GetSize( &width, &height );
     CGContextRef cgcontext = (CGContextRef)dc.GetWindow()->MacGetCGContextRef();
     cairo_surface_t* surface = cairo_quartz_surface_create_for_cg_context(cgcontext, width, height);
     Init( cairo_create( surface ) );
@@ -1265,10 +1807,20 @@ wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, const wxMemoryDC&
 }
 
 #ifdef __WXGTK20__
-wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, GdkDrawable *drawable )
+wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, GdkWindow *window )
 : wxGraphicsContext(renderer)
 {
-    Init( gdk_cairo_create( drawable ) );
+    Init( gdk_cairo_create( window ) );
+
+#ifdef __WXGTK3__
+    m_width = gdk_window_get_width(window);
+    m_height = gdk_window_get_height(window);
+#else
+    int width, height;
+    gdk_drawable_get_size(window, &width, &height);
+    m_width = width;
+    m_height = height;
+#endif
 }
 #endif
 
@@ -1277,9 +1829,9 @@ wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, HDC handle )
 : wxGraphicsContext(renderer)
 {
     m_mswSurface = cairo_win32_surface_create(handle);
-    m_context = cairo_create(m_mswSurface);
-    PushState();
-    PushState();
+    Init( cairo_create(m_mswSurface) );
+    m_width =
+    m_height = 0;
 }
 #endif
 
@@ -1288,11 +1840,17 @@ wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, cairo_t *context )
 : wxGraphicsContext(renderer)
 {
     Init( context );
+    m_width =
+    m_height = 0;
 }
 
 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, wxWindow *window)
-: wxGraphicsContext(renderer)
+    : wxGraphicsContext(renderer)
+#ifdef __WXMSW__
+    , m_mswWindowHDC(GetHwndOf(window))
+#endif
 {
+    m_enableOffset = true;    
 #ifdef __WXGTK__
     // something along these lines (copied from dcclient)
 
@@ -1307,7 +1865,23 @@ wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, wxWindow *window)
     wxASSERT_MSG( window->m_wxwindow, wxT("wxCairoContext needs a widget") );
 
     Init(gdk_cairo_create(window->GTKGetDrawingWindow()));
+
+    wxSize sz = window->GetSize();
+    m_width = sz.x;
+    m_height = sz.y;
+#endif
+
+#ifdef __WXMSW__
+    m_mswSurface = cairo_win32_surface_create((HDC)m_mswWindowHDC);
+    Init(cairo_create(m_mswSurface));
 #endif
+
+}
+
+wxCairoContext::wxCairoContext(wxGraphicsRenderer* renderer) :
+    wxGraphicsContext(renderer)
+{
+    m_context = NULL;
 }
 
 wxCairoContext::~wxCairoContext()
@@ -1315,10 +1889,6 @@ wxCairoContext::~wxCairoContext()
     if ( m_context )
     {
         PopState();
-#ifdef __WXMSW__
-    m_mswSurface = cairo_win32_surface_create((HDC)window->GetHandle());
-    m_context = cairo_create(m_mswSurface);
-#endif
         PopState();
         cairo_destroy(m_context);
     }
@@ -1505,30 +2075,25 @@ void wxCairoContext::DoDrawText(const wxString& str, wxDouble x, wxDouble y)
     if ( !data )
         return;
 
-    ((wxCairoFontData*)m_font.GetRefData())->Apply(this);
-
+    if ( ((wxCairoFontData*)m_font.GetRefData())->Apply(this) )
+    {
 #ifdef __WXGTK__
-    size_t datalen = strlen(data);
+        PangoLayout *layout = pango_cairo_create_layout (m_context);
+        const wxFont& font = static_cast<wxCairoFontData*>(m_font.GetRefData())->GetFont();
+        pango_layout_set_font_description(layout, font.GetNativeFontInfo()->description);
+        pango_layout_set_text(layout, data, data.length());
+        font.GTKSetPangoAttrs(layout);
 
-    PangoLayout *layout = pango_cairo_create_layout (m_context);
-    wxCairoFontData* font_data = (wxCairoFontData*) m_font.GetRefData();
-    pango_layout_set_font_description( layout, font_data->GetFont());
-    pango_layout_set_text(layout, data, datalen);
+        cairo_move_to(m_context, x, y);
+        pango_cairo_show_layout (m_context, layout);
 
-    if (font_data->GetUnderlined())
-    {
-        PangoAttrList *attrs = pango_attr_list_new();
-        PangoAttribute *attr = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
-        pango_attr_list_insert(attrs, attr);
-        pango_layout_set_attributes(layout, attrs);
-        pango_attr_list_unref(attrs);
-    }
+        g_object_unref (layout);
 
-    cairo_move_to(m_context, x, y);
-    pango_cairo_show_layout (m_context, layout);
+        // Don't use Cairo text API, we already did everything.
+        return;
+#endif
+    }
 
-    g_object_unref (layout);
-#else
     // Cairo's x,y for drawing text is at the baseline, so we need to adjust
     // the position we move to by the ascent.
     cairo_font_extents_t fe;
@@ -1536,7 +2101,6 @@ void wxCairoContext::DoDrawText(const wxString& str, wxDouble x, wxDouble y)
     cairo_move_to(m_context, x, y+fe.ascent);
 
     cairo_show_text(m_context, data);
-#endif
 }
 
 void wxCairoContext::GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height,
@@ -1556,32 +2120,36 @@ void wxCairoContext::GetTextExtent( const wxString &str, wxDouble *width, wxDoub
     if ( str.empty())
         return;
 
+    if ( ((wxCairoFontData*)m_font.GetRefData())->Apply((wxCairoContext*)this) )
+    {
 #ifdef __WXGTK__
-    int w, h;
+        int w, h;
 
-    PangoLayout *layout = pango_cairo_create_layout (m_context);
-    pango_layout_set_font_description( layout, ((wxCairoFontData*)m_font.GetRefData())->GetFont());
-    const wxCharBuffer data = str.utf8_str();
-    if ( !data )
-    {
+        PangoLayout *layout = pango_cairo_create_layout (m_context);
+        const wxFont& font = static_cast<wxCairoFontData*>(m_font.GetRefData())->GetFont();
+        pango_layout_set_font_description(layout, font.GetNativeFontInfo()->description);
+        const wxCharBuffer data = str.utf8_str();
+        if ( !data )
+        {
+            return;
+        }
+        pango_layout_set_text(layout, data, data.length());
+        pango_layout_get_pixel_size (layout, &w, &h);
+        if ( width )
+            *width = w;
+        if ( height )
+            *height = h;
+        if (descent)
+        {
+            PangoLayoutIter *iter = pango_layout_get_iter(layout);
+            int baseline = pango_layout_iter_get_baseline(iter);
+            pango_layout_iter_free(iter);
+            *descent = h - PANGO_PIXELS(baseline);
+        }
+        g_object_unref (layout);
         return;
+#endif
     }
-    pango_layout_set_text( layout, data, strlen(data) );
-    pango_layout_get_pixel_size (layout, &w, &h);
-    if ( width )
-        *width = w;
-    if ( height )
-        *height = h;
-    if (descent)
-    {
-        PangoLayoutIter *iter = pango_layout_get_iter(layout);
-        int baseline = pango_layout_iter_get_baseline(iter);
-        pango_layout_iter_free(iter);
-        *descent = h - PANGO_PIXELS(baseline);
-    }
-    g_object_unref (layout);
-#else
-    ((wxCairoFontData*)m_font.GetRefData())->Apply((wxCairoContext*)this);
 
     if (width)
     {
@@ -1614,20 +2182,38 @@ void wxCairoContext::GetTextExtent( const wxString &str, wxDouble *width, wxDoub
         if ( externalLeading )
             *externalLeading = wxMax(0, fe.height - (fe.ascent + fe.descent));
     }
-#endif
 }
 
 void wxCairoContext::GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const
 {
     widths.Empty();
-    widths.Add(0, text.length());
-
     wxCHECK_RET( !m_font.IsNull(), wxT("wxCairoContext::GetPartialTextExtents - no valid font set") );
-
-    if (text.empty())
-        return;
-
+#ifdef __WXGTK__
+    const wxCharBuffer data = text.utf8_str();
+    int w = 0;
+    if (data.length())
+    {
+        PangoLayout* layout = pango_cairo_create_layout(m_context);
+        const wxFont& font = static_cast<wxCairoFontData*>(m_font.GetRefData())->GetFont();
+        pango_layout_set_font_description(layout, font.GetNativeFontInfo()->description);
+        pango_layout_set_text(layout, data, data.length());
+        PangoLayoutIter* iter = pango_layout_get_iter(layout);
+        PangoRectangle rect;
+        do {
+            pango_layout_iter_get_cluster_extents(iter, NULL, &rect);
+            w += rect.width;
+            widths.Add(PANGO_PIXELS(w));
+        } while (pango_layout_iter_next_cluster(iter));
+        pango_layout_iter_free(iter);
+        g_object_unref(layout);
+    }
+    size_t i = widths.GetCount();
+    const size_t len = text.length();
+    while (i++ < len)
+        widths.Add(PANGO_PIXELS(w));
+#else
     // TODO
+#endif
 }
 
 void * wxCairoContext::GetNativeContext()
@@ -1658,6 +2244,12 @@ bool wxCairoContext::SetAntialiasMode(wxAntialiasMode antialias)
     return true;
 }
 
+bool wxCairoContext::SetInterpolationQuality(wxInterpolationQuality WXUNUSED(interpolation))
+{
+    // placeholder
+    return false;
+}
+
 bool wxCairoContext::SetCompositionMode(wxCompositionMode op)
 {
     if ( m_composition == op )
@@ -1747,11 +2339,18 @@ public :
     virtual wxGraphicsContext * CreateContextFromNativeContext( void * context );
 
     virtual wxGraphicsContext * CreateContextFromNativeWindow( void * window );
+#if wxUSE_IMAGE
+    virtual wxGraphicsContext * CreateContextFromImage(wxImage& image);
+#endif // wxUSE_IMAGE
 
     virtual wxGraphicsContext * CreateContext( wxWindow* window );
 
     virtual wxGraphicsContext * CreateMeasuringContext();
-
+#ifdef __WXMSW__
+#if wxUSE_ENH_METAFILE
+    virtual wxGraphicsContext * CreateContext( const wxEnhMetaFileDC& dc);
+#endif
+#endif
     // Path
 
     virtual wxGraphicsPath CreatePath();
@@ -1779,9 +2378,17 @@ public :
 
     // sets the font
     virtual wxGraphicsFont CreateFont( const wxFont &font , const wxColour &col = *wxBLACK ) ;
+    virtual wxGraphicsFont CreateFont(double sizeInPixels,
+                                      const wxString& facename,
+                                      int flags = wxFONTFLAG_DEFAULT,
+                                      const wxColour& col = *wxBLACK);
 
     // 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
 
     // create a graphics bitmap from a native bitmap
     virtual wxGraphicsBitmap CreateBitmapFromNativeBitmap( void* bitmap );
@@ -1789,7 +2396,6 @@ public :
     // create a subimage from a native image representation
     virtual wxGraphicsBitmap CreateSubBitmap( const wxGraphicsBitmap &bitmap, wxDouble x, wxDouble y, wxDouble w, wxDouble h  );
 
-private :
     DECLARE_DYNAMIC_CLASS_NO_COPY(wxCairoRenderer)
 } ;
 
@@ -1800,38 +2406,48 @@ private :
 IMPLEMENT_DYNAMIC_CLASS(wxCairoRenderer,wxGraphicsRenderer)
 
 static wxCairoRenderer gs_cairoGraphicsRenderer;
-// temporary hack to allow creating a cairo context on any platform
-extern wxGraphicsRenderer* gCairoRenderer;
-wxGraphicsRenderer* gCairoRenderer = &gs_cairoGraphicsRenderer;
+
+#ifdef __WXGTK__
+    #define ENSURE_LOADED_OR_RETURN(returnOnFail)
+#else
+    #define ENSURE_LOADED_OR_RETURN(returnOnFail)  \
+        if (!wxCairoInit())                        \
+            return returnOnFail
+#endif
 
 wxGraphicsContext * wxCairoRenderer::CreateContext( const wxWindowDC& dc)
 {
+    ENSURE_LOADED_OR_RETURN(NULL);
     return new wxCairoContext(this,dc);
 }
 
 wxGraphicsContext * wxCairoRenderer::CreateContext( const wxMemoryDC& dc)
 {
+    ENSURE_LOADED_OR_RETURN(NULL);
     return new wxCairoContext(this,dc);
 }
 
 wxGraphicsContext * wxCairoRenderer::CreateContext( const wxPrinterDC& dc)
 {
-#ifdef __WXGTK20__
-    const wxDCImpl *impl = dc.GetImpl();
-    cairo_t* context = (cairo_t*) impl->GetCairoContext();
-    if (context)
-       return new wxCairoContext(this,dc);
-    else
-#endif
-       return NULL;
+    ENSURE_LOADED_OR_RETURN(NULL);
+    return new wxCairoContext(this, dc);
+}
+
+#ifdef __WXMSW__
+#if wxUSE_ENH_METAFILE
+wxGraphicsContext * wxCairoRenderer::CreateContext( const wxEnhMetaFileDC& WXUNUSED(dc) )
+{
+    return NULL;
 }
+#endif
+#endif
 
 wxGraphicsContext * wxCairoRenderer::CreateContextFromNativeContext( void * context )
 {
+    ENSURE_LOADED_OR_RETURN(NULL);
 #ifdef __WXMSW__
     return new wxCairoContext(this,(HDC)context);
-#endif
-#ifdef __WXGTK__
+#else
     return new wxCairoContext(this,(cairo_t*)context);
 #endif
 }
@@ -1840,23 +2456,34 @@ wxGraphicsContext * wxCairoRenderer::CreateContextFromNativeContext( void * cont
 wxGraphicsContext * wxCairoRenderer::CreateContextFromNativeWindow( void * window )
 {
 #ifdef __WXGTK__
-    return new wxCairoContext(this,(GdkDrawable*)window);
+    return new wxCairoContext(this, static_cast<GdkWindow*>(window));
 #else
+    wxUnusedVar(window);
     return NULL;
 #endif
 }
 
+#if wxUSE_IMAGE
+wxGraphicsContext * wxCairoRenderer::CreateContextFromImage(wxImage& image)
+{
+    ENSURE_LOADED_OR_RETURN(NULL);
+    return new wxCairoImageContext(this, image);
+}
+#endif // wxUSE_IMAGE
+
 wxGraphicsContext * wxCairoRenderer::CreateMeasuringContext()
 {
 #ifdef __WXGTK__
     return CreateContextFromNativeWindow(gdk_get_default_root_window());
-#endif
+#else
     return NULL;
     // TODO
+#endif
 }
 
 wxGraphicsContext * wxCairoRenderer::CreateContext( wxWindow* window )
 {
+    ENSURE_LOADED_OR_RETURN(NULL);
     return new wxCairoContext(this, window );
 }
 
@@ -1865,6 +2492,7 @@ wxGraphicsContext * wxCairoRenderer::CreateContext( wxWindow* window )
 wxGraphicsPath wxCairoRenderer::CreatePath()
 {
     wxGraphicsPath path;
+    ENSURE_LOADED_OR_RETURN(path);
     path.SetRefData( new wxCairoPathData(this) );
     return path;
 }
@@ -1877,6 +2505,7 @@ wxGraphicsMatrix wxCairoRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDouble
 
 {
     wxGraphicsMatrix m;
+    ENSURE_LOADED_OR_RETURN(m);
     wxCairoMatrixData* data = new wxCairoMatrixData( this );
     data->Set( a,b,c,d,tx,ty ) ;
     m.SetRefData(data);
@@ -1885,26 +2514,24 @@ wxGraphicsMatrix wxCairoRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDouble
 
 wxGraphicsPen wxCairoRenderer::CreatePen(const wxPen& pen)
 {
-    if ( !pen.Ok() || pen.GetStyle() == wxPENSTYLE_TRANSPARENT )
-        return wxNullGraphicsPen;
-    else
+    wxGraphicsPen p;
+    ENSURE_LOADED_OR_RETURN(p);
+    if (pen.IsOk() && pen.GetStyle() != wxPENSTYLE_TRANSPARENT)
     {
-        wxGraphicsPen p;
         p.SetRefData(new wxCairoPenData( this, pen ));
-        return p;
     }
+    return p;
 }
 
 wxGraphicsBrush wxCairoRenderer::CreateBrush(const wxBrush& brush )
 {
-    if ( !brush.Ok() || brush.GetStyle() == wxBRUSHSTYLE_TRANSPARENT )
-        return wxNullGraphicsBrush;
-    else
+    wxGraphicsBrush p;
+    ENSURE_LOADED_OR_RETURN(p);
+    if (brush.IsOk() && brush.GetStyle() != wxBRUSHSTYLE_TRANSPARENT)
     {
-        wxGraphicsBrush p;
         p.SetRefData(new wxCairoBrushData( this, brush ));
-        return p;
     }
+    return p;
 }
 
 wxGraphicsBrush
@@ -1913,6 +2540,7 @@ wxCairoRenderer::CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
                                            const wxGraphicsGradientStops& stops)
 {
     wxGraphicsBrush p;
+    ENSURE_LOADED_OR_RETURN(p);
     wxCairoBrushData* d = new wxCairoBrushData( this );
     d->CreateLinearGradientBrush(x1, y1, x2, y2, stops);
     p.SetRefData(d);
@@ -1925,47 +2553,88 @@ wxCairoRenderer::CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
                                            const wxGraphicsGradientStops& stops)
 {
     wxGraphicsBrush p;
+    ENSURE_LOADED_OR_RETURN(p);
     wxCairoBrushData* d = new wxCairoBrushData( this );
     d->CreateRadialGradientBrush(xo, yo, xc, yc, r, stops);
     p.SetRefData(d);
     return p;
 }
 
-// sets the font
 wxGraphicsFont wxCairoRenderer::CreateFont( const wxFont &font , const wxColour &col )
 {
-    if ( font.Ok() )
+    wxGraphicsFont p;
+    ENSURE_LOADED_OR_RETURN(p);
+    if ( font.IsOk() )
     {
-        wxGraphicsFont p;
         p.SetRefData(new wxCairoFontData( this , font, col ));
-        return p;
     }
-    else
-        return wxNullGraphicsFont;
+    return p;
+}
+
+wxGraphicsFont
+wxCairoRenderer::CreateFont(double sizeInPixels,
+                            const wxString& facename,
+                            int flags,
+                            const wxColour& col)
+{
+    wxGraphicsFont font;
+    ENSURE_LOADED_OR_RETURN(font);
+    font.SetRefData(new wxCairoFontData(this, sizeInPixels, facename, flags, col));
+    return font;
 }
 
 wxGraphicsBitmap wxCairoRenderer::CreateBitmap( const wxBitmap& bmp )
 {
-    if ( bmp.Ok() )
+    wxGraphicsBitmap p;
+    ENSURE_LOADED_OR_RETURN(p);
+    if ( bmp.IsOk() )
     {
-        wxGraphicsBitmap p;
         p.SetRefData(new wxCairoBitmapData( this , bmp ));
-        return p;
     }
-    else
-        return wxNullGraphicsBitmap;
+    return p;
 }
 
+#if wxUSE_IMAGE
+
+wxGraphicsBitmap wxCairoRenderer::CreateBitmapFromImage(const wxImage& image)
+{
+    wxGraphicsBitmap bmp;
+
+    ENSURE_LOADED_OR_RETURN(bmp);
+
+    if ( image.IsOk() )
+    {
+        bmp.SetRefData(new wxCairoBitmapData(this, image));
+    }
+
+    return bmp;
+}
+
+wxImage wxCairoRenderer::CreateImageFromBitmap(const wxGraphicsBitmap& bmp)
+{
+    wxImage image;
+    ENSURE_LOADED_OR_RETURN(image);
+
+    const wxCairoBitmapData* const
+        data = static_cast<wxCairoBitmapData*>(bmp.GetGraphicsData());
+    if (data)
+        image = data->ConvertToImage();
+
+    return image;
+}
+
+#endif // wxUSE_IMAGE
+
+
 wxGraphicsBitmap wxCairoRenderer::CreateBitmapFromNativeBitmap( void* bitmap )
 {
+    wxGraphicsBitmap p;
+    ENSURE_LOADED_OR_RETURN(p);
     if ( bitmap != NULL )
     {
-        wxGraphicsBitmap p;
         p.SetRefData(new wxCairoBitmapData( this , (cairo_surface_t*) bitmap ));
-        return p;
     }
-    else
-        return wxNullGraphicsBitmap;
+    return p;
 }
 
 wxGraphicsBitmap
@@ -1975,8 +2644,9 @@ wxCairoRenderer::CreateSubBitmap(const wxGraphicsBitmap& WXUNUSED(bitmap),
                                  wxDouble WXUNUSED(w),
                                  wxDouble WXUNUSED(h))
 {
+    wxGraphicsBitmap p;
     wxFAIL_MSG("wxCairoRenderer::CreateSubBitmap is not implemented.");
-    return wxNullGraphicsBitmap;
+    return p;
 }
 
 wxGraphicsRenderer* wxGraphicsRenderer::GetCairoRenderer()