]> git.saurik.com Git - wxWidgets.git/blobdiff - src/generic/graphicc.cpp
Added ability to switch off more components of the size page UI
[wxWidgets.git] / src / generic / graphicc.cpp
index f203bdec3ca03cc1799ca897710cd3a49823520f..5e7da3dcba2654ae70349dea4a19e51820e43c1d 100644 (file)
@@ -25,7 +25,9 @@
 // the wx dll in order to load them dynamically.
 #define cairo_public 
 
 // the wx dll in order to load them dynamically.
 #define cairo_public 
 
-#include "wx/cairo.h"
+#include <cairo.h>
+
+bool wxCairoInit();
 
 #ifndef WX_PRECOMP
     #include "wx/bitmap.h"
 
 #ifndef WX_PRECOMP
     #include "wx/bitmap.h"
@@ -33,9 +35,7 @@
     #include "wx/dcclient.h"
     #include "wx/dcmemory.h"
     #include "wx/dcprint.h"
     #include "wx/dcclient.h"
     #include "wx/dcmemory.h"
     #include "wx/dcprint.h"
-    #ifdef __WXGTK__
-        #include "wx/window.h"
-    #endif
+    #include "wx/window.h"
 #endif
 
 #include "wx/private/graphics.h"
 #endif
 
 #include "wx/private/graphics.h"
@@ -73,16 +73,18 @@ using namespace std;
 #include <cairo.h>
 #ifdef __WXMSW__
 #include <cairo-win32.h>
 #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"
 #endif
 
 #ifdef __WXGTK__
 #include <gtk/gtk.h>
 #include "wx/fontutil.h"
+#ifndef __WXGTK3__
 #include "wx/gtk/dc.h"
 #endif
 #include "wx/gtk/dc.h"
 #endif
-
-#ifdef __WXMSW__
-#include <cairo-win32.h>
 #endif
 
 #ifdef __WXMAC__
 #endif
 
 #ifdef __WXMAC__
@@ -216,7 +218,44 @@ private:
     cairo_matrix_t m_matrix ;
 } ;
 
     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 );
 {
 public:
     wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen );
@@ -230,11 +269,6 @@ public:
 private :
     double m_width;
 
 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;
 
     cairo_line_cap_t m_cap;
     cairo_line_join_t m_join;
 
@@ -242,19 +276,14 @@ private :
     const double *m_lengths;
     double *m_userLengths;
 
     const double *m_lengths;
     double *m_userLengths;
 
-    wxPen m_pen;
-
     wxDECLARE_NO_COPY_CLASS(wxCairoPenData);
 };
 
     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 );
 {
 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,
 
     void CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
                                    wxDouble x2, wxDouble y2,
@@ -268,14 +297,6 @@ protected:
 
     // common part of Create{Linear,Radial}GradientBrush()
     void AddGradientStops(const wxGraphicsGradientStops& stops);
 
     // 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
 };
 
 class wxCairoFontData : public wxGraphicsObjectRefData
@@ -291,8 +312,7 @@ public:
 
     virtual bool Apply( wxGraphicsContext* context );
 #ifdef __WXGTK__
 
     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);
 #endif
 private :
     void InitColour(const wxColour& col);
@@ -308,8 +328,7 @@ private :
 #ifdef __WXMAC__
     cairo_font_face_t *m_font;
 #elif defined(__WXGTK__)
 #ifdef __WXMAC__
     cairo_font_face_t *m_font;
 #elif defined(__WXGTK__)
-    PangoFontDescription* m_font;
-    bool m_underlined;
+    wxFont m_wxfont;
 #endif
 
     // These members are used when the font is created from its face name and
 #endif
 
     // These members are used when the font is created from its face name and
@@ -327,7 +346,7 @@ private :
     cairo_font_weight_t m_weight;
 };
 
     cairo_font_weight_t m_weight;
 };
 
-class wxCairoBitmapData : public wxGraphicsObjectRefData
+class wxCairoBitmapData : public wxGraphicsBitmapData
 {
 public:
     wxCairoBitmapData( wxGraphicsRenderer* renderer, const wxBitmap& bmp );
 {
 public:
     wxCairoBitmapData( wxGraphicsRenderer* renderer, const wxBitmap& bmp );
@@ -339,6 +358,7 @@ public:
 
     virtual cairo_surface_t* GetCairoSurface() { return m_surface; }
     virtual cairo_pattern_t* GetCairoPattern() { return m_pattern; }
 
     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
     virtual wxSize GetSize() { return wxSize(m_width, m_height); }
 
 #if wxUSE_IMAGE
@@ -370,7 +390,7 @@ public:
     wxCairoContext( wxGraphicsRenderer* renderer, const wxMemoryDC& dc );
     wxCairoContext( wxGraphicsRenderer* renderer, const wxPrinterDC& dc );
 #ifdef __WXGTK__
     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
 #ifdef __WXMSW__
     wxCairoContext( wxGraphicsRenderer* renderer, HDC context );
@@ -401,6 +421,7 @@ public:
     virtual void Clip( const wxRegion &region );
 #ifdef __WXMSW__
     cairo_surface_t* m_mswSurface;
     virtual void Clip( const wxRegion &region );
 #ifdef __WXMSW__
     cairo_surface_t* m_mswSurface;
+    WindowHDC m_mswWindowHDC;
 #endif
 
     // clips drawings to the rect
 #endif
 
     // clips drawings to the rect
@@ -489,6 +510,139 @@ private:
 };
 #endif // wxUSE_IMAGE
 
 };
 #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
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxCairoPenData implementation
 //-----------------------------------------------------------------------------
@@ -507,20 +661,14 @@ void wxCairoPenData::Init()
 }
 
 wxCairoPenData::wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
 }
 
 wxCairoPenData::wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
-: wxGraphicsObjectRefData(renderer)
+    : wxCairoPenBrushBaseData(renderer, pen.GetColour(), pen.IsTransparent())
 {
     Init();
 {
     Init();
-    m_pen = pen;
-    m_width = m_pen.GetWidth();
+    m_width = pen.GetWidth();
     if (m_width <= 0.0)
         m_width = 0.1;
 
     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;
     {
     case wxCAP_ROUND :
         m_cap = CAIRO_LINE_CAP_ROUND;
@@ -539,7 +687,7 @@ wxCairoPenData::wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
         break;
     }
 
         break;
     }
 
-    switch ( m_pen.GetJoin() )
+    switch ( pen.GetJoin() )
     {
     case wxJOIN_BEVEL :
         m_join = CAIRO_LINE_JOIN_BEVEL;
     {
     case wxJOIN_BEVEL :
         m_join = CAIRO_LINE_JOIN_BEVEL;
@@ -576,7 +724,7 @@ wxCairoPenData::wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
         9.0 , 6.0 , 3.0 , 3.0
     };
 
         9.0 , 6.0 , 3.0 , 3.0
     };
 
-    switch ( m_pen.GetStyle() )
+    switch ( pen.GetStyle() )
     {
     case wxPENSTYLE_SOLID :
         break;
     {
     case wxPENSTYLE_SOLID :
         break;
@@ -606,7 +754,7 @@ wxCairoPenData::wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
     case wxPENSTYLE_USER_DASH :
         {
             wxDash *wxdashes ;
     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] ;
             if ((wxdashes != NULL) && (m_count > 0))
             {
                 m_userLengths = new double[m_count] ;
@@ -623,54 +771,18 @@ wxCairoPenData::wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
             m_lengths = m_userLengths ;
         }
         break;
             m_lengths = m_userLengths ;
         }
         break;
+
     case wxPENSTYLE_STIPPLE :
     case wxPENSTYLE_STIPPLE :
-        {
-            /*
-            wxBitmap* bmp = pen.GetStipple();
-            if ( bmp && bmp->IsOk() )
-            {
-            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;
         break;
+
     default :
     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;
     }
         }
         break;
     }
@@ -678,9 +790,10 @@ wxCairoPenData::wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
 
 void wxCairoPenData::Apply( wxGraphicsContext* context )
 {
 
 void wxCairoPenData::Apply( wxGraphicsContext* context )
 {
+    wxCairoPenBrushBaseData::Apply(context);
+
     cairo_t * ctext = (cairo_t*) context->GetNativeContext();
     cairo_set_line_width(ctext,m_width);
     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);
     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);
@@ -691,83 +804,29 @@ void wxCairoPenData::Apply( wxGraphicsContext* context )
 //-----------------------------------------------------------------------------
 
 wxCairoBrushData::wxCairoBrushData( wxGraphicsRenderer* renderer )
 //-----------------------------------------------------------------------------
 
 wxCairoBrushData::wxCairoBrushData( wxGraphicsRenderer* renderer )
-  : wxGraphicsObjectRefData( renderer )
+    : wxCairoPenBrushBaseData(renderer, wxColour(), true /* transparent */)
 {
     Init();
 }
 
 {
     Init();
 }
 
-wxCairoBrushData::wxCairoBrushData( wxGraphicsRenderer* renderer, const wxBrush &brush )
-  : wxGraphicsObjectRefData(renderer)
+wxCairoBrushData::wxCairoBrushData( wxGraphicsRenderer* renderer,
+                                    const wxBrush &brush )
+    : wxCairoPenBrushBaseData(renderer, brush.GetColour(), brush.IsTransparent())
 {
     Init();
 
 {
     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() )
+    switch ( brush.GetStyle() )
     {
     {
-    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
-    {
-    wxBitmap* bmp = brush.GetStipple();
-    if ( bmp && bmp->IsOk() )
-    {
-    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;
     }
 }
 
     }
 }
 
@@ -783,7 +842,7 @@ void wxCairoBrushData::AddGradientStops(const wxGraphicsGradientStops& stops)
 
         cairo_pattern_add_color_stop_rgba
         (
 
         cairo_pattern_add_color_stop_rgba
         (
-            m_brushPattern,
+            m_pattern,
             stop.GetPosition(),
             col.Red()/255.0,
             col.Green()/255.0,
             stop.GetPosition(),
             col.Red()/255.0,
             col.Green()/255.0,
@@ -792,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"));
 }
 
                  wxT("Couldn't create cairo pattern"));
 }
 
@@ -801,7 +860,7 @@ wxCairoBrushData::CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
                                             wxDouble x2, wxDouble y2,
                                             const wxGraphicsGradientStops& stops)
 {
                                             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);
 }
 
     AddGradientStops(stops);
 }
@@ -812,14 +871,15 @@ wxCairoBrushData::CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
                                             wxDouble radius,
                                             const wxGraphicsGradientStops& stops)
 {
                                             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()
 {
 
     AddGradientStops(stops);
 }
 
 void wxCairoBrushData::Init()
 {
-    m_brushPattern = NULL;
+    m_pattern = NULL;
+    m_bmpdata = NULL;
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------
@@ -845,7 +905,11 @@ wxCairoFontData::InitFontComponents(const wxString& facename,
 }
 
 wxCairoFontData::wxCairoFontData( wxGraphicsRenderer* renderer, const wxFont &font,
 }
 
 wxCairoFontData::wxCairoFontData( wxGraphicsRenderer* renderer, const wxFont &font,
-                         const wxColour& col ) : wxGraphicsObjectRefData(renderer)
+                         const wxColour& col )
+    : wxGraphicsObjectRefData(renderer)
+#ifdef __WXGTK__
+    , m_wxfont(font)
+#endif
 {
     InitColour(col);
 
 {
     InitColour(col);
 
@@ -854,8 +918,6 @@ wxCairoFontData::wxCairoFontData( wxGraphicsRenderer* renderer, const wxFont &fo
 #ifdef __WXMAC__
     m_font = cairo_quartz_font_face_create_for_cgfont( font.OSXGetCGFont() );
 #elif defined(__WXGTK__)
 #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 );
-    m_underlined = font.GetUnderlined();
 #else
     InitFontComponents
     (
 #else
     InitFontComponents
     (
@@ -882,7 +944,7 @@ wxCairoFontData::wxCairoFontData(wxGraphicsRenderer* renderer,
     // directly to cairo_set_font_size().
     m_size = sizeInPixels;
 
     // directly to cairo_set_font_size().
     m_size = sizeInPixels;
 
-#if defined(__WXGTK__) || defined(__WXMAC__)
+#if defined(__WXMAC__)
     m_font = NULL;
 #endif
 
     m_font = NULL;
 #endif
 
@@ -904,10 +966,6 @@ wxCairoFontData::~wxCairoFontData()
 #ifdef __WXMAC__
     if ( m_font )
         cairo_font_face_destroy( m_font );
 #ifdef __WXMAC__
     if ( m_font )
         cairo_font_face_destroy( m_font );
-#elif defined(__WXGTK__)
-    if ( m_font )
-        pango_font_description_free( m_font );
-#else
 #endif
 }
 
 #endif
 }
 
@@ -916,7 +974,7 @@ 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__
     cairo_t * ctext = (cairo_t*) context->GetNativeContext();
     cairo_set_source_rgba(ctext,m_red,m_green, m_blue,m_alpha);
 #ifdef __WXGTK__
-    if ( m_font )
+    if (m_wxfont.IsOk())
     {
         // Nothing to do, the caller uses Pango layout functions to do
         // everything.
     {
         // Nothing to do, the caller uses Pango layout functions to do
         // everything.
@@ -1253,13 +1311,13 @@ void wxCairoBitmapData::InitSurface(cairo_format_t format, int stride)
 }
 
 wxCairoBitmapData::wxCairoBitmapData( wxGraphicsRenderer* renderer, cairo_surface_t* bitmap ) :
 }
 
 wxCairoBitmapData::wxCairoBitmapData( wxGraphicsRenderer* renderer, cairo_surface_t* bitmap ) :
-    wxGraphicsObjectRefData( renderer )
+    wxGraphicsBitmapData( renderer )
 {
     m_surface = bitmap;
     m_pattern = cairo_pattern_create_for_surface(m_surface);
 }
 
 {
     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"));
 
 {
     wxCHECK_RET( bmp.IsOk(), wxT("Invalid bitmap in wxCairoContext::DrawBitmap"));
 
@@ -1267,8 +1325,8 @@ wxCairoBitmapData::wxCairoBitmapData( wxGraphicsRenderer* renderer, const wxBitm
     // 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...
     // 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...
-    const cairo_format_t bufferFormat = bmp.GetDepth() == 32
-#ifdef __WXGTK__
+    cairo_format_t bufferFormat = bmp.GetDepth() == 32
+#if defined(__WXGTK__) && !defined(__WXGTK3__)
                                             || bmp.GetMask()
 #endif
                                         ? CAIRO_FORMAT_ARGB32
                                             || bmp.GetMask()
 #endif
                                         ? CAIRO_FORMAT_ARGB32
@@ -1276,23 +1334,22 @@ wxCairoBitmapData::wxCairoBitmapData( wxGraphicsRenderer* renderer, const wxBitm
 
     int stride = InitBuffer(bmp.GetWidth(), bmp.GetHeight(), bufferFormat);
 
 
     int stride = InitBuffer(bmp.GetWidth(), bmp.GetHeight(), bufferFormat);
 
-    int bw = m_width;
-    int bh = m_height;
     wxBitmap bmpSource = bmp;  // we need a non-const instance
     wxUint32* data = (wxUint32*)m_buffer;
 
     if ( bufferFormat == CAIRO_FORMAT_ARGB32 )
     {
         // use the bitmap's alpha
     wxBitmap bmpSource = bmp;  // we need a non-const instance
     wxUint32* data = (wxUint32*)m_buffer;
 
     if ( bufferFormat == CAIRO_FORMAT_ARGB32 )
     {
         // use the bitmap's alpha
-        wxAlphaPixelData pixData(bmpSource, wxPoint(0,0), wxSize(bw, bh));
+        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);
         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;
             wxUint32* const rowStartDst = data;
         {
             wxAlphaPixelData::Iterator rowStart = p;
             wxUint32* const rowStartDst = data;
-            for (int x=0; x<bw; x++)
+            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
             {
                 // Each pixel in CAIRO_FORMAT_ARGB32 is a 32-bit quantity,
                 // with alpha in the upper 8 bits, then red, then green, then
@@ -1317,15 +1374,16 @@ wxCairoBitmapData::wxCairoBitmapData( wxGraphicsRenderer* renderer, const wxBitm
     }
     else  // no alpha
     {
     }
     else  // no alpha
     {
-        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);
         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;
             wxUint32* const rowStartDst = data;
         {
             wxNativePixelData::Iterator rowStart = p;
             wxUint32* const rowStartDst = data;
-            for (int x=0; x<bw; x++)
+            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
             {
                 // Each pixel in CAIRO_FORMAT_RGB24 is a 32-bit quantity, with
                 // the upper 8 bits unused. Red, Green, and Blue are stored in
@@ -1341,23 +1399,24 @@ wxCairoBitmapData::wxCairoBitmapData( wxGraphicsRenderer* renderer, const wxBitm
             p.OffsetY(pixData, 1);
         }
     }
             p.OffsetY(pixData, 1);
         }
     }
-#ifdef __WXMSW__
+#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())
     {
     // 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.GetMaskBitmap();
+        wxBitmap bmpMask = bmpSource.GetMask()->GetBitmap();
         bufferFormat = CAIRO_FORMAT_ARGB32;
         data = (wxUint32*)m_buffer;
         bufferFormat = CAIRO_FORMAT_ARGB32;
         data = (wxUint32*)m_buffer;
-        wxNativePixelData pixData(bmpMask, wxPoint(0,0), wxSize(bw, bh));
-        wxCHECK_RET( pixData, wxT("Failed to gain raw access to mask bitmap data."));
+        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);
 
         wxNativePixelData::Iterator p(pixData);
-        for (int y=0; y<bh; y++)
+        for (int y=0; y<m_height; y++)
         {
             wxNativePixelData::Iterator rowStart = p;
             wxUint32* const rowStartDst = data;
         {
             wxNativePixelData::Iterator rowStart = p;
             wxUint32* const rowStartDst = data;
-            for (int x=0; x<bw; x++)
+            for (int x=0; x<m_width; x++)
             {
                 if (p.Red()+p.Green()+p.Blue() == 0)
                     *data = 0;
             {
                 if (p.Red()+p.Green()+p.Blue() == 0)
                     *data = 0;
@@ -1398,7 +1457,7 @@ inline unsigned char Unpremultiply(unsigned char alpha, unsigned char data)
 
 wxCairoBitmapData::wxCairoBitmapData(wxGraphicsRenderer* renderer,
                                      const wxImage& image)
 
 wxCairoBitmapData::wxCairoBitmapData(wxGraphicsRenderer* renderer,
                                      const wxImage& image)
-    : wxGraphicsObjectRefData(renderer)
+    : wxGraphicsBitmapData(renderer)
 {
     const cairo_format_t bufferFormat = image.HasAlpha()
                                             ? CAIRO_FORMAT_ARGB32
 {
     const cairo_format_t bufferFormat = image.HasAlpha()
                                             ? CAIRO_FORMAT_ARGB32
@@ -1557,22 +1616,6 @@ wxCairoBitmapData::~wxCairoBitmapData()
     delete [] m_buffer;
 }
 
     delete [] m_buffer;
 }
 
-// ----------------------------------------------------------------------------
-// wxGraphicsBitmap implementation
-// ----------------------------------------------------------------------------
-
-#if wxUSE_IMAGE
-
-wxImage wxGraphicsBitmap::ConvertToImage() const
-{
-    const wxCairoBitmapData* const
-        data = static_cast<wxCairoBitmapData*>(GetGraphicsData());
-
-    return data ? data->ConvertToImage() : wxNullImage;
-}
-
-#endif // wxUSE_IMAGE
-
 //-----------------------------------------------------------------------------
 // wxCairoContext implementation
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxCairoContext implementation
 //-----------------------------------------------------------------------------
@@ -1655,7 +1698,11 @@ wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, const wxWindowDC&
     Init( cairo_create(m_mswSurface) );
 #endif
 
     Init( cairo_create(m_mswSurface) );
 #endif
 
-#ifdef __WXGTK20__
+#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() ) );
 
     wxGTKDCImpl *impldc = (wxGTKDCImpl*) dc.GetImpl();
     Init( gdk_cairo_create( impldc->GetGDKWindow() ) );
 
@@ -1695,11 +1742,42 @@ wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, const wxMemoryDC&
     m_enableOffset = true;
 
 #ifdef __WXMSW__
     m_enableOffset = true;
 
 #ifdef __WXMSW__
-    m_mswSurface = cairo_win32_surface_create((HDC)dc.GetHDC());
+
+    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) );
     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
     
 #endif
     
-#ifdef __WXGTK20__
+#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() ) );
 
     wxGTKDCImpl *impldc = (wxGTKDCImpl*) dc.GetImpl();
     Init( gdk_cairo_create( impldc->GetGDKWindow() ) );
 
@@ -1729,15 +1807,20 @@ wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, const wxMemoryDC&
 }
 
 #ifdef __WXGTK20__
 }
 
 #ifdef __WXGTK20__
-wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, GdkDrawable *drawable )
+wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, GdkWindow *window )
 : wxGraphicsContext(renderer)
 {
 : 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;
     int width, height;
-    gdk_drawable_get_size( drawable, &width, &height );
+    gdk_drawable_get_size(window, &width, &height);
     m_width = width;
     m_height = height;
     m_width = width;
     m_height = height;
+#endif
 }
 #endif
 
 }
 #endif
 
@@ -1762,7 +1845,10 @@ wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, cairo_t *context )
 }
 
 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, wxWindow *window)
 }
 
 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, wxWindow *window)
-: wxGraphicsContext(renderer)
+    : wxGraphicsContext(renderer)
+#ifdef __WXMSW__
+    , m_mswWindowHDC(GetHwndOf(window))
+#endif
 {
     m_enableOffset = true;    
 #ifdef __WXGTK__
 {
     m_enableOffset = true;    
 #ifdef __WXGTK__
@@ -1786,7 +1872,7 @@ wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, wxWindow *window)
 #endif
 
 #ifdef __WXMSW__
 #endif
 
 #ifdef __WXMSW__
-    m_mswSurface = cairo_win32_surface_create((HDC)window->GetHandle());
+    m_mswSurface = cairo_win32_surface_create((HDC)m_mswWindowHDC);
     Init(cairo_create(m_mswSurface));
 #endif
 
     Init(cairo_create(m_mswSurface));
 #endif
 
@@ -1992,21 +2078,11 @@ void wxCairoContext::DoDrawText(const wxString& str, wxDouble x, wxDouble y)
     if ( ((wxCairoFontData*)m_font.GetRefData())->Apply(this) )
     {
 #ifdef __WXGTK__
     if ( ((wxCairoFontData*)m_font.GetRefData())->Apply(this) )
     {
 #ifdef __WXGTK__
-        size_t datalen = strlen(data);
-
         PangoLayout *layout = pango_cairo_create_layout (m_context);
         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);
-
-        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);
-        }
+        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);
 
         cairo_move_to(m_context, x, y);
         pango_cairo_show_layout (m_context, layout);
 
         cairo_move_to(m_context, x, y);
         pango_cairo_show_layout (m_context, layout);
@@ -2050,13 +2126,14 @@ void wxCairoContext::GetTextExtent( const wxString &str, wxDouble *width, wxDoub
         int w, h;
 
         PangoLayout *layout = pango_cairo_create_layout (m_context);
         int w, h;
 
         PangoLayout *layout = pango_cairo_create_layout (m_context);
-        pango_layout_set_font_description( layout, ((wxCairoFontData*)m_font.GetRefData())->GetFont());
+        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;
         }
         const wxCharBuffer data = str.utf8_str();
         if ( !data )
         {
             return;
         }
-        pango_layout_set_text( layout, data, strlen(data) );
+        pango_layout_set_text(layout, data, data.length());
         pango_layout_get_pixel_size (layout, &w, &h);
         if ( width )
             *width = w;
         pango_layout_get_pixel_size (layout, &w, &h);
         if ( width )
             *width = w;
@@ -2110,14 +2187,33 @@ void wxCairoContext::GetTextExtent( const wxString &str, wxDouble *width, wxDoub
 void wxCairoContext::GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const
 {
     widths.Empty();
 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") );
     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
     // TODO
+#endif
 }
 
 void * wxCairoContext::GetNativeContext()
 }
 
 void * wxCairoContext::GetNativeContext()
@@ -2291,6 +2387,7 @@ public :
     virtual wxGraphicsBitmap CreateBitmap( const wxBitmap &bitmap );
 #if wxUSE_IMAGE
     virtual wxGraphicsBitmap CreateBitmapFromImage(const wxImage& image);
     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
 #endif // wxUSE_IMAGE
 
     // create a graphics bitmap from a native bitmap
@@ -2299,13 +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  );
 
     // create a subimage from a native image representation
     virtual wxGraphicsBitmap CreateSubBitmap( const wxGraphicsBitmap &bitmap, wxDouble x, wxDouble y, wxDouble w, wxDouble h  );
 
-protected :
-    bool EnsureIsLoaded();
-    void Load();
-    void Unload();
-    friend class wxCairoModule;
-private :
-    int m_loaded;
     DECLARE_DYNAMIC_CLASS_NO_COPY(wxCairoRenderer)
 } ;
 
     DECLARE_DYNAMIC_CLASS_NO_COPY(wxCairoRenderer)
 } ;
 
@@ -2316,34 +2406,14 @@ private :
 IMPLEMENT_DYNAMIC_CLASS(wxCairoRenderer,wxGraphicsRenderer)
 
 static wxCairoRenderer gs_cairoGraphicsRenderer;
 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;
 
 
-bool wxCairoRenderer::EnsureIsLoaded()
-{
-#ifndef __WXGTK__
-    Load();
-    return wxCairoInit();
+#ifdef __WXGTK__
+    #define ENSURE_LOADED_OR_RETURN(returnOnFail)
 #else
 #else
-    return true;
+    #define ENSURE_LOADED_OR_RETURN(returnOnFail)  \
+        if (!wxCairoInit())                        \
+            return returnOnFail
 #endif
 #endif
-}
-
-void wxCairoRenderer::Load()
-{
-    wxCairoInit();
-}
-
-void wxCairoRenderer::Unload()
-{
-    wxCairoCleanUp();
-}
-
-// call EnsureIsLoaded() and return returnOnFail value if it fails
-#define ENSURE_LOADED_OR_RETURN(returnOnFail)  \
-    if ( !EnsureIsLoaded() )                   \
-        return (returnOnFail)
 
 wxGraphicsContext * wxCairoRenderer::CreateContext( const wxWindowDC& dc)
 {
 
 wxGraphicsContext * wxCairoRenderer::CreateContext( const wxWindowDC& dc)
 {
@@ -2360,21 +2430,13 @@ wxGraphicsContext * wxCairoRenderer::CreateContext( const wxMemoryDC& dc)
 wxGraphicsContext * wxCairoRenderer::CreateContext( const wxPrinterDC& dc)
 {
     ENSURE_LOADED_OR_RETURN(NULL);
 wxGraphicsContext * wxCairoRenderer::CreateContext( const wxPrinterDC& dc)
 {
     ENSURE_LOADED_OR_RETURN(NULL);
-#ifdef __WXGTK20__
-    const wxDCImpl *impl = dc.GetImpl();
-    cairo_t* context = (cairo_t*) impl->GetCairoContext();
-    if (context)
-       return new wxCairoContext(this,dc);
-    else
-#endif
-       return new wxCairoContext(this,dc);
+    return new wxCairoContext(this, dc);
 }
 
 #ifdef __WXMSW__
 #if wxUSE_ENH_METAFILE
 wxGraphicsContext * wxCairoRenderer::CreateContext( const wxEnhMetaFileDC& WXUNUSED(dc) )
 {
 }
 
 #ifdef __WXMSW__
 #if wxUSE_ENH_METAFILE
 wxGraphicsContext * wxCairoRenderer::CreateContext( const wxEnhMetaFileDC& WXUNUSED(dc) )
 {
-    ENSURE_LOADED_OR_RETURN(NULL);
     return NULL;
 }
 #endif
     return NULL;
 }
 #endif
@@ -2393,9 +2455,8 @@ wxGraphicsContext * wxCairoRenderer::CreateContextFromNativeContext( void * cont
 
 wxGraphicsContext * wxCairoRenderer::CreateContextFromNativeWindow( void * window )
 {
 
 wxGraphicsContext * wxCairoRenderer::CreateContextFromNativeWindow( void * window )
 {
-    ENSURE_LOADED_OR_RETURN(NULL);
 #ifdef __WXGTK__
 #ifdef __WXGTK__
-    return new wxCairoContext(this,(GdkDrawable*)window);
+    return new wxCairoContext(this, static_cast<GdkWindow*>(window));
 #else
     wxUnusedVar(window);
     return NULL;
 #else
     wxUnusedVar(window);
     return NULL;
@@ -2405,18 +2466,19 @@ wxGraphicsContext * wxCairoRenderer::CreateContextFromNativeWindow( void * windo
 #if wxUSE_IMAGE
 wxGraphicsContext * wxCairoRenderer::CreateContextFromImage(wxImage& image)
 {
 #if wxUSE_IMAGE
 wxGraphicsContext * wxCairoRenderer::CreateContextFromImage(wxImage& image)
 {
+    ENSURE_LOADED_OR_RETURN(NULL);
     return new wxCairoImageContext(this, image);
 }
 #endif // wxUSE_IMAGE
 
 wxGraphicsContext * wxCairoRenderer::CreateMeasuringContext()
 {
     return new wxCairoImageContext(this, image);
 }
 #endif // wxUSE_IMAGE
 
 wxGraphicsContext * wxCairoRenderer::CreateMeasuringContext()
 {
-    ENSURE_LOADED_OR_RETURN(NULL);
 #ifdef __WXGTK__
     return CreateContextFromNativeWindow(gdk_get_default_root_window());
 #ifdef __WXGTK__
     return CreateContextFromNativeWindow(gdk_get_default_root_window());
-#endif
+#else
     return NULL;
     // TODO
     return NULL;
     // TODO
+#endif
 }
 
 wxGraphicsContext * wxCairoRenderer::CreateContext( wxWindow* window )
 }
 
 wxGraphicsContext * wxCairoRenderer::CreateContext( wxWindow* window )
@@ -2429,8 +2491,8 @@ wxGraphicsContext * wxCairoRenderer::CreateContext( wxWindow* window )
 
 wxGraphicsPath wxCairoRenderer::CreatePath()
 {
 
 wxGraphicsPath wxCairoRenderer::CreatePath()
 {
-    ENSURE_LOADED_OR_RETURN(wxNullGraphicsPath);
     wxGraphicsPath path;
     wxGraphicsPath path;
+    ENSURE_LOADED_OR_RETURN(path);
     path.SetRefData( new wxCairoPathData(this) );
     return path;
 }
     path.SetRefData( new wxCairoPathData(this) );
     return path;
 }
@@ -2442,8 +2504,8 @@ wxGraphicsMatrix wxCairoRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDouble
                                                 wxDouble tx, wxDouble ty)
 
 {
                                                 wxDouble tx, wxDouble ty)
 
 {
-    ENSURE_LOADED_OR_RETURN(wxNullGraphicsMatrix);
     wxGraphicsMatrix m;
     wxGraphicsMatrix m;
+    ENSURE_LOADED_OR_RETURN(m);
     wxCairoMatrixData* data = new wxCairoMatrixData( this );
     data->Set( a,b,c,d,tx,ty ) ;
     m.SetRefData(data);
     wxCairoMatrixData* data = new wxCairoMatrixData( this );
     data->Set( a,b,c,d,tx,ty ) ;
     m.SetRefData(data);
@@ -2452,28 +2514,24 @@ wxGraphicsMatrix wxCairoRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDouble
 
 wxGraphicsPen wxCairoRenderer::CreatePen(const wxPen& pen)
 {
 
 wxGraphicsPen wxCairoRenderer::CreatePen(const wxPen& pen)
 {
-    ENSURE_LOADED_OR_RETURN(wxNullGraphicsPen);
-    if ( !pen.IsOk() || 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 ));
         p.SetRefData(new wxCairoPenData( this, pen ));
-        return p;
     }
     }
+    return p;
 }
 
 wxGraphicsBrush wxCairoRenderer::CreateBrush(const wxBrush& brush )
 {
 }
 
 wxGraphicsBrush wxCairoRenderer::CreateBrush(const wxBrush& brush )
 {
-    ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush);
-    if ( !brush.IsOk() || 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 ));
         p.SetRefData(new wxCairoBrushData( this, brush ));
-        return p;
     }
     }
+    return p;
 }
 
 wxGraphicsBrush
 }
 
 wxGraphicsBrush
@@ -2481,8 +2539,8 @@ wxCairoRenderer::CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
                                            wxDouble x2, wxDouble y2,
                                            const wxGraphicsGradientStops& stops)
 {
                                            wxDouble x2, wxDouble y2,
                                            const wxGraphicsGradientStops& stops)
 {
-    ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush);
     wxGraphicsBrush p;
     wxGraphicsBrush p;
+    ENSURE_LOADED_OR_RETURN(p);
     wxCairoBrushData* d = new wxCairoBrushData( this );
     d->CreateLinearGradientBrush(x1, y1, x2, y2, stops);
     p.SetRefData(d);
     wxCairoBrushData* d = new wxCairoBrushData( this );
     d->CreateLinearGradientBrush(x1, y1, x2, y2, stops);
     p.SetRefData(d);
@@ -2494,8 +2552,8 @@ wxCairoRenderer::CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
                                            wxDouble xc, wxDouble yc, wxDouble r,
                                            const wxGraphicsGradientStops& stops)
 {
                                            wxDouble xc, wxDouble yc, wxDouble r,
                                            const wxGraphicsGradientStops& stops)
 {
-    ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush);
     wxGraphicsBrush p;
     wxGraphicsBrush p;
+    ENSURE_LOADED_OR_RETURN(p);
     wxCairoBrushData* d = new wxCairoBrushData( this );
     d->CreateRadialGradientBrush(xo, yo, xc, yc, r, stops);
     p.SetRefData(d);
     wxCairoBrushData* d = new wxCairoBrushData( this );
     d->CreateRadialGradientBrush(xo, yo, xc, yc, r, stops);
     p.SetRefData(d);
@@ -2504,15 +2562,13 @@ wxCairoRenderer::CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
 
 wxGraphicsFont wxCairoRenderer::CreateFont( const wxFont &font , const wxColour &col )
 {
 
 wxGraphicsFont wxCairoRenderer::CreateFont( const wxFont &font , const wxColour &col )
 {
-    ENSURE_LOADED_OR_RETURN(wxNullGraphicsFont);
+    wxGraphicsFont p;
+    ENSURE_LOADED_OR_RETURN(p);
     if ( font.IsOk() )
     {
     if ( font.IsOk() )
     {
-        wxGraphicsFont p;
         p.SetRefData(new wxCairoFontData( this , font, col ));
         p.SetRefData(new wxCairoFontData( this , font, col ));
-        return p;
     }
     }
-    else
-        return wxNullGraphicsFont;
+    return p;
 }
 
 wxGraphicsFont
 }
 
 wxGraphicsFont
@@ -2521,24 +2577,21 @@ wxCairoRenderer::CreateFont(double sizeInPixels,
                             int flags,
                             const wxColour& col)
 {
                             int flags,
                             const wxColour& col)
 {
-    ENSURE_LOADED_OR_RETURN(wxNullGraphicsFont);
-
     wxGraphicsFont font;
     wxGraphicsFont font;
+    ENSURE_LOADED_OR_RETURN(font);
     font.SetRefData(new wxCairoFontData(this, sizeInPixels, facename, flags, col));
     return font;
 }
 
 wxGraphicsBitmap wxCairoRenderer::CreateBitmap( const wxBitmap& bmp )
 {
     font.SetRefData(new wxCairoFontData(this, sizeInPixels, facename, flags, col));
     return font;
 }
 
 wxGraphicsBitmap wxCairoRenderer::CreateBitmap( const wxBitmap& bmp )
 {
-    ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap);
+    wxGraphicsBitmap p;
+    ENSURE_LOADED_OR_RETURN(p);
     if ( bmp.IsOk() )
     {
     if ( bmp.IsOk() )
     {
-        wxGraphicsBitmap p;
         p.SetRefData(new wxCairoBitmapData( this , bmp ));
         p.SetRefData(new wxCairoBitmapData( this , bmp ));
-        return p;
     }
     }
-    else
-        return wxNullGraphicsBitmap;
+    return p;
 }
 
 #if wxUSE_IMAGE
 }
 
 #if wxUSE_IMAGE
@@ -2557,19 +2610,31 @@ wxGraphicsBitmap wxCairoRenderer::CreateBitmapFromImage(const wxImage& image)
     return bmp;
 }
 
     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
 
 #endif // wxUSE_IMAGE
 
+
 wxGraphicsBitmap wxCairoRenderer::CreateBitmapFromNativeBitmap( void* bitmap )
 {
 wxGraphicsBitmap wxCairoRenderer::CreateBitmapFromNativeBitmap( void* bitmap )
 {
-    ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap);
+    wxGraphicsBitmap p;
+    ENSURE_LOADED_OR_RETURN(p);
     if ( bitmap != NULL )
     {
     if ( bitmap != NULL )
     {
-        wxGraphicsBitmap p;
         p.SetRefData(new wxCairoBitmapData( this , (cairo_surface_t*) bitmap ));
         p.SetRefData(new wxCairoBitmapData( this , (cairo_surface_t*) bitmap ));
-        return p;
     }
     }
-    else
-        return wxNullGraphicsBitmap;
+    return p;
 }
 
 wxGraphicsBitmap
 }
 
 wxGraphicsBitmap
@@ -2579,9 +2644,9 @@ wxCairoRenderer::CreateSubBitmap(const wxGraphicsBitmap& WXUNUSED(bitmap),
                                  wxDouble WXUNUSED(w),
                                  wxDouble WXUNUSED(h))
 {
                                  wxDouble WXUNUSED(w),
                                  wxDouble WXUNUSED(h))
 {
-    ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap);
+    wxGraphicsBitmap p;
     wxFAIL_MSG("wxCairoRenderer::CreateSubBitmap is not implemented.");
     wxFAIL_MSG("wxCairoRenderer::CreateSubBitmap is not implemented.");
-    return wxNullGraphicsBitmap;
+    return p;
 }
 
 wxGraphicsRenderer* wxGraphicsRenderer::GetCairoRenderer()
 }
 
 wxGraphicsRenderer* wxGraphicsRenderer::GetCairoRenderer()