Revert "Make wxMSW stack walking methods work with Unicode identifiers."

[wxWidgets.git] / src / gtk / dcclient.cpp

diff --git a/src/gtk/dcclient.cpp b/src/gtk/dcclient.cpp
index 4c4416ebe13449da3a2a2e1b4373e32237ecb7b1..a11615391e6d7b77e6107050452af4740b202503 100644 (file)
--- a/src/gtk/dcclient.cpp
+++ b/src/gtk/dcclient.cpp
@@ -2,7 +2,6 @@
 // Name:        src/gtk/dcclient.cpp
 // Purpose:     wxWindowDCImpl implementation
 // Author:      Robert Roebling
 // Name:        src/gtk/dcclient.cpp
 // Purpose:     wxWindowDCImpl implementation
 // Author:      Robert Roebling

-// RCS-ID:      $Id$

 // Copyright:   (c) 1998 Robert Roebling, Chris Breeze
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 // Copyright:   (c) 1998 Robert Roebling, Chris Breeze
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////


@@ -64,8 +63,6 @@ static const double RAD2DEG  = 180.0 / M_PI;
 static inline double dmax(double a, double b) { return a > b ? a : b; }
 static inline double dmin(double a, double b) { return a < b ? a : b; }
 
 static inline double dmax(double a, double b) { return a > b ? a : b; }
 static inline double dmin(double a, double b) { return a < b ? a : b; }
 

-static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
-

 static GdkPixmap* GetHatch(int style)
 {
     wxASSERT(style >= wxBRUSHSTYLE_FIRST_HATCH && style <= wxBRUSHSTYLE_LAST_HATCH);
 static GdkPixmap* GetHatch(int style)
 {
     wxASSERT(style >= wxBRUSHSTYLE_FIRST_HATCH && style <= wxBRUSHSTYLE_LAST_HATCH);


@@ -697,7 +694,7 @@ void wxWindowDCImpl::DoDrawPoint( wxCoord x, wxCoord y )
     CalcBoundingBox (x, y);
 }
 
     CalcBoundingBox (x, y);
 }
 

-void wxWindowDCImpl::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset )
+void wxWindowDCImpl::DoDrawLines( int n, const wxPoint points[], wxCoord xoffset, wxCoord yoffset )

 {
     wxCHECK_RET( IsOk(), wxT("invalid window dc") );
 
 {
     wxCHECK_RET( IsOk(), wxT("invalid window dc") );
 


@@ -711,29 +708,32 @@ void wxWindowDCImpl::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCo
         xoffset != 0 || yoffset != 0 || XLOG2DEV(10) != 10 || YLOG2DEV(10) != 10;
 
     // GdkPoint and wxPoint have the same memory layout, so we can cast one to the other
         xoffset != 0 || yoffset != 0 || XLOG2DEV(10) != 10 || YLOG2DEV(10) != 10;
 
     // GdkPoint and wxPoint have the same memory layout, so we can cast one to the other

-    GdkPoint* gpts = reinterpret_cast<GdkPoint*>(points);
+    const GdkPoint* gpts = reinterpret_cast<const GdkPoint*>(points);
+    GdkPoint* gpts_alloc = NULL;

 
     if (doScale)
 
     if (doScale)

-        gpts = new GdkPoint[n];
+    {
+        gpts_alloc = new GdkPoint[n];
+        gpts = gpts_alloc;
+    }

 
     for (int i = 0; i < n; i++)
     {
         if (doScale)
         {
 
     for (int i = 0; i < n; i++)
     {
         if (doScale)
         {

-            gpts[i].x = XLOG2DEV(points[i].x + xoffset);
-            gpts[i].y = YLOG2DEV(points[i].y + yoffset);
+            gpts_alloc[i].x = XLOG2DEV(points[i].x + xoffset);
+            gpts_alloc[i].y = YLOG2DEV(points[i].y + yoffset);

         }
         CalcBoundingBox(points[i].x + xoffset, points[i].y + yoffset);
     }
 
     if (m_gdkwindow)
         }
         CalcBoundingBox(points[i].x + xoffset, points[i].y + yoffset);
     }
 
     if (m_gdkwindow)

-        gdk_draw_lines( m_gdkwindow, m_penGC, gpts, n);
+        gdk_draw_lines( m_gdkwindow, m_penGC, (GdkPoint*) gpts, n);

 
 

-    if (doScale)
-        delete[] gpts;
+    delete[] gpts_alloc;

 }
 
 }
 

-void wxWindowDCImpl::DoDrawPolygon( int n, wxPoint points[],
+void wxWindowDCImpl::DoDrawPolygon( int n, const wxPoint points[],

                                     wxCoord xoffset, wxCoord yoffset,
                                     wxPolygonFillMode WXUNUSED(fillStyle) )
 {
                                     wxCoord xoffset, wxCoord yoffset,
                                     wxPolygonFillMode WXUNUSED(fillStyle) )
 {


@@ -746,18 +746,22 @@ void wxWindowDCImpl::DoDrawPolygon( int n, wxPoint points[],
         xoffset != 0 || yoffset != 0 || XLOG2DEV(10) != 10 || YLOG2DEV(10) != 10;
 
     // GdkPoint and wxPoint have the same memory layout, so we can cast one to the other
         xoffset != 0 || yoffset != 0 || XLOG2DEV(10) != 10 || YLOG2DEV(10) != 10;
 
     // GdkPoint and wxPoint have the same memory layout, so we can cast one to the other

-    GdkPoint* gdkpoints = reinterpret_cast<GdkPoint*>(points);
+    const GdkPoint* gdkpoints = reinterpret_cast<const GdkPoint*>(points);
+    GdkPoint* gdkpoints_alloc = NULL;

 
     if (doScale)
 
     if (doScale)

-        gdkpoints = new GdkPoint[n];
+    {
+        gdkpoints_alloc = new GdkPoint[n];
+        gdkpoints = gdkpoints_alloc;
+    }

 
     int i;
     for (i = 0 ; i < n ; i++)
     {
         if (doScale)
         {
 
     int i;
     for (i = 0 ; i < n ; i++)
     {
         if (doScale)
         {

-            gdkpoints[i].x = XLOG2DEV(points[i].x + xoffset);
-            gdkpoints[i].y = YLOG2DEV(points[i].y + yoffset);
+            gdkpoints_alloc[i].x = XLOG2DEV(points[i].x + xoffset);
+            gdkpoints_alloc[i].y = YLOG2DEV(points[i].y + yoffset);

         }
         CalcBoundingBox(points[i].x + xoffset, points[i].y + yoffset);
     }
         }
         CalcBoundingBox(points[i].x + xoffset, points[i].y + yoffset);
     }


@@ -770,7 +774,7 @@ void wxWindowDCImpl::DoDrawPolygon( int n, wxPoint points[],
             bool originChanged;
             DrawingSetup(gc, originChanged);
 
             bool originChanged;
             DrawingSetup(gc, originChanged);
 

-            gdk_draw_polygon(m_gdkwindow, gc, true, gdkpoints, n);
+            gdk_draw_polygon(m_gdkwindow, gc, true, (GdkPoint*) gdkpoints, n);

 
             if (originChanged)
                 gdk_gc_set_ts_origin(gc, 0, 0);
 
             if (originChanged)
                 gdk_gc_set_ts_origin(gc, 0, 0);


@@ -788,13 +792,12 @@ void wxWindowDCImpl::DoDrawPolygon( int n, wxPoint points[],
                                gdkpoints[(i+1)%n].y);
             }
 */
                                gdkpoints[(i+1)%n].y);
             }
 */

-            gdk_draw_polygon( m_gdkwindow, m_penGC, FALSE, gdkpoints, n );
+            gdk_draw_polygon( m_gdkwindow, m_penGC, FALSE, (GdkPoint*) gdkpoints, n );

 
         }
     }
 
 
         }
     }
 

-    if (doScale)
-        delete[] gdkpoints;
+    delete[] gdkpoints_alloc;

 }
 
 void wxWindowDCImpl::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 }
 
 void wxWindowDCImpl::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height )


@@ -990,7 +993,7 @@ void wxWindowDCImpl::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y )
     DoDrawBitmap( (const wxBitmap&)icon, x, y, true );
 }
 
     DoDrawBitmap( (const wxBitmap&)icon, x, y, true );
 }
 

-// scale a pixbuf, return new pixbuf, unref old one
+// scale a pixbuf

 static GdkPixbuf*
 Scale(GdkPixbuf* pixbuf, int dst_w, int dst_h, double sx, double sy)
 {
 static GdkPixbuf*
 Scale(GdkPixbuf* pixbuf, int dst_w, int dst_h, double sx, double sy)
 {


@@ -998,20 +1001,21 @@ Scale(GdkPixbuf* pixbuf, int dst_w, int dst_h, double sx, double sy)
         GDK_COLORSPACE_RGB, gdk_pixbuf_get_has_alpha(pixbuf), 8, dst_w, dst_h);
     gdk_pixbuf_scale(pixbuf, pixbuf_scaled,
         0, 0, dst_w, dst_h, 0, 0, sx, sy, GDK_INTERP_NEAREST);
         GDK_COLORSPACE_RGB, gdk_pixbuf_get_has_alpha(pixbuf), 8, dst_w, dst_h);
     gdk_pixbuf_scale(pixbuf, pixbuf_scaled,
         0, 0, dst_w, dst_h, 0, 0, sx, sy, GDK_INTERP_NEAREST);

-    g_object_unref(pixbuf);

     return pixbuf_scaled;
 }
 
     return pixbuf_scaled;
 }
 

-// scale part of a pixmap using pixbuf scaling, return pixbuf
+// scale part of a pixmap using pixbuf scaling

 static GdkPixbuf*
 Scale(GdkPixmap* pixmap, int x, int y, int w, int h, int dst_w, int dst_h, double sx, double sy)
 {
     GdkPixbuf* pixbuf = gdk_pixbuf_get_from_drawable(
         NULL, pixmap, NULL, x, y, 0, 0, w, h);
 static GdkPixbuf*
 Scale(GdkPixmap* pixmap, int x, int y, int w, int h, int dst_w, int dst_h, double sx, double sy)
 {
     GdkPixbuf* pixbuf = gdk_pixbuf_get_from_drawable(
         NULL, pixmap, NULL, x, y, 0, 0, w, h);

-    return Scale(pixbuf, dst_w, dst_h, sx, sy);
+    GdkPixbuf* pixbuf2 = Scale(pixbuf, dst_w, dst_h, sx, sy);
+    g_object_unref(pixbuf);
+    return pixbuf2;

 }
 
 }
 

-// scale part of a mask pixmap, return new mask, unref old one
+// scale part of a mask pixmap

 static GdkPixmap*
 ScaleMask(GdkPixmap* mask, int x, int y, int w, int h, int dst_w, int dst_h, double sx, double sy)
 {
 static GdkPixmap*
 ScaleMask(GdkPixmap* mask, int x, int y, int w, int h, int dst_w, int dst_h, double sx, double sy)
 {


@@ -1035,12 +1039,10 @@ ScaleMask(GdkPixmap* mask, int x, int y, int w, int h, int dst_w, int dst_h, dou
     g_object_unref(pixbuf);
     GdkPixmap* pixmap = gdk_bitmap_create_from_data(mask, data, dst_w, dst_h);
     delete[] data;
     g_object_unref(pixbuf);
     GdkPixmap* pixmap = gdk_bitmap_create_from_data(mask, data, dst_w, dst_h);
     delete[] data;

-    g_object_unref(mask);

     return pixmap;
 }
 
 // Make a new mask from part of a mask and a clip region.
     return pixmap;
 }
 
 // Make a new mask from part of a mask and a clip region.

-// Return new mask, unref old one.

 static GdkPixmap*
 ClipMask(GdkPixmap* mask, GdkRegion* clipRegion, int x, int y, int dst_x, int dst_y, int w, int h)
 {
 static GdkPixmap*
 ClipMask(GdkPixmap* mask, GdkRegion* clipRegion, int x, int y, int dst_x, int dst_y, int w, int h)
 {


@@ -1055,7 +1057,6 @@ ClipMask(GdkPixmap* mask, GdkRegion* clipRegion, int x, int y, int dst_x, int ds
     // draw old mask onto new one, with clip
     gdk_draw_drawable(pixmap, gc, mask, x, y, 0, 0, w, h);
     g_object_unref(gc);
     // draw old mask onto new one, with clip
     gdk_draw_drawable(pixmap, gc, mask, x, y, 0, 0, w, h);
     g_object_unref(gc);

-    g_object_unref(mask);

     return pixmap;
 }
 
     return pixmap;
 }
 


@@ -1126,18 +1127,25 @@ void wxWindowDCImpl::DoDrawBitmap( const wxBitmap &bitmap,
     {
         wxMask* m = bitmap.GetMask();
         if (m)
     {
         wxMask* m = bitmap.GetMask();
         if (m)

-            mask = m->GetBitmap();
+            mask = *m;

     }
     }

+
+    GdkPixmap* mask_new = NULL;

     if (mask)
     {
     if (mask)
     {

-        g_object_ref(mask);

         if (isScaled)
         if (isScaled)

+        {

             mask = ScaleMask(mask, 0, 0, w, h, ww, hh, m_scaleX, m_scaleY);
             mask = ScaleMask(mask, 0, 0, w, h, ww, hh, m_scaleX, m_scaleY);

+            mask_new = mask;
+        }

         if (overlap == wxPartRegion)
         {
             // need a new mask that also masks the clipped area,
             // because gc can't have both a mask and a clip region
             mask = ClipMask(mask, clipRegion, 0, 0, xx, yy, ww, hh);
         if (overlap == wxPartRegion)
         {
             // need a new mask that also masks the clipped area,
             // because gc can't have both a mask and a clip region
             mask = ClipMask(mask, clipRegion, 0, 0, xx, yy, ww, hh);

+            if (mask_new)
+                g_object_unref(mask_new);
+            mask_new = mask;

         }
         gdk_gc_set_clip_mask(use_gc, mask);
         gdk_gc_set_clip_origin(use_gc, xx, yy);
         }
         gdk_gc_set_clip_mask(use_gc, mask);
         gdk_gc_set_clip_origin(use_gc, xx, yy);


@@ -1145,24 +1153,22 @@ void wxWindowDCImpl::DoDrawBitmap( const wxBitmap &bitmap,
 
     // determine whether to use pixmap or pixbuf
     GdkPixmap* pixmap = NULL;
 
     // determine whether to use pixmap or pixbuf
     GdkPixmap* pixmap = NULL;

+    GdkPixmap* pixmap_new = NULL;

     GdkPixbuf* pixbuf = NULL;
     GdkPixbuf* pixbuf = NULL;

+    GdkPixbuf* pixbuf_new = NULL;

     if (bitmap.HasPixmap())
         pixmap = bitmap.GetPixmap();
     if (pixmap && gdk_drawable_get_depth(pixmap) == 1)
     {
     if (bitmap.HasPixmap())
         pixmap = bitmap.GetPixmap();
     if (pixmap && gdk_drawable_get_depth(pixmap) == 1)
     {

-        // convert mono pixmap to color using text fg/bg colors
-        pixmap = MonoToColor(pixmap, 0, 0, w, h);
+        if (gdk_drawable_get_depth(m_gdkwindow) != 1)
+        {
+            // convert mono pixmap to color using text fg/bg colors
+            pixmap = MonoToColor(pixmap, 0, 0, w, h);
+            pixmap_new = pixmap;
+        }

     }
     else if (hasAlpha || pixmap == NULL)
     }
     else if (hasAlpha || pixmap == NULL)

-    {
-        pixmap = NULL;

         pixbuf = bitmap.GetPixbuf();
         pixbuf = bitmap.GetPixbuf();

-        g_object_ref(pixbuf);
-    }
-    else
-    {
-        g_object_ref(pixmap);
-    }

 
     if (isScaled)
     {
 
     if (isScaled)
     {


@@ -1170,25 +1176,34 @@ void wxWindowDCImpl::DoDrawBitmap( const wxBitmap &bitmap,
             pixbuf = Scale(pixbuf, ww, hh, m_scaleX, m_scaleY);
         else
             pixbuf = Scale(pixmap, 0, 0, w, h, ww, hh, m_scaleX, m_scaleY);
             pixbuf = Scale(pixbuf, ww, hh, m_scaleX, m_scaleY);
         else
             pixbuf = Scale(pixmap, 0, 0, w, h, ww, hh, m_scaleX, m_scaleY);

+
+        pixbuf_new = pixbuf;

     }
 
     if (pixbuf)
     {
         gdk_draw_pixbuf(m_gdkwindow, use_gc, pixbuf,
             0, 0, xx, yy, ww, hh, GDK_RGB_DITHER_NORMAL, 0, 0);
     }
 
     if (pixbuf)
     {
         gdk_draw_pixbuf(m_gdkwindow, use_gc, pixbuf,
             0, 0, xx, yy, ww, hh, GDK_RGB_DITHER_NORMAL, 0, 0);

-        g_object_unref(pixbuf);

     }
     else
     {
         gdk_draw_drawable(m_gdkwindow, use_gc, pixmap, 0, 0, xx, yy, ww, hh);
     }
 
     }
     else
     {
         gdk_draw_drawable(m_gdkwindow, use_gc, pixmap, 0, 0, xx, yy, ww, hh);
     }
 

-    if (pixmap)
-        g_object_unref(pixmap);
+    if (pixbuf_new)
+        g_object_unref(pixbuf_new);
+    if (pixmap_new)
+        g_object_unref(pixmap_new);

     if (mask)
     {
     if (mask)
     {

-        g_object_unref(mask);

         gdk_gc_set_clip_region(use_gc, clipRegion);
         gdk_gc_set_clip_region(use_gc, clipRegion);

+
+        // Notice that we can only release the mask now, we can't do it before
+        // the calls to gdk_draw_xxx() above as they crash with X error with
+        // GTK+ up to 2.20.1 (i.e. it works with 2.20 but is known to not work
+        // with 2.16.1 and below).
+        if (mask_new)
+            g_object_unref(mask_new);

     }
 }
 
     }
 }
 


@@ -1218,7 +1233,7 @@ bool wxWindowDCImpl::DoBlit( wxCoord xdest, wxCoord ydest,
         {
             wxMask* m = bitmap.GetMask();
             if (m)
         {
             wxMask* m = bitmap.GetMask();
             if (m)

-                mask = m->GetBitmap();
+                mask = *m;

         }
     }
     else
         }
     }
     else


@@ -1298,7 +1313,6 @@ bool wxWindowDCImpl::DoBlit( wxCoord xdest, wxCoord ydest,
 
     if (mask)
     {
 
     if (mask)
     {

-        g_object_ref(mask);

         int srcMask_x = src_x;
         int srcMask_y = src_y;
         if (xsrcMask != -1 || ysrcMask != -1)
         int srcMask_x = src_x;
         int srcMask_y = src_y;
         if (xsrcMask != -1 || ysrcMask != -1)


@@ -1306,10 +1320,12 @@ bool wxWindowDCImpl::DoBlit( wxCoord xdest, wxCoord ydest,
             srcMask_x = source->LogicalToDeviceX(xsrcMask);
             srcMask_y = source->LogicalToDeviceY(ysrcMask);
         }
             srcMask_x = source->LogicalToDeviceX(xsrcMask);
             srcMask_y = source->LogicalToDeviceY(ysrcMask);
         }

+        GdkPixmap* mask_new = NULL;

         if (isScaled)
         {
             mask = ScaleMask(mask, srcMask_x, srcMask_y,
                 src_w, src_h, dst_w, dst_h, scale_x, scale_y);
         if (isScaled)
         {
             mask = ScaleMask(mask, srcMask_x, srcMask_y,
                 src_w, src_h, dst_w, dst_h, scale_x, scale_y);

+            mask_new = mask;

             srcMask_x = 0;
             srcMask_y = 0;
         }
             srcMask_x = 0;
             srcMask_y = 0;
         }


@@ -1319,15 +1335,21 @@ bool wxWindowDCImpl::DoBlit( wxCoord xdest, wxCoord ydest,
             // because gc can't have both a mask and a clip region
             mask = ClipMask(mask, clipRegion,
                 srcMask_x, srcMask_y, dst_x, dst_y, dst_w, dst_h);
             // because gc can't have both a mask and a clip region
             mask = ClipMask(mask, clipRegion,
                 srcMask_x, srcMask_y, dst_x, dst_y, dst_w, dst_h);

+            if (mask_new)
+                g_object_unref(mask_new);
+            mask_new = mask;

             srcMask_x = 0;
             srcMask_y = 0;
         }
         gdk_gc_set_clip_mask(use_gc, mask);
         gdk_gc_set_clip_origin(use_gc, dst_x - srcMask_x, dst_y - srcMask_y);
             srcMask_x = 0;
             srcMask_y = 0;
         }
         gdk_gc_set_clip_mask(use_gc, mask);
         gdk_gc_set_clip_origin(use_gc, dst_x - srcMask_x, dst_y - srcMask_y);

+        if (mask_new)
+            g_object_unref(mask_new);

     }
 
     GdkPixmap* pixmap = NULL;
     }
 
     GdkPixmap* pixmap = NULL;

-    if (gdk_drawable_get_depth(srcDrawable) == 1)
+    if (gdk_drawable_get_depth(srcDrawable) == 1 &&
+        (gdk_drawable_get_depth(m_gdkwindow) != 1 || isScaled))

     {
         // Convert mono pixmap to color using text fg/bg colors.
         // Scaling/drawing is simpler if this is done first.
     {
         // Convert mono pixmap to color using text fg/bg colors.
         // Scaling/drawing is simpler if this is done first.


@@ -1363,10 +1385,8 @@ bool wxWindowDCImpl::DoBlit( wxCoord xdest, wxCoord ydest,
     if (pixmap)
         g_object_unref(pixmap);
     if (mask)
     if (pixmap)
         g_object_unref(pixmap);
     if (mask)

-    {
-        g_object_unref(mask);

         gdk_gc_set_clip_region(use_gc, clipRegion);
         gdk_gc_set_clip_region(use_gc, clipRegion);

-    }
+

     return true;
 }
 
     return true;
 }
 


@@ -1374,158 +1394,75 @@ void wxWindowDCImpl::DoDrawText(const wxString& text,
                                 wxCoord xLogical,
                                 wxCoord yLogical)
 {
                                 wxCoord xLogical,
                                 wxCoord yLogical)
 {

-    wxCHECK_RET( IsOk(), wxT("invalid window dc") );
-
-    if (!m_gdkwindow) return;
-
-    if (text.empty()) return;
-
-    wxCoord x = XLOG2DEV(xLogical),
-            y = YLOG2DEV(yLogical);
-
-    wxCHECK_RET( m_context, wxT("no Pango context") );
-    wxCHECK_RET( m_layout, wxT("no Pango layout") );
-    wxCHECK_RET( m_fontdesc, wxT("no Pango font description") );
-
-    gdk_pango_context_set_colormap( m_context, m_cmap );  // not needed in gtk+ >= 2.6
-
-    wxCharBuffer data = wxGTK_CONV(text);
-    if ( !data )
-        return;
-
-    pango_layout_set_text(m_layout, data, data.length());
-    const bool setAttrs = m_font.GTKSetPangoAttrs(m_layout);
-
-    int oldSize = 0;
-    const bool isScaled = fabs(m_scaleY - 1.0) > 0.00001;
-    if (isScaled)
-    {
-        // If there is a user or actually any scale applied to
-        // the device context, scale the font.
-
-        // scale font description
-        oldSize = pango_font_description_get_size(m_fontdesc);
-        pango_font_description_set_size(m_fontdesc, int(oldSize * m_scaleY));
-
-        // actually apply scaled font
-        pango_layout_set_font_description( m_layout, m_fontdesc );
-    }
-
-    int w, h;
-    pango_layout_get_pixel_size(m_layout, &w, &h);
-
-    // Draw layout.
-    int x_rtl = x;
-    if (m_window && m_window->GetLayoutDirection() == wxLayout_RightToLeft)
-        x_rtl -= w;
-
-    const GdkColor* bg_col = NULL;
-    if (m_backgroundMode == wxBRUSHSTYLE_SOLID)
-        bg_col = m_textBackgroundColour.GetColor();
-
-    gdk_draw_layout_with_colors(m_gdkwindow, m_textGC, x_rtl, y, m_layout, NULL, bg_col);
-
-    if (isScaled)
-    {
-         // reset unscaled size
-         pango_font_description_set_size( m_fontdesc, oldSize );
-
-         // actually apply unscaled font
-         pango_layout_set_font_description( m_layout, m_fontdesc );
-    }
-    if (setAttrs)
-    {
-        // undo underline attributes setting:
-        pango_layout_set_attributes(m_layout, NULL);
-    }
-
-    CalcBoundingBox(xLogical + int(w / m_scaleX), yLogical + int(h / m_scaleY));
-    CalcBoundingBox(xLogical, yLogical);
+    DoDrawRotatedText(text, xLogical, yLogical, 0);

 }
 
 }
 

-// TODO: When GTK2.6 is required, merge DoDrawText and DoDrawRotatedText to
-// avoid code duplication
-void wxWindowDCImpl::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y, double angle )
+void wxWindowDCImpl::DoDrawRotatedText(const wxString& text, int xLogical, int yLogical, double angle)

 {
     if (!m_gdkwindow || text.empty())
         return;
 
     wxCHECK_RET( IsOk(), wxT("invalid window dc") );
 
 {
     if (!m_gdkwindow || text.empty())
         return;
 
     wxCHECK_RET( IsOk(), wxT("invalid window dc") );
 

-    x = XLOG2DEV(x);
-    y = YLOG2DEV(y);
-

     pango_layout_set_text(m_layout, wxGTK_CONV(text), -1);
     const bool setAttrs = m_font.GTKSetPangoAttrs(m_layout);
     pango_layout_set_text(m_layout, wxGTK_CONV(text), -1);
     const bool setAttrs = m_font.GTKSetPangoAttrs(m_layout);

-    int oldSize = 0;
-    const bool isScaled = fabs(m_scaleY - 1.0) > 0.00001;
-    if (isScaled)
-    {
-        //TODO: when Pango >= 1.6 is required, use pango_matrix_scale()
-         // If there is a user or actually any scale applied to
-         // the device context, scale the font.
-
-         // scale font description
-        oldSize = pango_font_description_get_size(m_fontdesc);
-        pango_font_description_set_size(m_fontdesc, int(oldSize * m_scaleY));
-
-         // actually apply scaled font
-         pango_layout_set_font_description( m_layout, m_fontdesc );
-    }
-
-    int w, h;
-    pango_layout_get_pixel_size(m_layout, &w, &h);

 
     const GdkColor* bg_col = NULL;
     if (m_backgroundMode == wxBRUSHSTYLE_SOLID)
         bg_col = m_textBackgroundColour.GetColor();
 
 
     const GdkColor* bg_col = NULL;
     if (m_backgroundMode == wxBRUSHSTYLE_SOLID)
         bg_col = m_textBackgroundColour.GetColor();
 

-    // rotate the text

     PangoMatrix matrix = PANGO_MATRIX_INIT;
     PangoMatrix matrix = PANGO_MATRIX_INIT;

-    pango_matrix_rotate (&matrix, angle);
-    pango_context_set_matrix (m_context, &matrix);
-    pango_layout_context_changed (m_layout);
-
-    // To be compatible with MSW, the rotation axis must be in the old
-    // top-left corner.
-    // Calculate the vertices of the rotated rectangle containing the text,
-    // relative to the old top-left vertex.
-    // We could use the matrix for this, but it's simpler with trignonometry.
-    double rad = DegToRad(angle);
-    // the rectangle vertices are counted clockwise with the first one
-    // being at (0, 0)
-    double x2 = w * cos(rad);
-    double y2 = -w * sin(rad);   // y axis points to the bottom, hence minus
-    double x4 = h * sin(rad);
-    double y4 = h * cos(rad);
-    double x3 = x4 + x2;
-    double y3 = y4 + y2;
-    // Then we calculate max and min of the rotated rectangle.
-    wxCoord maxX = (wxCoord)(dmax(dmax(0, x2), dmax(x3, x4)) + 0.5),
-            maxY = (wxCoord)(dmax(dmax(0, y2), dmax(y3, y4)) + 0.5),
-            minX = (wxCoord)(dmin(dmin(0, x2), dmin(x3, x4)) - 0.5),
-            minY = (wxCoord)(dmin(dmin(0, y2), dmin(y3, y4)) - 0.5);
-
-    gdk_draw_layout_with_colors(m_gdkwindow, m_textGC, x+minX, y+minY,
-                                m_layout, NULL, bg_col);
+    if (!wxIsSameDouble(m_scaleX, 1) || !wxIsSameDouble(m_scaleY, 1) || !wxIsNullDouble(angle))
+    {
+        pango_matrix_scale(&matrix, m_scaleX, m_scaleY);
+        pango_matrix_rotate(&matrix, angle);
+        pango_context_set_matrix(m_context, &matrix);
+        pango_layout_context_changed(m_layout);
+    }

 
 

-    if (setAttrs)
-        pango_layout_set_attributes(m_layout, NULL);
+    int w, h;
+    pango_layout_get_pixel_size(m_layout, &w, &h);

 
 

-    // clean up the transformation matrix
-    pango_context_set_matrix(m_context, NULL);
+    int x = LogicalToDeviceX(xLogical);
+    int y = LogicalToDeviceY(yLogical);
+    if (m_window && m_window->GetLayoutDirection() == wxLayout_RightToLeft)
+        x -= LogicalToDeviceXRel(w);

 
 

-    if (isScaled)
+    if (wxIsNullDouble(angle))

     {
     {

-         // reset unscaled size
-         pango_font_description_set_size( m_fontdesc, oldSize );
-
-         // actually apply unscaled font
-         pango_layout_set_font_description( m_layout, m_fontdesc );
+        CalcBoundingBox(xLogical, yLogical);
+        CalcBoundingBox(xLogical + w, yLogical + h);

     }
     }

+    else
+    {
+        // To be compatible with MSW, the rotation axis must be in the old
+        // top-left corner.
+        // Calculate the vertices of the rotated rectangle containing the text,
+        // relative to the old top-left vertex.
+        // the rectangle vertices are counted clockwise with the first one
+        // being at (0, 0)
+        double x2 = w * matrix.xx;
+        double y2 = w * matrix.yx;
+        double x4 = h * matrix.xy;
+        double y4 = h * matrix.yy;
+        double x3 = x4 + x2;
+        double y3 = y4 + y2;
+        // Then we calculate max and min of the rotated rectangle.
+        wxCoord maxX = (wxCoord)(dmax(dmax(0, x2), dmax(x3, x4)) + 0.5),
+                maxY = (wxCoord)(dmax(dmax(0, y2), dmax(y3, y4)) + 0.5),
+                minX = (wxCoord)(dmin(dmin(0, x2), dmin(x3, x4)) - 0.5),
+                minY = (wxCoord)(dmin(dmin(0, y2), dmin(y3, y4)) - 0.5);
+        x += minX;
+        y += minY;
+        CalcBoundingBox(DeviceToLogicalX(x), DeviceToLogicalY(y));
+        CalcBoundingBox(DeviceToLogicalX(x + maxX - minX), DeviceToLogicalY(y + maxY - minY));
+    }
+
+    gdk_draw_layout_with_colors(m_gdkwindow, m_textGC, x, y, m_layout, NULL, bg_col);

 
 

-    CalcBoundingBox(x+minX, y+minY);
-    CalcBoundingBox(x+maxX, y+maxY);
+    pango_context_set_matrix(m_context, NULL);
+    if (setAttrs)
+        pango_layout_set_attributes(m_layout, NULL);

 }
 
 void wxWindowDCImpl::DoGetTextExtent(const wxString &string,
 }
 
 void wxWindowDCImpl::DoGetTextExtent(const wxString &string,


@@ -1781,7 +1718,7 @@ void wxWindowDCImpl::SetBrush( const wxBrush &brush )
     if ((m_brush.GetStyle() == wxBRUSHSTYLE_STIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
     {
         gdk_gc_set_fill( m_textGC, GDK_OPAQUE_STIPPLED);
     if ((m_brush.GetStyle() == wxBRUSHSTYLE_STIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
     {
         gdk_gc_set_fill( m_textGC, GDK_OPAQUE_STIPPLED);

-        gdk_gc_set_stipple( m_textGC, m_brush.GetStipple()->GetMask()->GetBitmap() );
+        gdk_gc_set_stipple( m_textGC, *m_brush.GetStipple()->GetMask() );

     }
 
     if (m_brush.IsHatch())
     }
 
     if (m_brush.IsHatch())


@@ -2103,10 +2040,7 @@ void wxClientDCImpl::DoGetSize(int *width, int *height) const
 {
     wxCHECK_RET( m_window, wxT("GetSize() doesn't work without window") );
 
 {
     wxCHECK_RET( m_window, wxT("GetSize() doesn't work without window") );
 

-    if (m_window->m_wxwindow && m_gdkwindow)
-        gdk_drawable_get_size(m_gdkwindow, width, height);
-    else
-        m_window->GetClientSize(width, height);
+    m_window->GetClientSize(width, height);

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