Fix wxHtmlHelpData::SetTempDir() to behave correctly without trailing slash.

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

diff --git a/src/gtk/dcclient.cpp b/src/gtk/dcclient.cpp
index 943b9b3b02ee9991927ac8c2526dbcb83b9d7796..a11615391e6d7b77e6107050452af4740b202503 100644 (file)
--- a/src/gtk/dcclient.cpp
+++ b/src/gtk/dcclient.cpp
@@ -1,8 +1,7 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        src/gtk/dcclient.cpp
 /////////////////////////////////////////////////////////////////////////////
 // Name:        src/gtk/dcclient.cpp

-// Purpose:
+// Purpose:     wxWindowDCImpl implementation

 // Author:      Robert Roebling
 // 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
 /////////////////////////////////////////////////////////////////////////////


@@ -25,6 +24,7 @@
 
 #include "wx/gtk/private.h"
 #include "wx/gtk/private/object.h"
 
 #include "wx/gtk/private.h"
 #include "wx/gtk/private/object.h"

+#include "wx/private/textmeasure.h"

 
 //-----------------------------------------------------------------------------
 // local defines
 
 //-----------------------------------------------------------------------------
 // local defines


@@ -63,35 +63,48 @@ 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);
     const int i = style - wxBRUSHSTYLE_FIRST_HATCH;
     if (hatches[i] == NULL)
     {
 static GdkPixmap* GetHatch(int style)
 {
     wxASSERT(style >= wxBRUSHSTYLE_FIRST_HATCH && style <= wxBRUSHSTYLE_LAST_HATCH);
     const int i = style - wxBRUSHSTYLE_FIRST_HATCH;
     if (hatches[i] == NULL)
     {

+        // This macro creates a bitmap from an XBM file included above. Notice
+        // the need for the cast because gdk_bitmap_create_from_data() doesn't
+        // accept unsigned data but the arrays in XBM need to be unsigned to
+        // avoid warnings (and even errors in C+0x mode) from g++.
+#define CREATE_FROM_XBM_DATA(name) \
+        gdk_bitmap_create_from_data \
+        ( \
+            NULL, \
+            reinterpret_cast<gchar *>(name ## _bits), \
+            name ## _width, \
+            name ## _height \
+        )
+

         switch (style)
         {
         case wxBRUSHSTYLE_BDIAGONAL_HATCH:
         switch (style)
         {
         case wxBRUSHSTYLE_BDIAGONAL_HATCH:

-            hatches[i] = gdk_bitmap_create_from_data(NULL, bdiag_bits, bdiag_width, bdiag_height);
+            hatches[i] = CREATE_FROM_XBM_DATA(bdiag);

             break;
         case wxBRUSHSTYLE_CROSSDIAG_HATCH:
             break;
         case wxBRUSHSTYLE_CROSSDIAG_HATCH:

-            hatches[i] = gdk_bitmap_create_from_data(NULL, cdiag_bits, cdiag_width, cdiag_height);
+            hatches[i] = CREATE_FROM_XBM_DATA(cdiag);

             break;
         case wxBRUSHSTYLE_CROSS_HATCH:
             break;
         case wxBRUSHSTYLE_CROSS_HATCH:

-            hatches[i] = gdk_bitmap_create_from_data(NULL, cross_bits, cross_width, cross_height);
+            hatches[i] = CREATE_FROM_XBM_DATA(cross);

             break;
         case wxBRUSHSTYLE_FDIAGONAL_HATCH:
             break;
         case wxBRUSHSTYLE_FDIAGONAL_HATCH:

-            hatches[i] = gdk_bitmap_create_from_data(NULL, fdiag_bits, fdiag_width, fdiag_height);
+            hatches[i] = CREATE_FROM_XBM_DATA(fdiag);

             break;
         case wxBRUSHSTYLE_HORIZONTAL_HATCH:
             break;
         case wxBRUSHSTYLE_HORIZONTAL_HATCH:

-            hatches[i] = gdk_bitmap_create_from_data(NULL, horiz_bits, horiz_width, horiz_height);
+            hatches[i] = CREATE_FROM_XBM_DATA(horiz);

             break;
         case wxBRUSHSTYLE_VERTICAL_HATCH:
             break;
         case wxBRUSHSTYLE_VERTICAL_HATCH:

-            hatches[i] = gdk_bitmap_create_from_data(NULL, verti_bits, verti_width, verti_height);
+            hatches[i] = CREATE_FROM_XBM_DATA(verti);

             break;
         }
             break;
         }

+
+#undef CREATE_FROM_XBM_DATA

     }
     return hatches[i];
 }
     }
     return hatches[i];
 }


@@ -114,7 +127,11 @@ enum wxPoolGCType
    wxTEXT_SCREEN,
    wxBG_SCREEN,
    wxPEN_SCREEN,
    wxTEXT_SCREEN,
    wxBG_SCREEN,
    wxPEN_SCREEN,

-   wxBRUSH_SCREEN
+   wxBRUSH_SCREEN,
+   wxTEXT_COLOUR_ALPHA,
+   wxBG_COLOUR_ALPHA,
+   wxPEN_COLOUR_ALPHA,
+   wxBRUSH_COLOUR_ALPHA

 };
 
 struct wxGC
 };
 
 struct wxGC


@@ -216,7 +233,7 @@ static GdkGC* wxGetPoolGC( GdkWindow *window, wxPoolGCType type )
     // The realloc failed.  Fall through to error.
     wxFAIL_MSG( wxT("No GC available") );
 
     // The realloc failed.  Fall through to error.
     wxFAIL_MSG( wxT("No GC available") );
 

-    return (GdkGC*) NULL;
+    return NULL;

 }
 
 static void wxFreePoolGC( GdkGC *gc )
 }
 
 static void wxFreePoolGC( GdkGC *gc )


@@ -242,16 +259,16 @@ IMPLEMENT_ABSTRACT_CLASS(wxWindowDCImpl, wxGTKDCImpl)
 wxWindowDCImpl::wxWindowDCImpl( wxDC *owner ) :
    wxGTKDCImpl( owner )
 {
 wxWindowDCImpl::wxWindowDCImpl( wxDC *owner ) :
    wxGTKDCImpl( owner )
 {

-    m_gdkwindow = (GdkWindow*) NULL;
-    m_penGC = (GdkGC *) NULL;
-    m_brushGC = (GdkGC *) NULL;
-    m_textGC = (GdkGC *) NULL;
-    m_bgGC = (GdkGC *) NULL;
-    m_cmap = (GdkColormap *) NULL;
+    m_gdkwindow = NULL;
+    m_penGC = NULL;
+    m_brushGC = NULL;
+    m_textGC = NULL;
+    m_bgGC = NULL;
+    m_cmap = NULL;

     m_isScreenDC = false;
     m_isScreenDC = false;

-    m_context = (PangoContext *)NULL;
-    m_layout = (PangoLayout *)NULL;
-    m_fontdesc = (PangoFontDescription *)NULL;
+    m_context = NULL;
+    m_layout = NULL;
+    m_fontdesc = NULL;

 }
 
 wxWindowDCImpl::wxWindowDCImpl( wxDC *owner, wxWindow *window ) :
 }
 
 wxWindowDCImpl::wxWindowDCImpl( wxDC *owner, wxWindow *window ) :


@@ -259,34 +276,35 @@ wxWindowDCImpl::wxWindowDCImpl( wxDC *owner, wxWindow *window ) :
 {
     wxASSERT_MSG( window, wxT("DC needs a window") );
 
 {
     wxASSERT_MSG( window, wxT("DC needs a window") );
 

-    m_gdkwindow = (GdkWindow*) NULL;
-    m_penGC = (GdkGC *) NULL;
-    m_brushGC = (GdkGC *) NULL;
-    m_textGC = (GdkGC *) NULL;
-    m_bgGC = (GdkGC *) NULL;
-    m_cmap = (GdkColormap *) NULL;
+    m_gdkwindow = NULL;
+    m_penGC = NULL;
+    m_brushGC = NULL;
+    m_textGC = NULL;
+    m_bgGC = NULL;
+    m_cmap = NULL;

     m_isScreenDC = false;
     m_font = window->GetFont();
 
     GtkWidget *widget = window->m_wxwindow;
     m_isScreenDC = false;
     m_font = window->GetFont();
 
     GtkWidget *widget = window->m_wxwindow;

+    m_gdkwindow = window->GTKGetDrawingWindow();

 
     // Some controls don't have m_wxwindow - like wxStaticBox, but the user
 
     // Some controls don't have m_wxwindow - like wxStaticBox, but the user

-    // code should still be able to create wxClientDCs for them, so we will
-    // use the parent window here then.
+    // code should still be able to create wxClientDCs for them

     if ( !widget )
     {
     if ( !widget )
     {

-        window = window->GetParent();
-        widget = window->m_wxwindow;
-    }
+        widget = window->m_widget;
+
+        wxCHECK_RET(widget, "DC needs a widget");

 
 

-    wxASSERT_MSG( widget, wxT("DC needs a widget") );
+        m_gdkwindow = widget->window;
+        if (!gtk_widget_get_has_window(widget))
+            SetDeviceLocalOrigin(widget->allocation.x, widget->allocation.y);
+    }

 
 

-    m_context = window->GtkGetPangoDefaultContext();
+    m_context = window->GTKGetPangoDefaultContext();

     m_layout = pango_layout_new( m_context );
     m_fontdesc = pango_font_description_copy( widget->style->font_desc );
 
     m_layout = pango_layout_new( m_context );
     m_fontdesc = pango_font_description_copy( widget->style->font_desc );
 

-    m_gdkwindow = widget->window;
-

     // Window not realized ?
     if (!m_gdkwindow)
     {
     // Window not realized ?
     if (!m_gdkwindow)
     {


@@ -296,7 +314,7 @@ wxWindowDCImpl::wxWindowDCImpl( wxDC *owner, wxWindow *window ) :
          return;
     }
 
          return;
     }
 

-    m_cmap = gtk_widget_get_colormap( widget ? widget : window->m_widget );
+    m_cmap = gtk_widget_get_colormap(widget);

 
     SetUpDC();
 
 
     SetUpDC();
 


@@ -309,7 +327,7 @@ wxWindowDCImpl::wxWindowDCImpl( wxDC *owner, wxWindow *window ) :
 
     m_window = window;
 
 
     m_window = window;
 

-    if (m_window && m_window->m_wxwindow && 
+    if (m_window && m_window->m_wxwindow &&

         (m_window->GetLayoutDirection() == wxLayout_RightToLeft))
     {
         // reverse sense
         (m_window->GetLayoutDirection() == wxLayout_RightToLeft))
     {
         // reverse sense


@@ -351,7 +369,7 @@ void wxWindowDCImpl::SetUpDC( bool isMemDC )
     }
 
     if (!done)
     }
 
     if (!done)

-    {    
+    {

         if (m_isScreenDC)
         {
             m_penGC = wxGetPoolGC( m_gdkwindow, wxPEN_SCREEN );
         if (m_isScreenDC)
         {
             m_penGC = wxGetPoolGC( m_gdkwindow, wxPEN_SCREEN );


@@ -359,6 +377,18 @@ void wxWindowDCImpl::SetUpDC( bool isMemDC )
             m_textGC = wxGetPoolGC( m_gdkwindow, wxTEXT_SCREEN );
             m_bgGC = wxGetPoolGC( m_gdkwindow, wxBG_SCREEN );
         }
             m_textGC = wxGetPoolGC( m_gdkwindow, wxTEXT_SCREEN );
             m_bgGC = wxGetPoolGC( m_gdkwindow, wxBG_SCREEN );
         }

+#if GTK_CHECK_VERSION(2,12,0)
+        // gdk_screen_get_rgba_colormap was added in 2.8, but this code is for
+        // compositing which requires 2.12
+        else if (gtk_check_version(2,12,0) == NULL &&
+            m_cmap == gdk_screen_get_rgba_colormap(gdk_colormap_get_screen(m_cmap)))
+        {
+            m_penGC = wxGetPoolGC( m_gdkwindow, wxPEN_COLOUR_ALPHA );
+            m_brushGC = wxGetPoolGC( m_gdkwindow, wxBRUSH_COLOUR_ALPHA );
+            m_textGC = wxGetPoolGC( m_gdkwindow, wxTEXT_COLOUR_ALPHA );
+            m_bgGC = wxGetPoolGC( m_gdkwindow, wxBG_COLOUR_ALPHA );
+        }
+#endif

         else
         {
             m_penGC = wxGetPoolGC( m_gdkwindow, wxPEN_COLOUR );
         else
         {
             m_penGC = wxGetPoolGC( m_gdkwindow, wxPEN_COLOUR );


@@ -410,25 +440,25 @@ void wxWindowDCImpl::SetUpDC( bool isMemDC )
     gdk_gc_set_function( m_penGC, GDK_COPY );
 
     /* clipping */
     gdk_gc_set_function( m_penGC, GDK_COPY );
 
     /* clipping */

-    gdk_gc_set_clip_rectangle( m_penGC, (GdkRectangle *) NULL );
-    gdk_gc_set_clip_rectangle( m_brushGC, (GdkRectangle *) NULL );
-    gdk_gc_set_clip_rectangle( m_textGC, (GdkRectangle *) NULL );
-    gdk_gc_set_clip_rectangle( m_bgGC, (GdkRectangle *) NULL );
+    gdk_gc_set_clip_rectangle( m_penGC, NULL );
+    gdk_gc_set_clip_rectangle( m_brushGC, NULL );
+    gdk_gc_set_clip_rectangle( m_textGC, NULL );
+    gdk_gc_set_clip_rectangle( m_bgGC, NULL );

 }
 
 void wxWindowDCImpl::DoGetSize( int* width, int* height ) const
 {
 }
 
 void wxWindowDCImpl::DoGetSize( int* width, int* height ) const
 {

-    wxCHECK_RET( m_window, _T("GetSize() doesn't work without window") );
+    wxCHECK_RET( m_window, wxT("GetSize() doesn't work without window") );

 
     m_window->GetSize(width, height);
 }
 
 bool wxWindowDCImpl::DoFloodFill(wxCoord x, wxCoord y,
 
     m_window->GetSize(width, height);
 }
 
 bool wxWindowDCImpl::DoFloodFill(wxCoord x, wxCoord y,

-                             const wxColour& col, int style)
+                                 const wxColour& col, wxFloodFillStyle style)

 {
 #if wxUSE_IMAGE
     extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
 {
 #if wxUSE_IMAGE
     extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,

-                              const wxColour & col, int style);
+                              const wxColour & col, wxFloodFillStyle style);

 
     return wxDoFloodFill( GetOwner(), x, y, col, style);
 #else
 
     return wxDoFloodFill( GetOwner(), x, y, col, style);
 #else


@@ -475,8 +505,8 @@ bool wxWindowDCImpl::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
 void wxWindowDCImpl::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
 {
     wxCHECK_RET( IsOk(), wxT("invalid window dc") );
 void wxWindowDCImpl::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
 {
     wxCHECK_RET( IsOk(), wxT("invalid window dc") );

-    
-    if (m_pen.GetStyle() != wxPENSTYLE_TRANSPARENT)
+
+    if ( m_pen.IsNonTransparent() )

     {
         if (m_gdkwindow)
             gdk_draw_line( m_gdkwindow, m_penGC, XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
     {
         if (m_gdkwindow)
             gdk_draw_line( m_gdkwindow, m_penGC, XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );


@@ -490,7 +520,7 @@ void wxWindowDCImpl::DoCrossHair( wxCoord x, wxCoord y )
 {
     wxCHECK_RET( IsOk(), wxT("invalid window dc") );
 
 {
     wxCHECK_RET( IsOk(), wxT("invalid window dc") );
 

-    if (m_pen.GetStyle() != wxPENSTYLE_TRANSPARENT)
+    if ( m_pen.IsNonTransparent() )

     {
         int w = 0;
         int h = 0;
     {
         int w = 0;
         int h = 0;


@@ -588,7 +618,7 @@ void wxWindowDCImpl::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
 
     if (m_gdkwindow)
     {
 
     if (m_gdkwindow)
     {

-        if (m_brush.GetStyle() != wxBRUSHSTYLE_TRANSPARENT)
+        if ( m_brush.IsNonTransparent() )

         {
             GdkGC* gc;
             bool originChanged;
         {
             GdkGC* gc;
             bool originChanged;


@@ -600,11 +630,11 @@ void wxWindowDCImpl::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
                 gdk_gc_set_ts_origin(gc, 0, 0);
         }
 
                 gdk_gc_set_ts_origin(gc, 0, 0);
         }
 

-        if (m_pen.GetStyle() != wxPENSTYLE_TRANSPARENT)
+        if ( m_pen.IsNonTransparent() )

         {
             gdk_draw_arc( m_gdkwindow, m_penGC, FALSE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 
         {
             gdk_draw_arc( m_gdkwindow, m_penGC, FALSE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 

-            if ((m_brush.GetStyle() != wxBRUSHSTYLE_TRANSPARENT) && (alpha2 - alpha1 != 360*64))
+            if ( m_brush.IsNonTransparent() && (alpha2 - alpha1 != 360*64) )

             {
                 gdk_draw_line( m_gdkwindow, m_penGC, xx1, yy1, xxc, yyc );
                 gdk_draw_line( m_gdkwindow, m_penGC, xxc, yyc, xx2, yy2 );
             {
                 gdk_draw_line( m_gdkwindow, m_penGC, xx1, yy1, xxc, yyc );
                 gdk_draw_line( m_gdkwindow, m_penGC, xxc, yyc, xx2, yy2 );


@@ -634,7 +664,7 @@ void wxWindowDCImpl::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxC
         wxCoord start = wxCoord(sa * 64.0);
         wxCoord end = wxCoord((ea-sa) * 64.0);
 
         wxCoord start = wxCoord(sa * 64.0);
         wxCoord end = wxCoord((ea-sa) * 64.0);
 

-        if (m_brush.GetStyle() != wxBRUSHSTYLE_TRANSPARENT)
+        if ( m_brush.IsNonTransparent() )

         {
             GdkGC* gc;
             bool originChanged;
         {
             GdkGC* gc;
             bool originChanged;


@@ -646,7 +676,7 @@ void wxWindowDCImpl::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxC
                 gdk_gc_set_ts_origin(gc, 0, 0);
         }
 
                 gdk_gc_set_ts_origin(gc, 0, 0);
         }
 

-        if (m_pen.GetStyle() != wxPENSTYLE_TRANSPARENT)
+        if ( m_pen.IsNonTransparent() )

             gdk_draw_arc( m_gdkwindow, m_penGC, FALSE, xx, yy, ww, hh, start, end );
     }
 
             gdk_draw_arc( m_gdkwindow, m_penGC, FALSE, xx, yy, ww, hh, start, end );
     }
 


@@ -658,47 +688,54 @@ void wxWindowDCImpl::DoDrawPoint( wxCoord x, wxCoord y )
 {
     wxCHECK_RET( IsOk(), wxT("invalid window dc") );
 
 {
     wxCHECK_RET( IsOk(), wxT("invalid window dc") );
 

-    if ((m_pen.GetStyle() != wxPENSTYLE_TRANSPARENT) && m_gdkwindow)
+    if ( m_pen.IsNonTransparent() && m_gdkwindow )

         gdk_draw_point( m_gdkwindow, m_penGC, XLOG2DEV(x), YLOG2DEV(y) );
 
     CalcBoundingBox (x, y);
 }
 
         gdk_draw_point( m_gdkwindow, m_penGC, XLOG2DEV(x), YLOG2DEV(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") );
 

-    if (m_pen.GetStyle() == wxPENSTYLE_TRANSPARENT) return;

     if (n <= 0) return;
 
     if (n <= 0) return;
 

+    if ( m_pen.IsTransparent() )
+        return;
+

     //Check, if scaling is necessary
     const bool doScale =
         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
     //Check, if scaling is necessary
     const bool doScale =
         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[], wxCoord xoffset, wxCoord yoffset, int WXUNUSED(fillStyle) )
+void wxWindowDCImpl::DoDrawPolygon( int n, const wxPoint points[],
+                                    wxCoord xoffset, wxCoord yoffset,
+                                    wxPolygonFillMode WXUNUSED(fillStyle) )

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


@@ -709,37 +746,41 @@ void wxWindowDCImpl::DoDrawPolygon( int n, wxPoint points[], wxCoord xoffset, wx
         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);
     }
 
     if (m_gdkwindow)
     {
         }
         CalcBoundingBox(points[i].x + xoffset, points[i].y + yoffset);
     }
 
     if (m_gdkwindow)
     {

-        if (m_brush.GetStyle() != wxBRUSHSTYLE_TRANSPARENT)
+        if ( m_brush.IsNonTransparent() )

         {
             GdkGC* gc;
             bool originChanged;
             DrawingSetup(gc, originChanged);
 
         {
             GdkGC* gc;
             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);
         }
 

-        if (m_pen.GetStyle() != wxPENSTYLE_TRANSPARENT)
+        if ( m_pen.IsNonTransparent() )

         {
 /*
             for (i = 0 ; i < n ; i++)
         {
 /*
             for (i = 0 ; i < n ; i++)


@@ -751,13 +792,12 @@ void wxWindowDCImpl::DoDrawPolygon( int n, wxPoint points[], wxCoord xoffset, wx
                                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 )


@@ -778,7 +818,7 @@ void wxWindowDCImpl::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoo
 
     if (m_gdkwindow)
     {
 
     if (m_gdkwindow)
     {

-        if (m_brush.GetStyle() != wxBRUSHSTYLE_TRANSPARENT)
+        if ( m_brush.IsNonTransparent() )

         {
             GdkGC* gc;
             bool originChanged;
         {
             GdkGC* gc;
             bool originChanged;


@@ -790,9 +830,8 @@ void wxWindowDCImpl::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoo
                 gdk_gc_set_ts_origin(gc, 0, 0);
         }
 
                 gdk_gc_set_ts_origin(gc, 0, 0);
         }
 

-        if (m_pen.GetStyle() != wxPENSTYLE_TRANSPARENT)
+        if ( m_pen.IsNonTransparent() )

         {
         {

-#if 1

             if ((m_pen.GetWidth() == 2) && (m_pen.GetCap() == wxCAP_ROUND) &&
                 (m_pen.GetJoin() == wxJOIN_ROUND) && (m_pen.GetStyle() == wxPENSTYLE_SOLID))
             {
             if ((m_pen.GetWidth() == 2) && (m_pen.GetCap() == wxCAP_ROUND) &&
                 (m_pen.GetJoin() == wxJOIN_ROUND) && (m_pen.GetStyle() == wxPENSTYLE_SOLID))
             {


@@ -815,7 +854,6 @@ void wxWindowDCImpl::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoo
                 gdk_gc_set_line_attributes( m_penGC, 2, GDK_LINE_SOLID, GDK_CAP_ROUND, GDK_JOIN_ROUND );
             }
             else
                 gdk_gc_set_line_attributes( m_penGC, 2, GDK_LINE_SOLID, GDK_CAP_ROUND, GDK_JOIN_ROUND );
             }
             else

-#endif

             {
                 // Just use X11 for other cases
                 gdk_draw_rectangle( m_gdkwindow, m_penGC, FALSE, xx, yy, ww-1, hh-1 );
             {
                 // Just use X11 for other cases
                 gdk_draw_rectangle( m_gdkwindow, m_penGC, FALSE, xx, yy, ww-1, hh-1 );


@@ -856,7 +894,7 @@ void wxWindowDCImpl::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width
 
     // CMB: adjust size if outline is drawn otherwise the result is
     // 1 pixel too wide and high
 
     // CMB: adjust size if outline is drawn otherwise the result is
     // 1 pixel too wide and high

-    if (m_pen.GetStyle() != wxPENSTYLE_TRANSPARENT)
+    if ( m_pen.IsNonTransparent() )

     {
         ww--;
         hh--;
     {
         ww--;
         hh--;


@@ -871,7 +909,7 @@ void wxWindowDCImpl::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width
         if (dd > hh) dd = hh;
         rr = dd / 2;
 
         if (dd > hh) dd = hh;
         rr = dd / 2;
 

-        if (m_brush.GetStyle() != wxBRUSHSTYLE_TRANSPARENT)
+        if ( m_brush.IsNonTransparent() )

         {
             GdkGC* gc;
             bool originChanged;
         {
             GdkGC* gc;
             bool originChanged;


@@ -888,7 +926,7 @@ void wxWindowDCImpl::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width
                 gdk_gc_set_ts_origin(gc, 0, 0);
         }
 
                 gdk_gc_set_ts_origin(gc, 0, 0);
         }
 

-        if (m_pen.GetStyle() != wxPENSTYLE_TRANSPARENT)
+        if ( m_pen.IsNonTransparent() )

         {
             gdk_draw_line( m_gdkwindow, m_penGC, xx+rr+1, yy, xx+ww-rr, yy );
             gdk_draw_line( m_gdkwindow, m_penGC, xx+rr+1, yy+hh, xx+ww-rr, yy+hh );
         {
             gdk_draw_line( m_gdkwindow, m_penGC, xx+rr+1, yy, xx+ww-rr, yy );
             gdk_draw_line( m_gdkwindow, m_penGC, xx+rr+1, yy+hh, xx+ww-rr, yy+hh );


@@ -921,7 +959,7 @@ void wxWindowDCImpl::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord
 
     if (m_gdkwindow)
     {
 
     if (m_gdkwindow)
     {

-        if (m_brush.GetStyle() != wxBRUSHSTYLE_TRANSPARENT)
+        if ( m_brush.IsNonTransparent() )

         {
             GdkGC* gc;
             bool originChanged;
         {
             GdkGC* gc;
             bool originChanged;


@@ -929,7 +967,7 @@ void wxWindowDCImpl::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord
 
             // If the pen is transparent pen we increase the size
             // for better compatibility with other platforms.
 
             // If the pen is transparent pen we increase the size
             // for better compatibility with other platforms.

-            if (m_pen.GetStyle() == wxPENSTYLE_TRANSPARENT)
+            if (m_pen.IsTransparent())

             {
                 ++ww;
                 ++hh;
             {
                 ++ww;
                 ++hh;


@@ -941,7 +979,7 @@ void wxWindowDCImpl::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord
                 gdk_gc_set_ts_origin(gc, 0, 0);
         }
 
                 gdk_gc_set_ts_origin(gc, 0, 0);
         }
 

-        if (m_pen.GetStyle() != wxPENSTYLE_TRANSPARENT)
+        if ( m_pen.IsNonTransparent() )

             gdk_draw_arc( m_gdkwindow, m_penGC, false, xx, yy, ww, hh, 0, 360*64 );
     }
 
             gdk_draw_arc( m_gdkwindow, m_penGC, false, xx, yy, ww, hh, 0, 360*64 );
     }
 


@@ -955,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)
 {


@@ -963,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)
 {


@@ -1000,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)
 {


@@ -1020,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;
 }
 


@@ -1056,8 +1092,11 @@ void wxWindowDCImpl::DoDrawBitmap( const wxBitmap &bitmap,
     const int w = bitmap.GetWidth();
     const int h = bitmap.GetHeight();
 
     const int w = bitmap.GetWidth();
     const int h = bitmap.GetHeight();
 

+    // notice that as the bitmap is not drawn upside down (or right to left)
+    // even if the corresponding axis direction is inversed, we need to take it
+    // into account when calculating its bounding box

     CalcBoundingBox(x, y);
     CalcBoundingBox(x, y);

-    CalcBoundingBox(x + w, y + h);
+    CalcBoundingBox(x + m_signX*w, y + m_signY*h);

 
     // device coords
     int xx = LogicalToDeviceX(x);
 
     // device coords
     int xx = LogicalToDeviceX(x);


@@ -1088,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);


@@ -1107,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)
     {


@@ -1132,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);

     }
 }
 
     }
 }
 


@@ -1158,7 +1211,7 @@ bool wxWindowDCImpl::DoBlit( wxCoord xdest, wxCoord ydest,
                          wxCoord width, wxCoord height,
                          wxDC *source,
                          wxCoord xsrc, wxCoord ysrc,
                          wxCoord width, wxCoord height,
                          wxDC *source,
                          wxCoord xsrc, wxCoord ysrc,

-                         int logical_func,
+                         wxRasterOperationMode logical_func,

                          bool useMask,
                          wxCoord xsrcMask, wxCoord ysrcMask )
 {
                          bool useMask,
                          wxCoord xsrcMask, wxCoord ysrcMask )
 {


@@ -1180,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


@@ -1260,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)


@@ -1268,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;
         }


@@ -1281,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.


@@ -1299,7 +1359,7 @@ bool wxWindowDCImpl::DoBlit( wxCoord xdest, wxCoord ydest,
         src_y = 0;
     }
 
         src_y = 0;
     }
 

-    const int logical_func_save = m_logicalFunction;
+    const wxRasterOperationMode logical_func_save = m_logicalFunction;

     SetLogicalFunction(logical_func);
     if (memDC == NULL)
         gdk_gc_set_subwindow(use_gc, GDK_INCLUDE_INFERIORS);
     SetLogicalFunction(logical_func);
     if (memDC == NULL)
         gdk_gc_set_subwindow(use_gc, GDK_INCLUDE_INFERIORS);


@@ -1325,208 +1385,66 @@ 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;
 }
 

-void wxWindowDCImpl::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
+void wxWindowDCImpl::DoDrawText(const wxString& text,
+                                wxCoord xLogical,
+                                wxCoord yLogical)

 {
 {

-    wxCHECK_RET( IsOk(), wxT("invalid window dc") );
-
-    if (!m_gdkwindow) return;
-
-    if (text.empty()) return;
-
-    x = XLOG2DEV(x);
-    y = YLOG2DEV(y);
-
-    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
-
-    bool underlined = m_font.IsOk() && m_font.GetUnderlined();
+    DoDrawRotatedText(text, xLogical, yLogical, 0);
+}

 
 

-    wxCharBuffer data = wxGTK_CONV(text);
-    if ( !data )
+void wxWindowDCImpl::DoDrawRotatedText(const wxString& text, int xLogical, int yLogical, double angle)
+{
+    if (!m_gdkwindow || text.empty())

         return;
         return;

-    size_t datalen = strlen(data);
-
-    // in Pango >= 1.16 the "underline of leading/trailing spaces" bug
-    // has been fixed and thus the hack implemented below should never be used
-    static bool pangoOk = !wx_pango_version_check(1, 16, 0);
-
-    bool needshack = underlined && !pangoOk;
-
-    if (needshack)
-    {
-        // a PangoLayout which has leading/trailing spaces with underlined font
-        // is not correctly drawn by this pango version: Pango won't underline the spaces.
-        // This can be a problem; e.g. wxHTML rendering of underlined text relies on
-        // this behaviour. To workaround this problem, we use a special hack here
-        // suggested by pango maintainer Behdad Esfahbod: we prepend and append two
-        // empty space characters and give them a dummy colour attribute.
-        // This will force Pango to underline the leading/trailing spaces, too.
-
-        wxCharBuffer data_tmp(datalen + 6);
-        // copy the leading U+200C ZERO WIDTH NON-JOINER encoded in UTF8 format
-        memcpy(data_tmp.data(), "\342\200\214", 3);
-        // copy the user string
-        memcpy(data_tmp.data() + 3, data, datalen);
-        // copy the trailing U+200C ZERO WIDTH NON-JOINER encoded in UTF8 format
-        memcpy(data_tmp.data() + 3 + datalen, "\342\200\214", 3);
-
-        data = data_tmp;
-        datalen += 6;
-    }

 
 

-    pango_layout_set_text(m_layout, data, datalen);
-
-    if (underlined)
-    {
-        PangoAttrList *attrs = pango_attr_list_new();
-        PangoAttribute *a = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
-        a->start_index = 0;
-        a->end_index = datalen;
-        pango_attr_list_insert(attrs, a);
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
 

-        if (needshack)
-        {
-            // dummy colour for the leading space
-            a = pango_attr_foreground_new (0x0057, 0x52A9, 0xD614);
-            a->start_index = 0;
-            a->end_index = 1;
-            pango_attr_list_insert(attrs, a);
-
-            // dummy colour for the trailing space
-            a = pango_attr_foreground_new (0x0057, 0x52A9, 0xD614);
-            a->start_index = datalen - 1;
-            a->end_index = datalen;
-            pango_attr_list_insert(attrs, a);
-        }
+    pango_layout_set_text(m_layout, wxGTK_CONV(text), -1);
+    const bool setAttrs = m_font.GTKSetPangoAttrs(m_layout);

 
 

-        pango_layout_set_attributes(m_layout, attrs);
-        pango_attr_list_unref(attrs);
-    }
+    const GdkColor* bg_col = NULL;
+    if (m_backgroundMode == wxBRUSHSTYLE_SOLID)
+        bg_col = m_textBackgroundColour.GetColor();

 
 

-    int oldSize = 0;
-    const bool isScaled = fabs(m_scaleY - 1.0) > 0.00001;
-    if (isScaled)
+    PangoMatrix matrix = PANGO_MATRIX_INIT;
+    if (!wxIsSameDouble(m_scaleX, 1) || !wxIsSameDouble(m_scaleY, 1) || !wxIsNullDouble(angle))

     {
     {

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

     }
 
     int w, h;
     pango_layout_get_pixel_size(m_layout, &w, &h);
 
     }
 
     int w, h;
     pango_layout_get_pixel_size(m_layout, &w, &h);
 

-    // Draw layout.
-    int x_rtl = x;
+    int x = LogicalToDeviceX(xLogical);
+    int y = LogicalToDeviceY(yLogical);

     if (m_window && m_window->GetLayoutDirection() == wxLayout_RightToLeft)
     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);
+        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);

     }
     }

-    if (underlined)
-    {
-        // undo underline attributes setting:
-        pango_layout_set_attributes(m_layout, NULL);
-    }
-
-    CalcBoundingBox(x + int(w / m_scaleX), y + int(h / m_scaleY));
-    CalcBoundingBox(x, y);
-}
-
-// 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 )
-{
-    if (!m_gdkwindow || text.empty())
-        return;
-
-    wxCHECK_RET( IsOk(), wxT("invalid window dc") );
-
-#if __WXGTK26__
-    if (!gtk_check_version(2,6,0))
+    else

     {
     {

-        x = XLOG2DEV(x);
-        y = YLOG2DEV(y);
-
-        pango_layout_set_text(m_layout, wxGTK_CONV(text), -1);
-
-        if (m_font.GetUnderlined())
-        {
-            PangoAttrList *attrs = pango_attr_list_new();
-            PangoAttribute *a = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
-            pango_attr_list_insert(attrs, a);
-            pango_layout_set_attributes(m_layout, attrs);
-            pango_attr_list_unref(attrs);
-        }
-
-        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();
-
-        // rotate the text
-        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 
+        // To be compatible with MSW, the rotation axis must be in the old

         // top-left corner.
         // top-left corner.

-        // Calculate the vertices of the rotated rectangle containing the text, 
+        // Calculate the vertices of the rotated rectangle containing the text,

         // relative to the old top-left vertex.
         // 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 
+        // the rectangle vertices are counted clockwise with the first one

         // being at (0, 0)
         // 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 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.
         double x3 = x4 + x2;
         double y3 = y4 + y2;
         // Then we calculate max and min of the rotated rectangle.


@@ -1534,132 +1452,17 @@ void wxWindowDCImpl::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord
                 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);
                 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 (m_font.GetUnderlined())
-            pango_layout_set_attributes(m_layout, NULL);
-
-        // clean up the transformation matrix
-        pango_context_set_matrix(m_context, NULL);
-
-        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 );
-        }
-
-        CalcBoundingBox(x+minX, y+minY);
-        CalcBoundingBox(x+maxX, y+maxY);
-    }
-    else
-#endif //__WXGTK26__
-    {
-#if wxUSE_IMAGE
-    if ( wxIsNullDouble(angle) )
-    {
-        DoDrawText(text, x, y);
-        return;
+        x += minX;
+        y += minY;
+        CalcBoundingBox(DeviceToLogicalX(x), DeviceToLogicalY(y));
+        CalcBoundingBox(DeviceToLogicalX(x + maxX - minX), DeviceToLogicalY(y + maxY - minY));

     }
 
     }
 

-    wxCoord w;
-    wxCoord h;
-
-    // TODO: implement later without GdkFont for GTK 2.0
-    DoGetTextExtent(text, &w, &h, NULL,NULL, &m_font);
-
-    // draw the string normally
-    wxBitmap src(w, h);
-    wxMemoryDC dc;
-    dc.SelectObject(src);
-    dc.SetFont(GetFont());
-    dc.SetBackground(*wxBLACK_BRUSH);
-    dc.SetBrush(*wxBLACK_BRUSH);
-    dc.Clear();
-    dc.SetTextForeground( *wxWHITE );
-    dc.DrawText(text, 0, 0);
-    dc.SelectObject(wxNullBitmap);
-
-    // Calculate the size of the rotated bounding box.
-    double rad = DegToRad(angle);
-    double dx = cos(rad),
-           dy = sin(rad);
-
-    // the rectngle vertices are counted clockwise with the first one being at
-    // (0, 0) (or, rather, at (x, y))
-    double x2 = w*dx,
-           y2 = -w*dy;      // y axis points to the bottom, hence minus
-    double x4 = h*dy,
-           y4 = h*dx;
-    double x3 = x4 + x2,
-           y3 = y4 + y2;
-
-    // calc max and min
-    wxCoord maxX = (wxCoord)(dmax(x2, dmax(x3, x4)) + 0.5),
-            maxY = (wxCoord)(dmax(y2, dmax(y3, y4)) + 0.5),
-            minX = (wxCoord)(dmin(x2, dmin(x3, x4)) - 0.5),
-            minY = (wxCoord)(dmin(y2, dmin(y3, y4)) - 0.5);
-
-
-    wxImage image = src.ConvertToImage();
-
-    image.ConvertColourToAlpha( m_textForegroundColour.Red(),
-                                m_textForegroundColour.Green(),
-                                m_textForegroundColour.Blue() );
-    image = image.Rotate( rad, wxPoint(0,0) );
-
-    int i_angle = (int) angle;
-    i_angle = i_angle % 360;
-    if (i_angle < 0)
-        i_angle += 360;
-    int xoffset = 0;
-    if ((i_angle >= 90.0) && (i_angle < 270.0))
-        xoffset = image.GetWidth();
-    int yoffset = 0;
-    if ((i_angle >= 0.0) && (i_angle < 180.0))
-        yoffset = image.GetHeight();
-
-    if ((i_angle >= 0) && (i_angle < 90))
-        yoffset -= (int)( cos(rad)*h );
-    if ((i_angle >= 90) && (i_angle < 180))
-        xoffset -= (int)( sin(rad)*h );
-    if ((i_angle >= 180) && (i_angle < 270))
-        yoffset -= (int)( cos(rad)*h );
-    if ((i_angle >= 270) && (i_angle < 360))
-        xoffset -= (int)( sin(rad)*h );
-
-    int i_x = x - xoffset;
-    int i_y = y - yoffset;
-
-    src = image;
-    DoDrawBitmap( src, i_x, i_y, true );
-
-
-    // it would be better to draw with non underlined font and draw the line
-    // manually here (it would be more straight...)
-#if 0
-    if ( m_font.GetUnderlined() )
-    {
-        gdk_draw_line( m_gdkwindow, m_textGC,
-                       XLOG2DEV(x + x4), YLOG2DEV(y + y4 + font->descent),
-                       XLOG2DEV(x + x3), YLOG2DEV(y + y3 + font->descent));
-    }
-#endif // 0
-
-    // update the bounding box
-    CalcBoundingBox(x + minX, y + minY);
-    CalcBoundingBox(x + maxX, y + maxY);
-#else // !wxUSE_IMAGE
-    wxUnusedVar(text);
-    wxUnusedVar(x);
-    wxUnusedVar(y);
-    wxUnusedVar(angle);
-#endif // wxUSE_IMAGE/!wxUSE_IMAGE
-    }
+    gdk_draw_layout_with_colors(m_gdkwindow, m_textGC, x, y, m_layout, NULL, bg_col);
+
+    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,


@@ -1667,100 +1470,27 @@ void wxWindowDCImpl::DoGetTextExtent(const wxString &string,
                                  wxCoord *descent, wxCoord *externalLeading,
                                  const wxFont *theFont) const
 {
                                  wxCoord *descent, wxCoord *externalLeading,
                                  const wxFont *theFont) const
 {

-    if ( width )
-        *width = 0;
-    if ( height )
-        *height = 0;
-    if ( descent )
-        *descent = 0;
-    if ( externalLeading )
-        *externalLeading = 0;
-
-    if (string.empty())
-        return;
-
-    // ensure that theFont is always non-NULL
+    // ensure we work with a valid font
+    const wxFont *fontToUse;

     if ( !theFont || !theFont->IsOk() )
     if ( !theFont || !theFont->IsOk() )

-        theFont = &m_font;
-
-    // and use it if it's valid
-    if ( theFont->IsOk() )
-    {
-        pango_layout_set_font_description
-        (
-            m_layout,
-            theFont->GetNativeFontInfo()->description
-        );
-    }
-
-    // Set layout's text
-    const wxCharBuffer dataUTF8 = wxGTK_CONV_FONT(string, *theFont);
-    if ( !dataUTF8 )
-    {
-        // hardly ideal, but what else can we do if conversion failed?
-        return;
-    }
-
-    pango_layout_set_text(m_layout, dataUTF8, -1);
+        fontToUse = &m_font;
+    else
+        fontToUse = theFont;

 
 

-    int h;
-    pango_layout_get_pixel_size(m_layout, width, &h);
-    if (descent)
-    {
-        PangoLayoutIter *iter = pango_layout_get_iter(m_layout);
-        int baseline = pango_layout_iter_get_baseline(iter);
-        pango_layout_iter_free(iter);
-        *descent = h - PANGO_PIXELS(baseline);
-    }
-    if (height)
-        *height = h;
+    wxCHECK_RET( fontToUse->IsOk(), wxT("invalid font") );

 
 

-    // Reset old font description
-    if (theFont->IsOk())
-        pango_layout_set_font_description( m_layout, m_fontdesc );
+    wxTextMeasure txm(GetOwner(), fontToUse);
+    txm.GetTextExtent(string, width, height, descent, externalLeading);

 }
 
 
 bool wxWindowDCImpl::DoGetPartialTextExtents(const wxString& text,
                                          wxArrayInt& widths) const
 {
 }
 
 
 bool wxWindowDCImpl::DoGetPartialTextExtents(const wxString& text,
                                          wxArrayInt& widths) const
 {

-    const size_t len = text.length();
-    widths.Empty();
-    widths.Add(0, len);
-
-    if (text.empty())
-        return true;
-
-    // Set layout's text
-    const wxCharBuffer dataUTF8 = wxGTK_CONV_FONT(text, m_font);
-    if ( !dataUTF8 )
-    {
-        // hardly ideal, but what else can we do if conversion failed?
-        wxLogLastError(wxT("DoGetPartialTextExtents"));
-        return false;
-    }
-
-    pango_layout_set_text(m_layout, dataUTF8, -1);
+    wxCHECK_MSG( m_font.IsOk(), false, wxT("Invalid font") );

 
 

-    // Calculate the position of each character based on the widths of
-    // the previous characters
-
-    // Code borrowed from Scintilla's PlatGTK
-    PangoLayoutIter *iter = pango_layout_get_iter(m_layout);
-    PangoRectangle pos;
-    pango_layout_iter_get_cluster_extents(iter, NULL, &pos);
-    size_t i = 0;
-    while (pango_layout_iter_next_cluster(iter))
-    {
-        pango_layout_iter_get_cluster_extents(iter, NULL, &pos);
-        int position = PANGO_PIXELS(pos.x);
-        widths[i++] = position;
-    }
-    while (i < len)
-        widths[i++] = PANGO_PIXELS(pos.x + pos.width);
-    pango_layout_iter_free(iter);
-
-    return true;
+    wxTextMeasure txm(GetOwner(), &m_font);
+    return txm.GetPartialTextExtents(text, widths, m_scaleX);

 }
 
 
 }
 
 


@@ -1775,10 +1505,10 @@ wxCoord wxWindowDCImpl::GetCharWidth() const
 wxCoord wxWindowDCImpl::GetCharHeight() const
 {
     PangoFontMetrics *metrics = pango_context_get_metrics (m_context, m_fontdesc, pango_context_get_language(m_context));
 wxCoord wxWindowDCImpl::GetCharHeight() const
 {
     PangoFontMetrics *metrics = pango_context_get_metrics (m_context, m_fontdesc, pango_context_get_language(m_context));

-    wxCHECK_MSG( metrics, -1, _T("failed to get pango font metrics") );
+    wxCHECK_MSG( metrics, -1, wxT("failed to get pango font metrics") );

 
     wxCoord h = PANGO_PIXELS (pango_font_metrics_get_descent (metrics) +
 
     wxCoord h = PANGO_PIXELS (pango_font_metrics_get_descent (metrics) +

-                pango_font_metrics_get_ascent (metrics));
+                              pango_font_metrics_get_ascent (metrics));

     pango_font_metrics_unref (metrics);
     return h;
 }
     pango_font_metrics_unref (metrics);
     return h;
 }


@@ -1810,7 +1540,7 @@ void wxWindowDCImpl::SetFont( const wxFont &font )
         {
             PangoContext *oldContext = m_context;
 
         {
             PangoContext *oldContext = m_context;
 

-            m_context = m_window->GtkGetPangoDefaultContext();
+            m_context = m_window->GTKGetPangoDefaultContext();

 
             // If we switch back/forth between different contexts
             // we also have to create a new layout. I think so,
 
             // If we switch back/forth between different contexts
             // we also have to create a new layout. I think so,


@@ -1902,7 +1632,7 @@ void wxWindowDCImpl::SetPen( const wxPen &pen )
         case wxPENSTYLE_SOLID:
         default:
             lineStyle = GDK_LINE_SOLID;
         case wxPENSTYLE_SOLID:
         default:
             lineStyle = GDK_LINE_SOLID;

-            req_dash = (wxGTKDash*)NULL;
+            req_dash = NULL;

             req_nb_dash = 0;
             break;
     }
             req_nb_dash = 0;
             break;
     }


@@ -1988,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())


@@ -2048,7 +1778,7 @@ void wxWindowDCImpl::SetBackground( const wxBrush &brush )
     }
 }
 
     }
 }
 

-void wxWindowDCImpl::SetLogicalFunction( int function )
+void wxWindowDCImpl::SetLogicalFunction( wxRasterOperationMode function )

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


@@ -2079,8 +1809,8 @@ void wxWindowDCImpl::SetLogicalFunction( int function )
         case wxSRC_INVERT:   mode = GDK_COPY_INVERT;   break;
         case wxNOR:          mode = GDK_NOR;           break;
         default:
         case wxSRC_INVERT:   mode = GDK_COPY_INVERT;   break;
         case wxNOR:          mode = GDK_NOR;           break;
         default:

-           wxFAIL_MSG( wxT("unsupported logical function") );
-           mode = GDK_COPY;
+            wxFAIL_MSG("unknown mode");
+            return;

     }
 
     m_logicalFunction = function;
     }
 
     m_logicalFunction = function;


@@ -2154,7 +1884,7 @@ void wxWindowDCImpl::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, w
     rect.width = XLOG2DEVREL(width);
     rect.height = YLOG2DEVREL(height);
 
     rect.width = XLOG2DEVREL(width);
     rect.height = YLOG2DEVREL(height);
 

-    if (m_window && m_window->m_wxwindow && 
+    if (m_window && m_window->m_wxwindow &&

         (m_window->GetLayoutDirection() == wxLayout_RightToLeft))
     {
         rect.x -= rect.width;
         (m_window->GetLayoutDirection() == wxLayout_RightToLeft))
     {
         rect.x -= rect.width;


@@ -2224,13 +1954,13 @@ void wxWindowDCImpl::DestroyClippingRegion()
 void wxWindowDCImpl::Destroy()
 {
     if (m_penGC) wxFreePoolGC( m_penGC );
 void wxWindowDCImpl::Destroy()
 {
     if (m_penGC) wxFreePoolGC( m_penGC );

-    m_penGC = (GdkGC*) NULL;
+    m_penGC = NULL;

     if (m_brushGC) wxFreePoolGC( m_brushGC );
     if (m_brushGC) wxFreePoolGC( m_brushGC );

-    m_brushGC = (GdkGC*) NULL;
+    m_brushGC = NULL;

     if (m_textGC) wxFreePoolGC( m_textGC );
     if (m_textGC) wxFreePoolGC( m_textGC );

-    m_textGC = (GdkGC*) NULL;
+    m_textGC = NULL;

     if (m_bgGC) wxFreePoolGC( m_bgGC );
     if (m_bgGC) wxFreePoolGC( m_bgGC );

-    m_bgGC = (GdkGC*) NULL;
+    m_bgGC = NULL;

 }
 
 void wxWindowDCImpl::SetDeviceOrigin( wxCoord x, wxCoord y )
 }
 
 void wxWindowDCImpl::SetDeviceOrigin( wxCoord x, wxCoord y )


@@ -2246,7 +1976,7 @@ void wxWindowDCImpl::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
     m_signX = (xLeftRight ?  1 : -1);
     m_signY = (yBottomUp  ? -1 :  1);
 
     m_signX = (xLeftRight ?  1 : -1);
     m_signY = (yBottomUp  ? -1 :  1);
 

-    if (m_window && m_window->m_wxwindow && 
+    if (m_window && m_window->m_wxwindow &&

         (m_window->GetLayoutDirection() == wxLayout_RightToLeft))
         m_signX = -m_signX;
 
         (m_window->GetLayoutDirection() == wxLayout_RightToLeft))
         m_signX = -m_signX;
 


@@ -2281,7 +2011,6 @@ int wxWindowDCImpl::GetDepth() const
     return gdk_drawable_get_depth(m_gdkwindow);
 }
 
     return gdk_drawable_get_depth(m_gdkwindow);
 }
 

-

 //-----------------------------------------------------------------------------
 // wxClientDCImpl
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxClientDCImpl
 //-----------------------------------------------------------------------------


@@ -2296,22 +2025,22 @@ wxClientDCImpl::wxClientDCImpl( wxDC *owner )
 wxClientDCImpl::wxClientDCImpl( wxDC *owner, wxWindow *win )
           : wxWindowDCImpl( owner, win )
 {
 wxClientDCImpl::wxClientDCImpl( wxDC *owner, wxWindow *win )
           : wxWindowDCImpl( owner, win )
 {

-    wxCHECK_RET( win, _T("NULL window in wxClientDCImpl::wxClientDC") );
+    wxCHECK_RET( win, wxT("NULL window in wxClientDCImpl::wxClientDC") );

 
 #ifdef __WXUNIVERSAL__
     wxPoint ptOrigin = win->GetClientAreaOrigin();
     SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
     wxSize size = win->GetClientSize();
     DoSetClippingRegion(0, 0, size.x, size.y);
 
 #ifdef __WXUNIVERSAL__
     wxPoint ptOrigin = win->GetClientAreaOrigin();
     SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
     wxSize size = win->GetClientSize();
     DoSetClippingRegion(0, 0, size.x, size.y);

-#endif 
+#endif

     // __WXUNIVERSAL__
 }
 
 void wxClientDCImpl::DoGetSize(int *width, int *height) const
 {
     // __WXUNIVERSAL__
 }
 
 void wxClientDCImpl::DoGetSize(int *width, int *height) const
 {

-    wxCHECK_RET( m_window, _T("GetSize() doesn't work without window") );
+    wxCHECK_RET( m_window, wxT("GetSize() doesn't work without window") );

 
 

-    m_window->GetClientSize( width, height );
+    m_window->GetClientSize(width, height);

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


@@ -2369,7 +2098,7 @@ wxPaintDCImpl::wxPaintDCImpl( wxDC *owner, wxWindow *win )
         gdk_gc_set_clip_region( m_textGC, region );
         gdk_gc_set_clip_region( m_bgGC, region );
     }
         gdk_gc_set_clip_region( m_textGC, region );
         gdk_gc_set_clip_region( m_bgGC, region );
     }

-#endif 
+#endif

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