Do not declare "environ" variable ourselves under MSW.

[wxWidgets.git] / src / generic / graphicc.cpp

diff --git a/src/generic/graphicc.cpp b/src/generic/graphicc.cpp
index 92893cac397fada7f6318d6ca57967b4a3b368ed..312cd846350ae768ae730d6022c0dbdf2c08f397 100644 (file)
--- a/src/generic/graphicc.cpp
+++ b/src/generic/graphicc.cpp
@@ -282,16 +282,25 @@ class wxCairoFontData : public wxGraphicsObjectRefData
 {
 public:
     wxCairoFontData( wxGraphicsRenderer* renderer, const wxFont &font, const wxColour& col );
 {
 public:
     wxCairoFontData( wxGraphicsRenderer* renderer, const wxFont &font, const wxColour& col );

+    wxCairoFontData(wxGraphicsRenderer* renderer,
+                    double sizeInPixels,
+                    const wxString& facename,
+                    int flags,
+                    const wxColour& col);

     ~wxCairoFontData();
 
     ~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; }
 #endif
 private :
 #ifdef __WXGTK__
     const PangoFontDescription* GetFont() const { return m_font; }
     bool GetUnderlined() const { return m_underlined; }
 #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;
     double m_size;

-    bool m_underlined;

     double m_red;
     double m_green;
     double m_blue;
     double m_red;
     double m_green;
     double m_blue;


@@ -300,17 +309,31 @@ private :
     cairo_font_face_t *m_font;
 #elif defined(__WXGTK__)
     PangoFontDescription* m_font;
     cairo_font_face_t *m_font;
 #elif defined(__WXGTK__)
     PangoFontDescription* m_font;

-#else
+    bool m_underlined;
+#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;
     wxCharBuffer m_fontName;
     cairo_font_slant_t m_slant;
     cairo_font_weight_t m_weight;

-#endif

 };
 
 class wxCairoBitmapData : public wxGraphicsObjectRefData
 {
 public:
     wxCairoBitmapData( wxGraphicsRenderer* renderer, const wxBitmap& bmp );
 };
 
 class wxCairoBitmapData : public wxGraphicsObjectRefData
 {
 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();
 
     wxCairoBitmapData( wxGraphicsRenderer* renderer, cairo_surface_t* bitmap );
     ~wxCairoBitmapData();
 


@@ -354,7 +377,10 @@ public:
 #endif
     wxCairoContext( wxGraphicsRenderer* renderer, cairo_t *context );
     wxCairoContext( wxGraphicsRenderer* renderer, wxWindow *window);
 #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
     virtual ~wxCairoContext();
 
     virtual bool ShouldOffset() const


@@ -424,9 +450,9 @@ public:
 protected:
     virtual void DoDrawText( const wxString &str, wxDouble x, wxDouble y );
 
 protected:
     virtual void DoDrawText( const wxString &str, wxDouble x, wxDouble y );
 

-private:

     void Init(cairo_t *context);
 
     void Init(cairo_t *context);
 

+private:

     cairo_t* m_context;
 
     wxVector<float> m_layerOpacities;
     cairo_t* m_context;
 
     wxVector<float> m_layerOpacities;


@@ -434,6 +460,35 @@ private:
     wxDECLARE_NO_COPY_CLASS(wxCairoContext);
 };
 
     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
+

 //-----------------------------------------------------------------------------
 // wxCairoPenData implementation
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxCairoPenData implementation
 //-----------------------------------------------------------------------------


@@ -771,50 +826,119 @@ void wxCairoBrushData::Init()
 // wxCairoFontData implementation
 //-----------------------------------------------------------------------------
 
 // 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;
 {
     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)
+{
+    InitColour(col);
+

     m_size = font.GetPointSize();
     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 );
 
 #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
 #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
 }
 
 #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(__WXGTK__) || 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__
 wxCairoFontData::~wxCairoFontData()
 {
 #ifdef __WXMAC__

-    cairo_font_face_destroy( m_font );
+    if ( m_font )
+        cairo_font_face_destroy( m_font );

 #elif defined(__WXGTK__)
 #elif defined(__WXGTK__)

-    pango_font_description_free( m_font );
+    if ( m_font )
+        pango_font_description_free( m_font );

 #else
 #endif
 }
 
 #else
 #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__
 {
     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_font )
+    {
+        // Nothing to do, the caller uses Pango layout functions to do
+        // everything.
+        return true;
+    }

 #elif defined(__WXMAC__)
 #elif defined(__WXMAC__)

-    cairo_set_font_face(ctext, m_font);
-    cairo_set_font_size(ctext, m_size );
-#else
+    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 );
     cairo_select_font_face(ctext, m_fontName, m_slant, m_weight );
     cairo_set_font_size(ctext, m_size );

-#endif
+
+    // Indicate that we don't use native fonts for the platforms which care
+    // about this (currently only wxGTK).
+    return false;

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -1143,7 +1267,7 @@ 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
+    cairo_format_t bufferFormat = bmp.GetDepth() == 32

 #ifdef __WXGTK__
                                             || bmp.GetMask()
 #endif
 #ifdef __WXGTK__
                                             || bmp.GetMask()
 #endif


@@ -1152,23 +1276,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


@@ -1193,15 +1316,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


@@ -1225,15 +1349,16 @@ wxCairoBitmapData::wxCairoBitmapData( wxGraphicsRenderer* renderer, const wxBitm
         wxBitmap bmpMask = bmpSource.GetMaskBitmap();
         bufferFormat = CAIRO_FORMAT_ARGB32;
         data = (wxUint32*)m_buffer;
         wxBitmap bmpMask = bmpSource.GetMaskBitmap();
         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;


@@ -1280,7 +1405,7 @@ wxCairoBitmapData::wxCairoBitmapData(wxGraphicsRenderer* renderer,
                                             ? CAIRO_FORMAT_ARGB32
                                             : CAIRO_FORMAT_RGB24;
 
                                             ? CAIRO_FORMAT_ARGB32
                                             : CAIRO_FORMAT_RGB24;
 

-    InitBuffer(image.GetWidth(), image.GetHeight(), bufferFormat);
+    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
 
     // Copy wxImage data into the buffer. Notice that we work with wxUint32
     // values and not bytes becase Cairo always works with buffers in native


@@ -1294,6 +1419,8 @@ wxCairoBitmapData::wxCairoBitmapData(wxGraphicsRenderer* renderer,
 
         for ( int y = 0; y < m_height; y++ )
         {
 
         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++;
             for ( int x = 0; x < m_width; x++ )
             {
                 const unsigned char a = *alpha++;


@@ -1304,12 +1431,16 @@ wxCairoBitmapData::wxCairoBitmapData(wxGraphicsRenderer* renderer,
                          Premultiply(a, src[2]);
                 src += 3;
             }
                          Premultiply(a, src[2]);
                 src += 3;
             }

+
+            dst = rowStartDst + stride / 4;

         }
     }
     else // RGB
     {
         for ( int y = 0; y < m_height; y++ )
         {
         }
     }
     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 |
             for ( int x = 0; x < m_width; x++ )
             {
                 *dst++ = src[0] << 16 |


@@ -1317,10 +1448,12 @@ wxCairoBitmapData::wxCairoBitmapData(wxGraphicsRenderer* renderer,
                          src[2];
                 src += 3;
             }
                          src[2];
                 src += 3;
             }

+
+            dst = rowStartDst + stride / 4;

         }
     }
 
         }
     }
 

-    InitSurface(bufferFormat);
+    InitSurface(bufferFormat, stride);

 }
 
 wxImage wxCairoBitmapData::ConvertToImage() const
 }
 
 wxImage wxCairoBitmapData::ConvertToImage() const


@@ -1425,22 +1558,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
 //-----------------------------------------------------------------------------


@@ -1660,6 +1777,12 @@ wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, wxWindow *window)
 
 }
 
 
 }
 

+wxCairoContext::wxCairoContext(wxGraphicsRenderer* renderer) :
+    wxGraphicsContext(renderer)
+{
+    m_context = NULL;
+}
+

 wxCairoContext::~wxCairoContext()
 {
     if ( m_context )
 wxCairoContext::~wxCairoContext()
 {
     if ( m_context )


@@ -1851,30 +1974,35 @@ void wxCairoContext::DoDrawText(const wxString& str, wxDouble x, wxDouble y)
     if ( !data )
         return;
 
     if ( !data )
         return;
 

-    ((wxCairoFontData*)m_font.GetRefData())->Apply(this);
-
+    if ( ((wxCairoFontData*)m_font.GetRefData())->Apply(this) )
+    {

 #ifdef __WXGTK__
 #ifdef __WXGTK__

-    size_t datalen = strlen(data);
+        size_t datalen = strlen(data);

 
 

-    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);
+        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);
-    }
+        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);
+        }

 
 

-    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);
+
+        g_object_unref (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;
     // 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;


@@ -1882,7 +2010,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);
     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,
 }
 
 void wxCairoContext::GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height,


@@ -1902,32 +2029,35 @@ void wxCairoContext::GetTextExtent( const wxString &str, wxDouble *width, wxDoub
     if ( str.empty())
         return;
 
     if ( str.empty())
         return;
 

+    if ( ((wxCairoFontData*)m_font.GetRefData())->Apply((wxCairoContext*)this) )
+    {

 #ifdef __WXGTK__
 #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);
+        pango_layout_set_font_description( layout, ((wxCairoFontData*)m_font.GetRefData())->GetFont());
+        const wxCharBuffer data = str.utf8_str();
+        if ( !data )
+        {
+            return;
+        }
+        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);

         return;
         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)
     {
 
     if (width)
     {


@@ -1960,7 +2090,6 @@ void wxCairoContext::GetTextExtent( const wxString &str, wxDouble *width, wxDoub
         if ( externalLeading )
             *externalLeading = wxMax(0, fe.height - (fe.ascent + fe.descent));
     }
         if ( externalLeading )
             *externalLeading = wxMax(0, fe.height - (fe.ascent + fe.descent));
     }

-#endif

 }
 
 void wxCairoContext::GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const
 }
 
 void wxCairoContext::GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const


@@ -2099,6 +2228,9 @@ public :
     virtual wxGraphicsContext * CreateContextFromNativeContext( void * context );
 
     virtual wxGraphicsContext * CreateContextFromNativeWindow( void * window );
     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 * CreateContext( wxWindow* window );
 


@@ -2135,9 +2267,17 @@ public :
 
     // sets the font
     virtual wxGraphicsFont CreateFont( const wxFont &font , const wxColour &col = *wxBLACK ) ;
 
     // sets the font
     virtual wxGraphicsFont CreateFont( const wxFont &font , const wxColour &col = *wxBLACK ) ;

+    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 );
 
     // 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 );
 
     // create a graphics bitmap from a native bitmap
     virtual wxGraphicsBitmap CreateBitmapFromNativeBitmap( void* bitmap );


@@ -2206,14 +2346,7 @@ 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__
 }
 
 #ifdef __WXMSW__


@@ -2248,6 +2381,13 @@ wxGraphicsContext * wxCairoRenderer::CreateContextFromNativeWindow( void * windo
 #endif
 }
 
 #endif
 }
 

+#if wxUSE_IMAGE
+wxGraphicsContext * wxCairoRenderer::CreateContextFromImage(wxImage& image)
+{
+    return new wxCairoImageContext(this, image);
+}
+#endif // wxUSE_IMAGE
+

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


@@ -2341,7 +2481,6 @@ wxCairoRenderer::CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
     return p;
 }
 
     return p;
 }
 

-// sets the font

 wxGraphicsFont wxCairoRenderer::CreateFont( const wxFont &font , const wxColour &col )
 {
     ENSURE_LOADED_OR_RETURN(wxNullGraphicsFont);
 wxGraphicsFont wxCairoRenderer::CreateFont( const wxFont &font , const wxColour &col )
 {
     ENSURE_LOADED_OR_RETURN(wxNullGraphicsFont);


@@ -2355,6 +2494,19 @@ wxGraphicsFont wxCairoRenderer::CreateFont( const wxFont &font , const wxColour
         return wxNullGraphicsFont;
 }
 
         return wxNullGraphicsFont;
 }
 

+wxGraphicsFont
+wxCairoRenderer::CreateFont(double sizeInPixels,
+                            const wxString& facename,
+                            int flags,
+                            const wxColour& col)
+{
+    ENSURE_LOADED_OR_RETURN(wxNullGraphicsFont);
+
+    wxGraphicsFont font;
+    font.SetRefData(new wxCairoFontData(this, sizeInPixels, facename, flags, col));
+    return font;
+}
+

 wxGraphicsBitmap wxCairoRenderer::CreateBitmap( const wxBitmap& bmp )
 {
     ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap);
 wxGraphicsBitmap wxCairoRenderer::CreateBitmap( const wxBitmap& bmp )
 {
     ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap);


@@ -2368,6 +2520,35 @@ wxGraphicsBitmap wxCairoRenderer::CreateBitmap( const wxBitmap& bmp )
         return wxNullGraphicsBitmap;
 }
 
         return wxNullGraphicsBitmap;
 }
 

+#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)
+{
+    ENSURE_LOADED_OR_RETURN(wxNullImage);
+
+    const wxCairoBitmapData* const
+        data = static_cast<wxCairoBitmapData*>(bmp.GetGraphicsData());
+
+    return data ? data->ConvertToImage() : wxNullImage;
+}
+
+#endif // wxUSE_IMAGE
+
+

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