Derive wxWebViewEvent from wxNotifyEvent.

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

diff --git a/src/x11/dcclient.cpp b/src/x11/dcclient.cpp
index d3601d5985504122367f9d03170b5573d14bfa99..3f127c442b8cadd29f1543ef6b2601a49e2dfe9a 100644 (file)
--- a/src/x11/dcclient.cpp
+++ b/src/x11/dcclient.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        x11/dcclient.cpp
+// Name:        src/x11/dcclient.cpp

 // Purpose:     wxClientDC class
 // Author:      Julian Smart, Robert Roebling
 // Modified by:
 // Purpose:     wxClientDC class
 // Author:      Julian Smart, Robert Roebling
 // Modified by:


@@ -9,26 +9,32 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "dcclient.h"
-#endif
+// for compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"

 
 #include "wx/dcclient.h"
 
 #include "wx/dcclient.h"

-#include "wx/dcmemory.h"
-#include "wx/window.h"
-#include "wx/app.h"
-#include "wx/image.h"
-#include "wx/module.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/app.h"
+    #include "wx/window.h"
+    #include "wx/math.h"
+    #include "wx/image.h"
+    #include "wx/module.h"
+#endif
+

 #include "wx/fontutil.h"
 #include "wx/fontutil.h"

+#include "wx/vector.h"

 
 #include "wx/x11/private.h"
 
 #include "wx/x11/private.h"

-
-#include <math.h>
+#include "wx/x11/dcclient.h"
+#include "wx/x11/dcmemory.h"

 
 #if wxUSE_UNICODE
 #include "glib.h"
 #include "pango/pangox.h"
 
 #if wxUSE_UNICODE
 #include "glib.h"
 #include "pango/pangox.h"

-#include "pango/pangoxft.h"
+#ifdef HAVE_PANGO_XFT
+    #include "pango/pangoxft.h"
+#endif

 
 #include "pango_x.cpp"
 #endif
 
 #include "pango_x.cpp"
 #endif


@@ -37,7 +43,8 @@
 // local defines
 //-----------------------------------------------------------------------------
 
 // local defines
 //-----------------------------------------------------------------------------
 

-#define USE_PAINT_REGION 1
+// VZ: what is this for exactly??
+#define USE_PAINT_REGION 0

 
 //-----------------------------------------------------------------------------
 // local data
 
 //-----------------------------------------------------------------------------
 // local data


@@ -55,7 +62,7 @@
 #define IS_16_PIX_HATCH(s) ((s)!=wxCROSSDIAG_HATCH && (s)!=wxHORIZONTAL_HATCH && (s)!=wxVERTICAL_HATCH)
 
 static Pixmap  hatches[num_hatches];
 #define IS_16_PIX_HATCH(s) ((s)!=wxCROSSDIAG_HATCH && (s)!=wxHORIZONTAL_HATCH && (s)!=wxVERTICAL_HATCH)
 
 static Pixmap  hatches[num_hatches];

-static Pixmap *hatch_bitmap = (Pixmap *) NULL;
+static Pixmap *hatch_bitmap = NULL;

 
 //-----------------------------------------------------------------------------
 // constants
 
 //-----------------------------------------------------------------------------
 // constants


@@ -127,11 +134,11 @@ static GC wxGetPoolGC( Window window, wxPoolGCType type )
             wxGCPool[i].m_gc = XCreateGC( wxGlobalDisplay(), window, 0, NULL );
             XSetGraphicsExposures( wxGlobalDisplay(), wxGCPool[i].m_gc, FALSE );
             wxGCPool[i].m_type = type;
             wxGCPool[i].m_gc = XCreateGC( wxGlobalDisplay(), window, 0, NULL );
             XSetGraphicsExposures( wxGlobalDisplay(), wxGCPool[i].m_gc, FALSE );
             wxGCPool[i].m_type = type;

-            wxGCPool[i].m_used = FALSE;
+            wxGCPool[i].m_used = false;

         }
         if ((!wxGCPool[i].m_used) && (wxGCPool[i].m_type == type))
         {
         }
         if ((!wxGCPool[i].m_used) && (wxGCPool[i].m_type == type))
         {

-            wxGCPool[i].m_used = TRUE;
+            wxGCPool[i].m_used = true;

             return wxGCPool[i].m_gc;
         }
     }
             return wxGCPool[i].m_gc;
         }
     }


@@ -147,7 +154,7 @@ static void wxFreePoolGC( GC gc )
     {
         if (wxGCPool[i].m_gc == gc)
         {
     {
         if (wxGCPool[i].m_gc == gc)
         {

-            wxGCPool[i].m_used = FALSE;
+            wxGCPool[i].m_used = false;

             return;
         }
     }
             return;
         }
     }


@@ -159,56 +166,37 @@ static void wxFreePoolGC( GC gc )
 // wxWindowDC
 // ----------------------------------------------------------------------------
 
 // wxWindowDC
 // ----------------------------------------------------------------------------
 

-IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
+IMPLEMENT_ABSTRACT_CLASS(wxWindowDCImpl, wxX11DCImpl)

 
 

-wxWindowDC::wxWindowDC()
+wxWindowDCImpl::wxWindowDCImpl( wxDC *owner )
+  : wxX11DCImpl( owner )

 {
 {

-    m_display = (WXDisplay *) NULL;
-    m_penGC = (WXGC *) NULL;
-    m_brushGC = (WXGC *) NULL;
-    m_textGC = (WXGC *) NULL;
-    m_bgGC = (WXGC *) NULL;
-    m_cmap = (WXColormap *) NULL;
-    m_isMemDC = FALSE;
-    m_isScreenDC = FALSE;
-    m_owner = (wxWindow *)NULL;
-    
-#if wxUSE_UNICODE
-    m_context = (PangoContext *)NULL;
-    m_fontdesc = (PangoFontDescription *)NULL;
-#endif
+    Init();

 }
 
 }
 

-wxWindowDC::wxWindowDC( wxWindow *window )
+wxWindowDCImpl::wxWindowDCImpl( wxDC* owner, wxWindow *window )
+  : wxX11DCImpl( owner )

 {
     wxASSERT_MSG( window, wxT("DC needs a window") );
 
 {
     wxASSERT_MSG( window, wxT("DC needs a window") );
 

-    m_display = (WXDisplay *) NULL;
-    m_penGC = (WXGC *) NULL;
-    m_brushGC = (WXGC *) NULL;
-    m_textGC = (WXGC *) NULL;
-    m_bgGC = (WXGC *) NULL;
-    m_cmap = (WXColormap *) NULL;
-    m_owner = (wxWindow *)NULL;
-    m_isMemDC = FALSE;
-    m_isScreenDC = FALSE;
+    Init();
+

     m_font = window->GetFont();
 
     m_font = window->GetFont();
 

-    m_window = (WXWindow*) window->GetMainWindow();
+    m_x11window = (WXWindow*) window->X11GetMainWindow();

 
     // not realized ?
 
     // not realized ?

-    if (!m_window)
+    if (!m_x11window)

     {
          // don't report problems
     {
          // don't report problems

-         m_ok = TRUE;
+         m_ok = true;

 
          return;
     }
 
     m_display = (WXDisplay *) wxGlobalDisplay();
 
          return;
     }
 
     m_display = (WXDisplay *) wxGlobalDisplay();

-    
+

 #if wxUSE_UNICODE
 #if wxUSE_UNICODE

-    m_context = wxTheApp->GetPangoContext();

     m_fontdesc = window->GetFont().GetNativeFontInfo()->description;
 #endif
 
     m_fontdesc = window->GetFont().GetNativeFontInfo()->description;
 #endif
 


@@ -219,46 +207,72 @@ wxWindowDC::wxWindowDC( wxWindow *window )
 
     /* this must be done after SetUpDC, bacause SetUpDC calls the
        repective SetBrush, SetPen, SetBackground etc functions
 
     /* this must be done after SetUpDC, bacause SetUpDC calls the
        repective SetBrush, SetPen, SetBackground etc functions

-       to set up the DC. SetBackground call m_owner->SetBackground
+       to set up the DC. SetBackground call m_window->SetBackground

        and this might not be desired as the standard dc background
        is white whereas a window might assume gray to be the
        standard (as e.g. wxStatusBar) */
 
        and this might not be desired as the standard dc background
        is white whereas a window might assume gray to be the
        standard (as e.g. wxStatusBar) */
 

-    m_owner = window;
+    m_window = window;

 }
 
 }
 

-wxWindowDC::~wxWindowDC()
+wxWindowDCImpl::~wxWindowDCImpl()

 {
     Destroy();
 }
 
 {
     Destroy();
 }
 

-void wxWindowDC::SetUpDC()
+void wxWindowDCImpl::Init()

 {
 {

-    m_ok = TRUE;
+    m_display = NULL;
+    m_penGC = NULL;
+    m_brushGC = NULL;
+    m_textGC = NULL;
+    m_bgGC = NULL;
+    m_cmap = NULL;
+    m_isMemDC = false;
+    m_isScreenDC = false;
+    m_x11window = NULL;
+
+#if wxUSE_UNICODE
+    m_context = wxTheApp->GetPangoContext();
+    m_fontdesc = NULL;
+#endif
+}
+
+void wxWindowDCImpl::SetUpDC()
+{
+    m_ok = true;

 
     wxASSERT_MSG( !m_penGC, wxT("GCs already created") );
 
 
     wxASSERT_MSG( !m_penGC, wxT("GCs already created") );
 

+    bool ismono = false;
+    if (m_isMemDC)
+    {
+        wxMemoryDCImpl *mem_impl = (wxMemoryDCImpl *) this;
+        if (mem_impl->GetSelectedBitmap().IsOk())
+            ismono = mem_impl->GetSelectedBitmap().GetDepth() == 1;
+    }
+

     if (m_isScreenDC)
     {
     if (m_isScreenDC)
     {

-        m_penGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxPEN_SCREEN );
-        m_brushGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBRUSH_SCREEN );
-        m_textGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxTEXT_SCREEN );
-        m_bgGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBG_SCREEN );
+        m_penGC = (WXGC*) wxGetPoolGC( (Window) m_x11window, wxPEN_SCREEN );
+        m_brushGC = (WXGC*) wxGetPoolGC( (Window) m_x11window, wxBRUSH_SCREEN );
+        m_textGC = (WXGC*) wxGetPoolGC( (Window) m_x11window, wxTEXT_SCREEN );
+        m_bgGC = (WXGC*) wxGetPoolGC( (Window) m_x11window, wxBG_SCREEN );

     }
     else
     }
     else

-    if (m_isMemDC && (((wxMemoryDC*)this)->m_selected.GetDepth() == 1))
+    if (m_isMemDC && ismono)

     {
     {

-        m_penGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxPEN_MONO );
-        m_brushGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBRUSH_MONO );
-        m_textGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxTEXT_MONO );
-        m_bgGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBG_MONO );
+        m_penGC = (WXGC*) wxGetPoolGC( (Window) m_x11window, wxPEN_MONO );
+        m_brushGC = (WXGC*) wxGetPoolGC( (Window) m_x11window, wxBRUSH_MONO );
+        m_textGC = (WXGC*) wxGetPoolGC( (Window) m_x11window, wxTEXT_MONO );
+        m_bgGC = (WXGC*) wxGetPoolGC( (Window) m_x11window, wxBG_MONO );

     }
     else
     {
     }
     else
     {

-        m_penGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxPEN_COLOUR );
-        m_brushGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBRUSH_COLOUR );
-        m_textGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxTEXT_COLOUR );
-        m_bgGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBG_COLOUR );
+        m_penGC = (WXGC*) wxGetPoolGC( (Window) m_x11window, wxPEN_COLOUR );
+        m_brushGC = (WXGC*) wxGetPoolGC( (Window) m_x11window, wxBRUSH_COLOUR );
+        m_textGC = (WXGC*) wxGetPoolGC( (Window) m_x11window, wxTEXT_COLOUR );
+        m_bgGC = (WXGC*) wxGetPoolGC( (Window) m_x11window, wxBG_COLOUR );

     }
 
     /* background colour */
     }
 
     /* background colour */


@@ -266,6 +280,9 @@ void wxWindowDC::SetUpDC()
     m_backgroundBrush.GetColour().CalcPixel( m_cmap );
     unsigned long bg_col = m_backgroundBrush.GetColour().GetPixel();
 
     m_backgroundBrush.GetColour().CalcPixel( m_cmap );
     unsigned long bg_col = m_backgroundBrush.GetColour().GetPixel();
 

+    m_textForegroundColour = *wxBLACK;
+    m_textBackgroundColour = *wxWHITE;
+

     /* m_textGC */
     m_textForegroundColour.CalcPixel( m_cmap );
     XSetForeground( (Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel() );
     /* m_textGC */
     m_textForegroundColour.CalcPixel( m_cmap );
     XSetForeground( (Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel() );


@@ -297,7 +314,7 @@ void wxWindowDC::SetUpDC()
     /* m_bgGC */
     XSetForeground( (Display*) m_display, (GC) m_bgGC, bg_col );
     XSetBackground( (Display*) m_display, (GC) m_bgGC, bg_col );
     /* m_bgGC */
     XSetForeground( (Display*) m_display, (GC) m_bgGC, bg_col );
     XSetBackground( (Display*) m_display, (GC) m_bgGC, bg_col );

-    
+

     XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillSolid );
 
     /* ROPs */
     XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillSolid );
 
     /* ROPs */


@@ -315,7 +332,7 @@ void wxWindowDC::SetUpDC()
     {
         int xscreen = DefaultScreen( (Display*) m_display );
         Window xroot = RootWindow( (Display*) m_display, xscreen );
     {
         int xscreen = DefaultScreen( (Display*) m_display );
         Window xroot = RootWindow( (Display*) m_display, xscreen );

-    
+

         hatch_bitmap    = hatches;
         hatch_bitmap[0] = XCreateBitmapFromData( (Display*) m_display, xroot, bdiag_bits, bdiag_width, bdiag_height );
         hatch_bitmap[1] = XCreateBitmapFromData( (Display*) m_display, xroot, cdiag_bits, cdiag_width, cdiag_height );
         hatch_bitmap    = hatches;
         hatch_bitmap[0] = XCreateBitmapFromData( (Display*) m_display, xroot, bdiag_bits, bdiag_width, bdiag_height );
         hatch_bitmap[1] = XCreateBitmapFromData( (Display*) m_display, xroot, cdiag_bits, cdiag_width, cdiag_height );


@@ -326,43 +343,43 @@ void wxWindowDC::SetUpDC()
     }
 }
 
     }
 }
 

-void wxWindowDC::DoGetSize( int* width, int* height ) const
+void wxWindowDCImpl::DoGetSize( int* width, int* height ) const

 {
 {

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

 
 

-    m_owner->GetSize(width, height);
+    m_window->GetSize(width, height);

 }
 
 }
 

-extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y, 
-                          const wxColour & col, int style);
+extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
+                          const wxColour & col, wxFloodFillStyle style);

 
 

-bool wxWindowDC::DoFloodFill(wxCoord x, wxCoord y,
-                             const wxColour& col, int style)
+bool wxWindowDCImpl::DoFloodFill(wxCoord x, wxCoord y,
+                                 const wxColour& col, wxFloodFillStyle style)

 {
 {

-    return wxDoFloodFill(this, x, y, col, style);
+    return wxDoFloodFill(GetOwner(), x, y, col, style);

 }
 
 }
 

-bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
+bool wxWindowDCImpl::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const

 {
     // Generic (and therefore rather inefficient) method.
     // Could be improved.
     wxMemoryDC memdc;
     wxBitmap bitmap(1, 1);
     memdc.SelectObject(bitmap);
 {
     // Generic (and therefore rather inefficient) method.
     // Could be improved.
     wxMemoryDC memdc;
     wxBitmap bitmap(1, 1);
     memdc.SelectObject(bitmap);

-    memdc.Blit(0, 0, 1, 1, (wxDC*) this, x1, y1);
+    memdc.Blit(0, 0, 1, 1, GetOwner(), x1, y1);

     memdc.SelectObject(wxNullBitmap);
     wxImage image(bitmap.ConvertToImage());
     col->Set(image.GetRed(0, 0), image.GetGreen(0, 0), image.GetBlue(0, 0));
     memdc.SelectObject(wxNullBitmap);
     wxImage image(bitmap.ConvertToImage());
     col->Set(image.GetRed(0, 0), image.GetGreen(0, 0), image.GetBlue(0, 0));

-    return TRUE;
+    return true;

 }
 
 }
 

-void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
+void wxWindowDCImpl::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
     if (m_pen.GetStyle() != wxTRANSPARENT)
     {
 
     if (m_pen.GetStyle() != wxTRANSPARENT)
     {

-        if (m_window)
+        if (m_x11window)

         {
             // This hack is for the iPaq: XDrawLine draws
             // nothing, whereas XDrawLines works...
         {
             // This hack is for the iPaq: XDrawLine draws
             // nothing, whereas XDrawLines works...


@@ -371,9 +388,9 @@ void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
             points[0].y = y1;
             points[1].x = x2;
             points[1].y = y2;
             points[0].y = y1;
             points[1].x = x2;
             points[1].y = y2;

-            DrawLines( 2, points, 0, 0 );
-            
-            // XDrawLine( (Display*) m_display, (Window) m_window, 
+            DoDrawLines( 2, points, 0, 0 );
+
+            // XDrawLine( (Display*) m_display, (Window) m_x11window,

             //    (GC) m_penGC, XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
         }
 
             //    (GC) m_penGC, XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
         }
 


@@ -382,30 +399,30 @@ void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
     }
 }
 
     }
 }
 

-void wxWindowDC::DoCrossHair( wxCoord x, wxCoord y )
+void wxWindowDCImpl::DoCrossHair( wxCoord x, wxCoord y )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
     if (m_pen.GetStyle() != wxTRANSPARENT)
     {
         int w = 0;
         int h = 0;
 
     if (m_pen.GetStyle() != wxTRANSPARENT)
     {
         int w = 0;
         int h = 0;

-        GetSize( &w, &h );
+        DoGetSize( &w, &h );

         wxCoord xx = XLOG2DEV(x);
         wxCoord yy = YLOG2DEV(y);
         wxCoord xx = XLOG2DEV(x);
         wxCoord yy = YLOG2DEV(y);

-        if (m_window)
+        if (m_x11window)

         {
         {

-            XDrawLine( (Display*) m_display, (Window) m_window,
+            XDrawLine( (Display*) m_display, (Window) m_x11window,

                 (GC) m_penGC, 0, yy, XLOG2DEVREL(w), yy );
                 (GC) m_penGC, 0, yy, XLOG2DEVREL(w), yy );

-            XDrawLine( (Display*) m_display, (Window) m_window,
+            XDrawLine( (Display*) m_display, (Window) m_x11window,

                 (GC) m_penGC, xx, 0, xx, YLOG2DEVREL(h) );
         }
     }
 }
 
                 (GC) m_penGC, xx, 0, xx, YLOG2DEVREL(h) );
         }
     }
 }
 

-void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc )
+void wxWindowDCImpl::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
     wxCoord xx1 = XLOG2DEV(x1);
     wxCoord yy1 = YLOG2DEV(y1);
 
     wxCoord xx1 = XLOG2DEV(x1);
     wxCoord yy1 = YLOG2DEV(y1);


@@ -443,7 +460,7 @@ void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCo
     while (alpha2 <= 0) alpha2 += 360*64;
     while (alpha1 > 360*64) alpha1 -= 360*64;
 
     while (alpha2 <= 0) alpha2 += 360*64;
     while (alpha1 > 360*64) alpha1 -= 360*64;
 

-    if (m_window)
+    if (m_x11window)

     {
         if (m_brush.GetStyle() != wxTRANSPARENT)
         {
     {
         if (m_brush.GetStyle() != wxTRANSPARENT)
         {


@@ -452,30 +469,30 @@ void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCo
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                                      
-                XFillArc( (Display*) m_display, (Window) m_window,
+
+                XFillArc( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );

-                    
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );

-                                      
-                XFillArc( (Display*) m_display, (Window) m_window,
+
+                XFillArc( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );

-                    
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );

-                
-                XFillArc( (Display*) m_display, (Window) m_window,
+
+                XFillArc( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)


@@ -483,28 +500,28 @@ void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCo
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                                      
-                XFillArc( (Display*) m_display, (Window) m_window,
+
+                XFillArc( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );

-                    
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else
             {

-                XFillArc( (Display*) m_display, (Window) m_window,
+                XFillArc( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
             }
         }
 
         if (m_pen.GetStyle() != wxTRANSPARENT)
         {
                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
             }
         }
 
         if (m_pen.GetStyle() != wxTRANSPARENT)
         {

-            XDrawArc( (Display*) m_display, (Window) m_window,
+            XDrawArc( (Display*) m_display, (Window) m_x11window,

                (GC) m_penGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
                (GC) m_penGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );

-               
-            XDrawLine( (Display*) m_display, (Window) m_window,
+
+            XDrawLine( (Display*) m_display, (Window) m_x11window,

                (GC) m_penGC, xx1, yy1, xxc, yyc );
                (GC) m_penGC, xx1, yy1, xxc, yyc );

-               
-            XDrawLine( (Display*) m_display, (Window) m_window,
+
+            XDrawLine( (Display*) m_display, (Window) m_x11window,

                (GC) m_penGC, xxc, yyc, xx2, yy2 );
         }
     }
                (GC) m_penGC, xxc, yyc, xx2, yy2 );
         }
     }


@@ -513,9 +530,9 @@ void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCo
     CalcBoundingBox (x2, y2);
 }
 
     CalcBoundingBox (x2, y2);
 }
 

-void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double sa, double ea )
+void wxWindowDCImpl::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double sa, double ea )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
     wxCoord xx = XLOG2DEV(x);
     wxCoord yy = YLOG2DEV(y);
 
     wxCoord xx = XLOG2DEV(x);
     wxCoord yy = YLOG2DEV(y);


@@ -526,7 +543,7 @@ void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord
     if (ww < 0) { ww = -ww; xx = xx - ww; }
     if (hh < 0) { hh = -hh; yy = yy - hh; }
 
     if (ww < 0) { ww = -ww; xx = xx - ww; }
     if (hh < 0) { hh = -hh; yy = yy - hh; }
 

-    if (m_window)
+    if (m_x11window)

     {
         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);


@@ -538,30 +555,30 @@ void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                
-                XFillArc( (Display*) m_display, (Window) m_window,
+
+                XFillArc( (Display*) m_display, (Window) m_x11window,

                     (GC) m_textGC, xx, yy, ww, hh, start, end );
                     (GC) m_textGC, xx, yy, ww, hh, start, end );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );

-                
-                XFillArc( (Display*) m_display, (Window) m_window,
+
+                XFillArc( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xx, yy, ww, hh, start, end );
                     (GC) m_brushGC, xx, yy, ww, hh, start, end );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );

-                
-                XFillArc( (Display*) m_display, (Window) m_window,
+
+                XFillArc( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xx, yy, ww, hh, start, end );
                     (GC) m_brushGC, xx, yy, ww, hh, start, end );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)


@@ -569,22 +586,22 @@ void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                
-                XFillArc( (Display*) m_display, (Window) m_window,
+
+                XFillArc( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xx, yy, ww, hh, start, end );
                     (GC) m_brushGC, xx, yy, ww, hh, start, end );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else
             {

-                XFillArc( (Display*) m_display, (Window) m_window,
+                XFillArc( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xx, yy, ww, hh, start, end );
             }
         }
 
         if (m_pen.GetStyle() != wxTRANSPARENT)
         {
                     (GC) m_brushGC, xx, yy, ww, hh, start, end );
             }
         }
 
         if (m_pen.GetStyle() != wxTRANSPARENT)
         {

-            XDrawArc( (Display*) m_display, (Window) m_window,
+            XDrawArc( (Display*) m_display, (Window) m_x11window,

                 (GC) m_penGC, xx, yy, ww, hh, start, end );
         }
     }
                 (GC) m_penGC, xx, yy, ww, hh, start, end );
         }
     }


@@ -593,20 +610,20 @@ void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord
     CalcBoundingBox (x + width, y + height);
 }
 
     CalcBoundingBox (x + width, y + height);
 }
 

-void wxWindowDC::DoDrawPoint( wxCoord x, wxCoord y )
+void wxWindowDCImpl::DoDrawPoint( wxCoord x, wxCoord y )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
 

-    if ((m_pen.GetStyle() != wxTRANSPARENT) && m_window)
-        XDrawPoint( (Display*) m_display, (Window) m_window,
+    if ((m_pen.GetStyle() != wxTRANSPARENT) && m_x11window)
+        XDrawPoint( (Display*) m_display, (Window) m_x11window,

                 (GC) m_penGC, XLOG2DEV(x), YLOG2DEV(y) );
 
     CalcBoundingBox (x, y);
 }
 
                 (GC) m_penGC, XLOG2DEV(x), YLOG2DEV(y) );
 
     CalcBoundingBox (x, y);
 }
 

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

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
     if (m_pen.GetStyle() == wxTRANSPARENT) return;
     if (n <= 0) return;
 
     if (m_pen.GetStyle() == wxTRANSPARENT) return;
     if (n <= 0) return;


@@ -616,18 +633,19 @@ void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord
     {
         xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
         xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
     {
         xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
         xpoints[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 );
     }

-    XDrawLines( (Display*) m_display, (Window) m_window, (GC) m_penGC, xpoints, n, 0 );
+    XDrawLines( (Display*) m_display, (Window) m_x11window, (GC) m_penGC, xpoints, n, 0 );

 
     delete[] xpoints;
 }
 
 
     delete[] xpoints;
 }
 

-void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
-                                wxCoord xoffset, wxCoord yoffset, int fillStyle )
+void wxWindowDCImpl::DoDrawPolygon( int n, wxPoint points[],
+                                wxCoord xoffset, wxCoord yoffset,
+                                wxPolygonFillMode WXUNUSED(fillStyle) )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

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


@@ -637,44 +655,44 @@ void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
     {
         xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
         xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
     {
         xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
         xpoints[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);
     }
 

-    if (m_window)
+    if (m_x11window)

     {
         if (m_brush.GetStyle() != wxTRANSPARENT)
         {
     {
         if (m_brush.GetStyle() != wxTRANSPARENT)
         {

-        
+

             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                
-                XFillPolygon( (Display*) m_display, (Window) m_window,
+
+                XFillPolygon( (Display*) m_display, (Window) m_x11window,

                     (GC) m_textGC, xpoints, n, Complex, 0);
                     (GC) m_textGC, xpoints, n, Complex, 0);

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );

-                
-                XFillPolygon( (Display*) m_display, (Window) m_window,
+
+                XFillPolygon( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xpoints, n, Complex, 0);
                     (GC) m_brushGC, xpoints, n, Complex, 0);

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );

-                
-                XFillPolygon( (Display*) m_display, (Window) m_window,
+
+                XFillPolygon( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xpoints, n, Complex, 0);
                     (GC) m_brushGC, xpoints, n, Complex, 0);

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)


@@ -682,15 +700,15 @@ void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                
-                XFillPolygon( (Display*) m_display, (Window) m_window,
+
+                XFillPolygon( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xpoints, n, Complex, 0);
                     (GC) m_brushGC, xpoints, n, Complex, 0);

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else
             {

-                XFillPolygon( (Display*) m_display, (Window) m_window,
+                XFillPolygon( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xpoints, n, Complex, 0);
             }
         }
                     (GC) m_brushGC, xpoints, n, Complex, 0);
             }
         }


@@ -701,16 +719,16 @@ void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
             xpoints[i].x = xpoints[0].x;
             xpoints[i].y = xpoints[0].y;
 
             xpoints[i].x = xpoints[0].x;
             xpoints[i].y = xpoints[0].y;
 

-            XDrawLines( (Display*) m_display, (Window) m_window, (GC) m_penGC, xpoints, n + 1, 0);
+            XDrawLines( (Display*) m_display, (Window) m_x11window, (GC) m_penGC, xpoints, n + 1, 0);

         }
     }
 
     delete[] xpoints;
 }
 
         }
     }
 
     delete[] xpoints;
 }
 

-void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
+void wxWindowDCImpl::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
     wxCoord xx = XLOG2DEV(x);
     wxCoord yy = YLOG2DEV(y);
 
     wxCoord xx = XLOG2DEV(x);
     wxCoord yy = YLOG2DEV(y);


@@ -723,8 +741,8 @@ void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord h
     // CMB: handle -ve width and/or height
     if (ww < 0) { ww = -ww; xx = xx - ww; }
     if (hh < 0) { hh = -hh; yy = yy - hh; }
     // CMB: handle -ve width and/or height
     if (ww < 0) { ww = -ww; xx = xx - ww; }
     if (hh < 0) { hh = -hh; yy = yy - hh; }

-    
-    if (m_window)
+
+    if (m_x11window)

     {
         if (m_brush.GetStyle() != wxTRANSPARENT)
         {
     {
         if (m_brush.GetStyle() != wxTRANSPARENT)
         {


@@ -733,30 +751,30 @@ void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord h
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                
-                XFillRectangle( (Display*) m_display, (Window) m_window,
+
+                XFillRectangle( (Display*) m_display, (Window) m_x11window,

                     (GC) m_textGC, xx, yy, ww, hh );
                     (GC) m_textGC, xx, yy, ww, hh );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );

-                
-                XFillRectangle( (Display*) m_display, (Window) m_window,
+
+                XFillRectangle( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xx, yy, ww, hh );
                     (GC) m_brushGC, xx, yy, ww, hh );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );

-                
-                XFillRectangle( (Display*) m_display, (Window) m_window,
+
+                XFillRectangle( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xx, yy, ww, hh );
                     (GC) m_brushGC, xx, yy, ww, hh );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)


@@ -764,22 +782,22 @@ void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord h
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                
-                XFillRectangle( (Display*) m_display, (Window) m_window,
+
+                XFillRectangle( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xx, yy, ww, hh );
                     (GC) m_brushGC, xx, yy, ww, hh );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else
             {

-                XFillRectangle( (Display*) m_display, (Window) m_window,
+                XFillRectangle( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xx, yy, ww, hh );
             }
         }
 
         if (m_pen.GetStyle () != wxTRANSPARENT)
         {
                     (GC) m_brushGC, xx, yy, ww, hh );
             }
         }
 
         if (m_pen.GetStyle () != wxTRANSPARENT)
         {

-            XDrawRectangle( (Display*) m_display, (Window) m_window,
+            XDrawRectangle( (Display*) m_display, (Window) m_x11window,

                 (GC) m_penGC, xx, yy, ww-1, hh-1 );
         }
     }
                 (GC) m_penGC, xx, yy, ww-1, hh-1 );
         }
     }


@@ -788,34 +806,34 @@ void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord h
     CalcBoundingBox( x + width, y + height );
 }
 
     CalcBoundingBox( x + width, y + height );
 }
 

-void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius )
+void wxWindowDCImpl::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
-                                                                                                                  
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+

     if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
     if (radius < 0.0) radius = - radius * ((width < height) ? width : height);

-                                                                                                                  
+

     wxCoord xx = XLOG2DEV(x);
     wxCoord yy = YLOG2DEV(y);
     wxCoord ww = m_signX * XLOG2DEVREL(width);
     wxCoord hh = m_signY * YLOG2DEVREL(height);
     wxCoord rr = XLOG2DEVREL((wxCoord)radius);
     wxCoord xx = XLOG2DEV(x);
     wxCoord yy = YLOG2DEV(y);
     wxCoord ww = m_signX * XLOG2DEVREL(width);
     wxCoord hh = m_signY * YLOG2DEVREL(height);
     wxCoord rr = XLOG2DEVREL((wxCoord)radius);

-                                                                                                                  
+

     // CMB: handle -ve width and/or height
     if (ww < 0) { ww = -ww; xx = xx - ww; }
     if (hh < 0) { hh = -hh; yy = yy - hh; }
     // CMB: handle -ve width and/or height
     if (ww < 0) { ww = -ww; xx = xx - ww; }
     if (hh < 0) { hh = -hh; yy = yy - hh; }

-                                                                                                                  
+

     // CMB: if radius is zero use DrawRectangle() instead to avoid
     // X drawing errors with small radii
     if (rr == 0)
     {
     // CMB: if radius is zero use DrawRectangle() instead to avoid
     // X drawing errors with small radii
     if (rr == 0)
     {

-            XDrawRectangle( (Display*) m_display, (Window) m_window,
+            XDrawRectangle( (Display*) m_display, (Window) m_x11window,

                 (GC) m_penGC, x, y, width, height);
         return;
     }
                 (GC) m_penGC, x, y, width, height);
         return;
     }

-                                                                                                                  
+

     // CMB: draw nothing if transformed w or h is 0
     if (ww == 0 || hh == 0) return;
     // CMB: draw nothing if transformed w or h is 0
     if (ww == 0 || hh == 0) return;

-                                                                                                                  
+

     // CMB: adjust size if outline is drawn otherwise the result is
     // 1 pixel too wide and high
     if (m_pen.GetStyle() != wxTRANSPARENT)
     // CMB: adjust size if outline is drawn otherwise the result is
     // 1 pixel too wide and high
     if (m_pen.GetStyle() != wxTRANSPARENT)


@@ -823,8 +841,8 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
         ww--;
         hh--;
     }
         ww--;
         hh--;
     }

-    
-    if (m_window)
+
+    if (m_x11window)

     {
         // CMB: ensure dd is not larger than rectangle otherwise we
         // get an hour glass shape
     {
         // CMB: ensure dd is not larger than rectangle otherwise we
         // get an hour glass shape


@@ -832,88 +850,88 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
         if (dd > ww) dd = ww;
         if (dd > hh) dd = hh;
         rr = dd / 2;
         if (dd > ww) dd = ww;
         if (dd > hh) dd = hh;
         rr = dd / 2;

-                                                                                                                  
+

         if (m_brush.GetStyle() != wxTRANSPARENT)
         {
             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
             {
         if (m_brush.GetStyle() != wxTRANSPARENT)
         {
             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
             {

-                XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 
-                              m_deviceOriginX % m_brush.GetStipple()->GetWidth(), 
+                XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
+                              m_deviceOriginX % m_brush.GetStipple()->GetWidth(),

                               m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                               m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_textGC, xx+rr, yy, ww-dd+1, hh );
-                XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_textGC, xx, yy+rr, ww, hh-dd+1 );
-                XFillArc( (Display*) m_display, (Window) m_window, (GC) m_textGC, xx, yy, dd, dd, 90*64, 90*64 );
-                XFillArc( (Display*) m_display, (Window) m_window, (GC) m_textGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
-                XFillArc( (Display*) m_display, (Window) m_window, (GC) m_textGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
-                XFillArc( (Display*) m_display, (Window) m_window, (GC) m_textGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
+                XFillRectangle( (Display*) m_display, (Window) m_x11window, (GC) m_textGC, xx+rr, yy, ww-dd+1, hh );
+                XFillRectangle( (Display*) m_display, (Window) m_x11window, (GC) m_textGC, xx, yy+rr, ww, hh-dd+1 );
+                XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_textGC, xx, yy, dd, dd, 90*64, 90*64 );
+                XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_textGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
+                XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_textGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
+                XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_textGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );

                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0);
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, m_deviceOriginX % 15, m_deviceOriginY % 15 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0);
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, m_deviceOriginX % 15, m_deviceOriginY % 15 );

-                XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+rr, yy, ww-dd+1, hh );
-                XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy+rr, ww, hh-dd+1 );
-                XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy, dd, dd, 90*64, 90*64 );
-                XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
-                XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
-                XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
+                XFillRectangle( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx+rr, yy, ww-dd+1, hh );
+                XFillRectangle( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx, yy+rr, ww, hh-dd+1 );
+                XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx, yy, dd, dd, 90*64, 90*64 );
+                XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
+                XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
+                XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0);
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, m_deviceOriginX % 16, m_deviceOriginY % 16 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0);
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, m_deviceOriginX % 16, m_deviceOriginY % 16 );

-                XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+rr, yy, ww-dd+1, hh );
-                XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy+rr, ww, hh-dd+1 );
-                XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy, dd, dd, 90*64, 90*64 );
-                XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
-                XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
-                XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
+                XFillRectangle( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx+rr, yy, ww-dd+1, hh );
+                XFillRectangle( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx, yy+rr, ww, hh-dd+1 );
+                XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx, yy, dd, dd, 90*64, 90*64 );
+                XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
+                XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
+                XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0);
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0);
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)
             {

-                XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 
+                XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,

                               m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                               m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                               m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                               m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+rr, yy, ww-dd+1, hh );
-                XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy+rr, ww, hh-dd+1 );
-                XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy, dd, dd, 90*64, 90*64 );
-                XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
-                XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
-                XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
+                XFillRectangle( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx+rr, yy, ww-dd+1, hh );
+                XFillRectangle( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx, yy+rr, ww, hh-dd+1 );
+                XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx, yy, dd, dd, 90*64, 90*64 );
+                XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
+                XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
+                XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0);
             }
             else
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0);
             }
             else
             {

-               XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+rr, yy, ww-dd+1, hh );
-               XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy+rr, ww, hh-dd+1 );
-               XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy, dd, dd, 90*64, 90*64 );
-               XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
-               XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
-               XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
+               XFillRectangle( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx+rr, yy, ww-dd+1, hh );
+               XFillRectangle( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx, yy+rr, ww, hh-dd+1 );
+               XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx, yy, dd, dd, 90*64, 90*64 );
+               XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
+               XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
+               XFillArc( (Display*) m_display, (Window) m_x11window, (GC) m_brushGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );

             }
         }
      if (m_pen.GetStyle() != wxTRANSPARENT)
         {
             }
         }
      if (m_pen.GetStyle() != wxTRANSPARENT)
         {

-            XDrawLine( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx+rr+1, yy, xx+ww-rr, yy );
-            XDrawLine( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx+rr+1, yy+hh, xx+ww-rr, yy+hh );
-            XDrawLine( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx, yy+rr+1, xx, yy+hh-rr );
-            XDrawLine( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx+ww, yy+rr+1, xx+ww, yy+hh-rr );
-            XDrawArc( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx, yy, dd, dd, 90*64, 90*64 );
-            XDrawArc( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
-            XDrawArc( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
-            XDrawArc( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
+            XDrawLine( (Display*) m_display, (Window) m_x11window, (GC) m_penGC, xx+rr+1, yy, xx+ww-rr, yy );
+            XDrawLine( (Display*) m_display, (Window) m_x11window, (GC) m_penGC, xx+rr+1, yy+hh, xx+ww-rr, yy+hh );
+            XDrawLine( (Display*) m_display, (Window) m_x11window, (GC) m_penGC, xx, yy+rr+1, xx, yy+hh-rr );
+            XDrawLine( (Display*) m_display, (Window) m_x11window, (GC) m_penGC, xx+ww, yy+rr+1, xx+ww, yy+hh-rr );
+            XDrawArc( (Display*) m_display, (Window) m_x11window, (GC) m_penGC, xx, yy, dd, dd, 90*64, 90*64 );
+            XDrawArc( (Display*) m_display, (Window) m_x11window, (GC) m_penGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
+            XDrawArc( (Display*) m_display, (Window) m_x11window, (GC) m_penGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
+            XDrawArc( (Display*) m_display, (Window) m_x11window, (GC) m_penGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );

         }
     }
         }
     }

-                                                                                                                  
+

     // this ignores the radius
     CalcBoundingBox( x, y );
     CalcBoundingBox( x + width, y + height );
 }
 
     // this ignores the radius
     CalcBoundingBox( x, y );
     CalcBoundingBox( x + width, y + height );
 }
 

-void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
+void wxWindowDCImpl::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
     wxCoord xx = XLOG2DEV(x);
     wxCoord yy = YLOG2DEV(y);
 
     wxCoord xx = XLOG2DEV(x);
     wxCoord yy = YLOG2DEV(y);


@@ -924,7 +942,7 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
     if (ww < 0) { ww = -ww; xx = xx - ww; }
     if (hh < 0) { hh = -hh; yy = yy - hh; }
 
     if (ww < 0) { ww = -ww; xx = xx - ww; }
     if (hh < 0) { hh = -hh; yy = yy - hh; }
 

-    if (m_window)
+    if (m_x11window)

     {
         if (m_brush.GetStyle() != wxTRANSPARENT)
         {
     {
         if (m_brush.GetStyle() != wxTRANSPARENT)
         {


@@ -933,30 +951,30 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                
-                XFillArc( (Display*) m_display, (Window) m_window,
+
+                XFillArc( (Display*) m_display, (Window) m_x11window,

                     (GC) m_textGC, xx, yy, ww, hh, 0, 360*64 );
                     (GC) m_textGC, xx, yy, ww, hh, 0, 360*64 );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );

-                
-                XFillArc( (Display*) m_display, (Window) m_window,
+
+                XFillArc( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );

-                
-                XFillArc( (Display*) m_display, (Window) m_window,
+
+                XFillArc( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)


@@ -964,22 +982,22 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                
-                XFillArc( (Display*) m_display, (Window) m_window,
+
+                XFillArc( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else
             {

-                XFillArc( (Display*) m_display, (Window) m_window,
+                XFillArc( (Display*) m_display, (Window) m_x11window,

                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
             }
         }
 
         if (m_pen.GetStyle () != wxTRANSPARENT)
         {
                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
             }
         }
 
         if (m_pen.GetStyle () != wxTRANSPARENT)
         {

-            XDrawArc( (Display*) m_display, (Window) m_window,
+            XDrawArc( (Display*) m_display, (Window) m_x11window,

                 (GC) m_penGC, xx, yy, ww, hh, 0, 360*64 );
         }
     }
                 (GC) m_penGC, xx, yy, ww, hh, 0, 360*64 );
         }
     }


@@ -988,20 +1006,20 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
     CalcBoundingBox( x + width, y + height );
 }
 
     CalcBoundingBox( x + width, y + height );
 }
 

-void wxWindowDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y)
+void wxWindowDCImpl::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y)

 {
 {

-    DoDrawBitmap(icon, x, y, TRUE);
+    DoDrawBitmap(icon, x, y, true);

 }
 
 #if wxUSE_NANOX
 }
 
 #if wxUSE_NANOX

-void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
+void wxWindowDCImpl::DoDrawBitmap( const wxBitmap &bitmap,

                                wxCoord x, wxCoord y,
                                bool useMask )
 {
                                wxCoord x, wxCoord y,
                                bool useMask )
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+
+    wxCHECK_RET( bitmap.IsOk(), wxT("invalid bitmap") );

 
 

-    wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
-    

     bool is_mono = (bitmap.GetBitmap() != NULL);
 
     /* scale/translate size and position */
     bool is_mono = (bitmap.GetBitmap() != NULL);
 
     /* scale/translate size and position */


@@ -1014,7 +1032,7 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
     CalcBoundingBox( x, y );
     CalcBoundingBox( x + w, y + h );
 
     CalcBoundingBox( x, y );
     CalcBoundingBox( x + w, y + h );
 

-    if (!m_window) return;
+    if (!m_x11window) return;

 
     int ww = XLOG2DEVREL(w);
     int hh = YLOG2DEVREL(h);
 
     int ww = XLOG2DEVREL(w);
     int hh = YLOG2DEVREL(h);


@@ -1070,10 +1088,10 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
         // In DoBlit, we may be able to eliminate this step
         // if we check if the rop = copy
 #if 0
         // In DoBlit, we may be able to eliminate this step
         // if we check if the rop = copy
 #if 0

-        GrCopyArea(bufPixmap, gc, 0, 0, w, h, (Window) m_window,
+        GrCopyArea(bufPixmap, gc, 0, 0, w, h, (Window) m_x11window,

                   0, 0, GR_MODE_COPY);
 #endif
                   0, 0, GR_MODE_COPY);
 #endif

-            
+

         // Copy src to buffer using selected raster op (none selected
         // in DrawBitmap, so just use Gxcopy)
         GrCopyArea(bufPixmap, gc, 0, 0, w, h, pixmap,
         // Copy src to buffer using selected raster op (none selected
         // in DrawBitmap, so just use Gxcopy)
         GrCopyArea(bufPixmap, gc, 0, 0, w, h, pixmap,


@@ -1084,22 +1102,22 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
         GrSetGCForeground(gc, BLACK);
         GrCopyArea(bufPixmap, gc, 0, 0, w, h, maskPixmap,
                     0, 0, GR_MODE_AND);
         GrSetGCForeground(gc, BLACK);
         GrCopyArea(bufPixmap, gc, 0, 0, w, h, maskPixmap,
                     0, 0, GR_MODE_AND);

-                       
+

         // set unmasked area in dest to BLACK
         GrSetGCBackground(gc, BLACK);
         GrSetGCForeground(gc, WHITE);
         // set unmasked area in dest to BLACK
         GrSetGCBackground(gc, BLACK);
         GrSetGCForeground(gc, WHITE);

-        GrCopyArea((Window) m_window, gc, xx, yy, w, h, maskPixmap,
+        GrCopyArea((Window) m_x11window, gc, xx, yy, w, h, maskPixmap,

                    0, 0, GR_MODE_AND);
 
         // OR buffer to dest
                    0, 0, GR_MODE_AND);
 
         // OR buffer to dest

-        GrCopyArea((Window) m_window, gc, xx, yy, w, h, bufPixmap,
+        GrCopyArea((Window) m_x11window, gc, xx, yy, w, h, bufPixmap,

                    0, 0, GR_MODE_OR);
 
         GrDestroyGC(gc);
         GrDestroyWindow(bufPixmap);
     }
     else
                    0, 0, GR_MODE_OR);
 
         GrDestroyGC(gc);
         GrDestroyWindow(bufPixmap);
     }
     else

-      XCopyArea( (Display*) m_display, (Pixmap) use_bitmap.GetPixmap(), (Window) m_window,
+      XCopyArea( (Display*) m_display, (Pixmap) use_bitmap.GetPixmap(), (Window) m_x11window,

             (GC) m_penGC, 0, 0, w, h, xx, yy );
 
     /* remove mask again if any */
             (GC) m_penGC, 0, 0, w, h, xx, yy );
 
     /* remove mask again if any */


@@ -1113,14 +1131,14 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
 #else
 
 // Normal X11
 #else
 
 // Normal X11

-void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
+void wxWindowDCImpl::DoDrawBitmap( const wxBitmap &bitmap,

                                wxCoord x, wxCoord y,
                                bool useMask )
 {
                                wxCoord x, wxCoord y,
                                bool useMask )
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+
+    wxCHECK_RET( bitmap.IsOk(), wxT("invalid bitmap") );

 
 

-    wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
-    

     bool is_mono = (bitmap.GetBitmap() != NULL);
 
     // scale/translate size and position
     bool is_mono = (bitmap.GetBitmap() != NULL);
 
     // scale/translate size and position


@@ -1133,7 +1151,7 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
     CalcBoundingBox( x, y );
     CalcBoundingBox( x + w, y + h );
 
     CalcBoundingBox( x, y );
     CalcBoundingBox( x + w, y + h );
 

-    if (!m_window) return;
+    if (!m_x11window) return;

 
     int ww = XLOG2DEVREL(w);
     int hh = YLOG2DEVREL(h);
 
     int ww = XLOG2DEVREL(w);
     int hh = YLOG2DEVREL(h);


@@ -1168,63 +1186,90 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
     // apply mask if any
     WXPixmap mask = NULL;
     if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
     // apply mask if any
     WXPixmap mask = NULL;
     if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();

-    
-        if (useMask && mask)
+
+    bool setClipMask = false;
+
+    if (!m_currentClippingRegion.IsNull() || (useMask && mask))
+    {
+        // XSetClipMask() call is necessary (because of clip region and/or transparent mask)
+        setClipMask = true;
+        Pixmap new_pixmap = 0;
+
+        if (!m_currentClippingRegion.IsNull())

         {
         {

-            WXPixmap new_mask = NULL;
-#if 0
-            if (!m_currentClippingRegion.IsNull())
+            // clipping necessary => create new_pixmap
+            Display *xdisplay = (Display*) m_display;
+            int xscreen = DefaultScreen( xdisplay );
+            Window xroot = RootWindow( xdisplay, xscreen );
+
+            new_pixmap = XCreatePixmap( xdisplay, xroot, ww, hh, 1 );
+            GC gc = XCreateGC( xdisplay, new_pixmap, 0, NULL );
+
+            XSetForeground( xdisplay, gc, BlackPixel(xdisplay,xscreen) );
+
+            XSetFillStyle( xdisplay, gc, FillSolid );
+            XFillRectangle( xdisplay, new_pixmap, gc, 0, 0, ww, hh );
+
+            XSetForeground( xdisplay, gc, WhitePixel(xdisplay,xscreen) );
+
+            if (useMask && mask)

             {
             {

-                GdkColor col;
-                new_mask = gdk_pixmap_new( wxGetRootWindow()->window, ww, hh, 1 );
-                GdkGC *gc = gdk_gc_new( new_mask );
-                col.pixel = 0;
-                gdk_gc_set_foreground( gc, &col );
-                gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, ww, hh );
-                col.pixel = 0;
-                gdk_gc_set_background( gc, &col );
-                col.pixel = 1;
-                gdk_gc_set_foreground( gc, &col );
-                gdk_gc_set_clip_region( gc, m_currentClippingRegion.GetRegion() );
-                gdk_gc_set_clip_origin( gc, -xx, -yy );
-                gdk_gc_set_fill( gc, GDK_OPAQUE_STIPPLED );
-                gdk_gc_set_stipple( gc, mask );
-                gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, ww, hh );
-                gdk_gc_unref( gc );
+                // transparent mask => call XSetStipple
+                XSetFillStyle( xdisplay, gc, FillStippled );
+                XSetTSOrigin( xdisplay, gc, 0, 0);
+                XSetStipple( xdisplay, gc, (Pixmap) mask);

             }
             }

-#endif
-            if (is_mono)
+
+            wxVector<XRectangle> rects;
+            for ( wxRegionIterator iter(m_currentClippingRegion);
+                  iter;
+                  ++iter )

             {
             {

-                if (new_mask)
-                    XSetClipMask( (Display*) m_display, (GC) m_textGC, (Pixmap) new_mask );
-                else
-                    XSetClipMask( (Display*) m_display, (GC) m_textGC, (Pixmap) mask );
-                XSetClipOrigin( (Display*) m_display, (GC) m_textGC, xx, yy );
+                XRectangle rect;
+                rect.x = iter.GetX() - xx;
+                rect.y = iter.GetY() - yy;
+                rect.width = iter.GetWidth();
+                rect.height = iter.GetHeight();
+                rects.push_back(rect);

             }
             }

+
+            XFillRectangles(xdisplay, new_pixmap, gc, &rects[0], rects.size());
+
+            XFreeGC( xdisplay, gc );
+        }
+
+        if (is_mono)
+        {
+            if (new_pixmap)
+                XSetClipMask( (Display*) m_display, (GC) m_textGC, new_pixmap );

             else
             else

-            {
-                if (new_mask)
-                    XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) new_mask );
-                else
-                    XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) mask );
-                XSetClipOrigin( (Display*) m_display, (GC) m_penGC, xx, yy );
-            }
-            
-            if (new_mask)
-               XFreePixmap( (Display*) m_display, (Pixmap) new_mask );
+                XSetClipMask( (Display*) m_display, (GC) m_textGC, (Pixmap) mask );
+            XSetClipOrigin( (Display*) m_display, (GC) m_textGC, xx, yy );
+        }
+        else
+        {
+            if (new_pixmap)
+                XSetClipMask( (Display*) m_display, (GC) m_penGC, new_pixmap );
+            else
+                XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) mask );
+            XSetClipOrigin( (Display*) m_display, (GC) m_penGC, xx, yy );

         }
 
         }
 

+        if (new_pixmap)
+            XFreePixmap( (Display*) m_display, new_pixmap );
+    }
+

     // Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
     // drawing a mono-bitmap (XBitmap) we use the current text GC
     if (is_mono)
     // Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
     // drawing a mono-bitmap (XBitmap) we use the current text GC
     if (is_mono)

-        XCopyPlane( (Display*) m_display, (Pixmap) use_bitmap.GetBitmap(), (Window) m_window,
-            (GC) m_textGC, 0, 0, w, h, xx, yy, 1 );
+        XCopyPlane( (Display*) m_display, (Pixmap) use_bitmap.GetBitmap(), (Window) m_x11window,
+            (GC) m_textGC, 0, 0, ww, hh, xx, yy, 1 );

     else
     else

-        XCopyArea( (Display*) m_display, (Pixmap) use_bitmap.GetPixmap(), (Window) m_window,
-            (GC) m_penGC, 0, 0, w, h, xx, yy );
+        XCopyArea( (Display*) m_display, (Pixmap) use_bitmap.GetPixmap(), (Window) m_x11window,
+            (GC) m_penGC, 0, 0, ww, hh, xx, yy );

 
     // remove mask again if any
 
     // remove mask again if any

-    if (useMask && mask)
+    if (setClipMask)

     {
         if (is_mono)
         {
     {
         if (is_mono)
         {


@@ -1245,8 +1290,9 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
 #endif
   // wxUSE_NANOX/!wxUSE_NANOX
 
 #endif
   // wxUSE_NANOX/!wxUSE_NANOX
 

-bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
-                         wxDC *source, wxCoord xsrc, wxCoord ysrc, int logical_func, bool useMask,
+bool wxWindowDCImpl::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
+                         wxDC *source, wxCoord xsrc, wxCoord ysrc,
+                         wxRasterOperationMode logical_func, bool useMask,

                          wxCoord xsrcMask, wxCoord ysrcMask )
 {
    /* this is the nth try to get this utterly useless function to
                          wxCoord xsrcMask, wxCoord ysrcMask )
 {
    /* this is the nth try to get this utterly useless function to


@@ -1254,32 +1300,35 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
       of the source dc, but scales correctly on the target dc and
       knows about possible mask information in a memory dc. */
 
       of the source dc, but scales correctly on the target dc and
       knows about possible mask information in a memory dc. */
 

-    wxCHECK_MSG( Ok(), FALSE, wxT("invalid window dc") );
+    wxCHECK_MSG( IsOk(), false, wxT("invalid window dc") );

 
 

-    wxCHECK_MSG( source, FALSE, wxT("invalid source dc") );
+    wxCHECK_MSG( source, false, wxT("invalid source dc") );

 
 

-    if (!m_window) return FALSE;
+    if (!m_x11window) return false;

 
     // transform the source DC coords to the device ones
 
     // transform the source DC coords to the device ones

-    xsrc = source->XLOG2DEV(xsrc);
-    ysrc = source->YLOG2DEV(ysrc);
+    xsrc = source->LogicalToDeviceX(xsrc);
+    ysrc = source->LogicalToDeviceY(ysrc);

 
     wxClientDC *srcDC = (wxClientDC*)source;
     wxMemoryDC *memDC = (wxMemoryDC*)source;
 
     wxClientDC *srcDC = (wxClientDC*)source;
     wxMemoryDC *memDC = (wxMemoryDC*)source;

+    wxWindowDCImpl *src_impl = (wxWindowDCImpl*) srcDC->GetImpl();

 
 

-    bool use_bitmap_method = FALSE;
-    bool is_mono = FALSE;
+    bool use_bitmap_method = false;
+    bool is_mono = false;

 
 

-    // TODO: use the mask origin when drawing transparently 
+    // TODO: use the mask origin when drawing transparently

     if (xsrcMask == -1 && ysrcMask == -1)
     {
         xsrcMask = xsrc;
         ysrcMask = ysrc;
     }
     if (xsrcMask == -1 && ysrcMask == -1)
     {
         xsrcMask = xsrc;
         ysrcMask = ysrc;
     }

-    
-    if (srcDC->m_isMemDC)
+
+    if (src_impl->m_isMemDC)

     {
     {

-        if (!memDC->m_selected.Ok()) return FALSE;
+        wxBitmap selected = memDC->GetSelectedBitmap();
+
+        if (!selected.IsOk()) return false;

 
         /* we use the "XCopyArea" way to copy a memory dc into
            y different window if the memory dc BOTH
 
         /* we use the "XCopyArea" way to copy a memory dc into
            y different window if the memory dc BOTH


@@ -1287,34 +1336,34 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
            b) it is clipped
            c) is not 1-bit */
 
            b) it is clipped
            c) is not 1-bit */
 

-        if (useMask && (memDC->m_selected.GetMask()))
+        if (useMask && (selected.GetMask()))

         {
            /* we HAVE TO use the direct way for memory dcs
               that have mask since the XCopyArea doesn't know
               about masks */
         {
            /* we HAVE TO use the direct way for memory dcs
               that have mask since the XCopyArea doesn't know
               about masks */

-            use_bitmap_method = TRUE;
+            use_bitmap_method = true;

         }
         }

-        else if (memDC->m_selected.GetDepth() == 1)
+        else if (selected.GetDepth() == 1)

         {
            /* we HAVE TO use the direct way for memory dcs
               that are bitmaps because XCopyArea doesn't cope
               with different bit depths */
         {
            /* we HAVE TO use the direct way for memory dcs
               that are bitmaps because XCopyArea doesn't cope
               with different bit depths */

-            is_mono = TRUE;
-            use_bitmap_method = TRUE;
+            is_mono = true;
+            use_bitmap_method = true;

         }
         else if ((xsrc == 0) && (ysrc == 0) &&
         }
         else if ((xsrc == 0) && (ysrc == 0) &&

-                 (width == memDC->m_selected.GetWidth()) &&
-                 (height == memDC->m_selected.GetHeight()))
+                 (width == selected.GetWidth()) &&
+                 (height == selected.GetHeight()))

         {
            /* we SHOULD use the direct way if all of the bitmap
               in the memory dc is copied in which case XCopyArea
               wouldn't be able able to boost performace by reducing
               the area to be scaled */
         {
            /* we SHOULD use the direct way if all of the bitmap
               in the memory dc is copied in which case XCopyArea
               wouldn't be able able to boost performace by reducing
               the area to be scaled */

-            use_bitmap_method = TRUE;
+            use_bitmap_method = true;

         }
         else
         {
         }
         else
         {

-            use_bitmap_method = FALSE;
+            use_bitmap_method = false;

         }
     }
 
         }
     }
 


@@ -1334,17 +1383,19 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
         wxRegion tmp( xx,yy,ww,hh );
         tmp.Intersect( m_currentClippingRegion );
         if (tmp.IsEmpty())
         wxRegion tmp( xx,yy,ww,hh );
         tmp.Intersect( m_currentClippingRegion );
         if (tmp.IsEmpty())

-            return TRUE;
+            return true;

     }
 
     }
 

-    int old_logical_func = m_logicalFunction;
+    wxRasterOperationMode old_logical_func = m_logicalFunction;

     SetLogicalFunction( logical_func );
 
     if (use_bitmap_method)
     {
     SetLogicalFunction( logical_func );
 
     if (use_bitmap_method)
     {

+        wxBitmap selected = memDC->GetSelectedBitmap();
+

         // scale/translate bitmap size
         // scale/translate bitmap size

-        wxCoord bm_width = memDC->m_selected.GetWidth();
-        wxCoord bm_height = memDC->m_selected.GetHeight();
+        wxCoord bm_width = selected.GetWidth();
+        wxCoord bm_height = selected.GetHeight();

 
         wxCoord bm_ww = XLOG2DEVREL( bm_width );
         wxCoord bm_hh = YLOG2DEVREL( bm_height );
 
         wxCoord bm_ww = XLOG2DEVREL( bm_width );
         wxCoord bm_hh = YLOG2DEVREL( bm_height );


@@ -1354,7 +1405,7 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
 
         if ((bm_width != bm_ww) || (bm_height != bm_hh))
         {
 
         if ((bm_width != bm_ww) || (bm_height != bm_hh))
         {

-            wxImage image( memDC->m_selected.ConvertToImage() );
+            wxImage image( selected.ConvertToImage() );

             image = image.Scale( bm_ww, bm_hh );
 
 #if 0
             image = image.Scale( bm_ww, bm_hh );
 
 #if 0


@@ -1366,7 +1417,7 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
         }
         else
         {
         }
         else
         {

-            use_bitmap = memDC->m_selected;
+            use_bitmap = selected;

         }
 
         // apply mask if any
         }
 
         // apply mask if any


@@ -1413,19 +1464,18 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
                     XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) mask );
                 XSetClipOrigin( (Display*) m_display, (GC) m_penGC, xx, yy );
             }
                     XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) mask );
                 XSetClipOrigin( (Display*) m_display, (GC) m_penGC, xx, yy );
             }

-            
+

             if (new_mask)
                XFreePixmap( (Display*) m_display, (Pixmap) new_mask );
         }
 
         // Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
         // drawing a mono-bitmap (XBitmap) we use the current text GC
             if (new_mask)
                XFreePixmap( (Display*) m_display, (Pixmap) new_mask );
         }
 
         // Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
         // drawing a mono-bitmap (XBitmap) we use the current text GC

-

         if (is_mono)
         if (is_mono)

-            XCopyPlane( (Display*) m_display, (Pixmap) use_bitmap.GetBitmap(), (Window) m_window,
+            XCopyPlane( (Display*) m_display, (Pixmap) use_bitmap.GetBitmap(), (Window) m_x11window,

                 (GC) m_textGC, xsrc, ysrc, width, height, xx, yy, 1 );
         else
                 (GC) m_textGC, xsrc, ysrc, width, height, xx, yy, 1 );
         else

-            XCopyArea( (Display*) m_display, (Pixmap) use_bitmap.GetPixmap(), (Window) m_window,
+            XCopyArea( (Display*) m_display, (Pixmap) use_bitmap.GetPixmap(), (Window) m_x11window,

                 (GC) m_penGC, xsrc, ysrc, width, height, xx, yy );
 
         // remove mask again if any
                 (GC) m_penGC, xsrc, ysrc, width, height, xx, yy );
 
         // remove mask again if any


@@ -1449,6 +1499,14 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
     }
     else // use_bitmap_method
     {
     }
     else // use_bitmap_method
     {

+        wxDCImpl *impl = srcDC->GetImpl();
+        wxWindowDCImpl *x11_impl = wxDynamicCast(impl, wxWindowDCImpl);
+        if (!x11_impl)
+        {
+            SetLogicalFunction( old_logical_func );
+            return false;
+        }
+

         if ((width != ww) || (height != hh))
         {
             /* Draw source window into a bitmap as we cannot scale
         if ((width != ww) || (height != hh))
         {
             /* Draw source window into a bitmap as we cannot scale


@@ -1468,7 +1526,7 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
 
             // copy including child window contents
             XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, IncludeInferiors );
 
             // copy including child window contents
             XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, IncludeInferiors );

-            XCopyArea( (Display*) m_display, (Window) srcDC->GetWindow(), (Window) bitmap.GetPixmap(),
+            XCopyArea( (Display*) m_display, (Window) x11_impl->GetX11Window(), (Window) bitmap.GetPixmap(),

                        (GC) m_penGC, xsrc, ysrc, width, height, 0, 0 );
             XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, ClipByChildren );
 
                        (GC) m_penGC, xsrc, ysrc, width, height, 0, 0 );
             XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, ClipByChildren );
 


@@ -1480,31 +1538,30 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
             bitmap = image;
 
             // draw scaled bitmap
             bitmap = image;
 
             // draw scaled bitmap

-            XCopyArea( (Display*) m_display, (Window) bitmap.GetPixmap(), (Window) m_window, 
+            XCopyArea( (Display*) m_display, (Window) bitmap.GetPixmap(), (Window) m_x11window,

                        (GC) m_penGC, 0, 0, width, height, xx, yy );
         }
         else
         {
             // No scaling and not a memory dc with a mask either
                        (GC) m_penGC, 0, 0, width, height, xx, yy );
         }
         else
         {
             // No scaling and not a memory dc with a mask either

-

             // copy including child window contents
             XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, IncludeInferiors );
             // copy including child window contents
             XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, IncludeInferiors );

-            XCopyArea( (Display*) m_display, (Window) srcDC->GetWindow(), (Window) m_window, 
+            XCopyArea( (Display*) m_display, (Window) x11_impl->GetX11Window(), (Window) m_x11window,

                        (GC) m_penGC, xsrc, ysrc, width, height, xx, yy );
             XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, ClipByChildren );
         }
     }
 
     SetLogicalFunction( old_logical_func );
                        (GC) m_penGC, xsrc, ysrc, width, height, xx, yy );
             XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, ClipByChildren );
         }
     }
 
     SetLogicalFunction( old_logical_func );

-    
-    return TRUE;
+
+    return true;

 }
 
 }
 

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

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
 

-    if (!m_window) return;
+    if (!m_x11window) return;

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


@@ -1512,31 +1569,31 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
 #if wxUSE_UNICODE
     PangoLayout *layout = pango_layout_new(m_context);
     pango_layout_set_font_description(layout, m_fontdesc);
 #if wxUSE_UNICODE
     PangoLayout *layout = pango_layout_new(m_context);
     pango_layout_set_font_description(layout, m_fontdesc);

-    
-    const wxCharBuffer data = wxConvUTF8.cWC2MB( text );
-    pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
-    
+
+    const wxScopedCharBuffer data(text.utf8_str());
+    pango_layout_set_text(layout, data, data.length());
+

     // Measure layout.
     int w,h;
     pango_layout_get_pixel_size(layout, &w, &h);
     wxCoord width = w;
     wxCoord height = h;
     // Measure layout.
     int w,h;
     pango_layout_get_pixel_size(layout, &w, &h);
     wxCoord width = w;
     wxCoord height = h;

-    
+

     // Draw layout.
     // Draw layout.

-    x11_draw_layout( (Drawable) m_window, (GC) m_textGC, x, y, layout, m_textForegroundColour );
-    
+    x11_draw_layout( (Drawable) m_x11window, (GC) m_textGC, x, y, layout, m_textForegroundColour );
+

     g_object_unref( G_OBJECT( layout ) );
     g_object_unref( G_OBJECT( layout ) );

-    
+

     CalcBoundingBox (x + width, y + height);
     CalcBoundingBox (x, y);
 #else
     XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
 
     wxCHECK_RET( xfont, wxT("invalid font") );
     CalcBoundingBox (x + width, y + height);
     CalcBoundingBox (x, y);
 #else
     XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
 
     wxCHECK_RET( xfont, wxT("invalid font") );

-    
+

     // First draw a rectangle representing the text background, if a text
     // background is specified
     // First draw a rectangle representing the text background, if a text
     // background is specified

-    if (m_textBackgroundColour.Ok () && (m_backgroundMode != wxTRANSPARENT))
+    if (m_textBackgroundColour.IsOk () && (m_backgroundMode != wxTRANSPARENT))

     {
         // Since X draws from the baseline of the text, must add the text height
         int cx = 0;
     {
         // Since X draws from the baseline of the text, must add the text height
         int cx = 0;


@@ -1548,14 +1605,15 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
         slen = strlen(text);
         XCharStruct overall_return;
 
         slen = strlen(text);
         XCharStruct overall_return;
 

-        (void)XTextExtents(xfont, (char*) text.c_str(), slen, &direction,
+        (void)XTextExtents(xfont, (const char*) text.c_str(), slen, &direction,

                                  &ascent, &descent, &overall_return);
 
         cx = overall_return.width;
         cy = ascent + descent;
         m_textBackgroundColour.CalcPixel(m_cmap);
                                  &ascent, &descent, &overall_return);
 
         cx = overall_return.width;
         cy = ascent + descent;
         m_textBackgroundColour.CalcPixel(m_cmap);

+        m_textForegroundColour.CalcPixel(m_cmap);

         XSetForeground ((Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel());
         XSetForeground ((Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel());

-        XFillRectangle( (Display*) m_display, (Window) m_window,
+        XFillRectangle( (Display*) m_display, (Window) m_x11window,

                     (GC) m_textGC, x, y, cx, cy );
         XSetForeground ((Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel());
 
                     (GC) m_textGC, x, y, cx, cy );
         XSetForeground ((Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel());
 


@@ -1563,11 +1621,13 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
 
     XSetFont( (Display*) m_display, (GC) m_textGC, xfont->fid );
 #if !wxUSE_NANOX
 
     XSetFont( (Display*) m_display, (GC) m_textGC, xfont->fid );
 #if !wxUSE_NANOX

-    if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))
+    // This may be a test for whether the font is 16-bit, but it also
+    // seems to fail for valid 8-bit fonts too.
+    if (1) // (xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))

 #endif
     {
 #endif
     {

-        XDrawString( (Display*) m_display, (Window) m_window, 
-            (GC) m_textGC, x, y + XFontStructGetAscent(xfont), text.c_str(), text.Len() );
+        XDrawString( (Display*) m_display, (Window) m_x11window,
+            (GC) m_textGC, x, y + XFontStructGetAscent(xfont), text.c_str(), text.length() );

     }
 
 #if 0
     }
 
 #if 0


@@ -1575,36 +1635,40 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
     {
         wxCoord ul_y = y + XFontStructGetAscent(font);
         if (font->descent > 0) ul_y++;
     {
         wxCoord ul_y = y + XFontStructGetAscent(font);
         if (font->descent > 0) ul_y++;

-        gdk_draw_line( m_window, m_textGC, x, ul_y, x + width, ul_y);
+        gdk_draw_line( m_x11window, m_textGC, x, ul_y, x + width, ul_y);

     }
 
     width = wxCoord(width / m_scaleX);
     height = wxCoord(height / m_scaleY);
     }
 
     width = wxCoord(width / m_scaleX);
     height = wxCoord(height / m_scaleY);

-    
+

     CalcBoundingBox (x + width, y + height);
     CalcBoundingBox (x, y);
 #endif
 #endif
 }
 
     CalcBoundingBox (x + width, y + height);
     CalcBoundingBox (x, y);
 #endif
 #endif
 }
 

-void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y, double angle )
+void wxWindowDCImpl::DoDrawRotatedText(const wxString& WXUNUSED(text),
+                                   wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
+                                   double WXUNUSED(angle))

 {
 {

-    // later
+    wxFAIL_MSG( "not implemented" );

 }
 
 }
 

-void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoord *height,
+void wxWindowDCImpl::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoord *height,

                                 wxCoord *descent, wxCoord *externalLeading,
                                 wxCoord *descent, wxCoord *externalLeading,

-                                wxFont *font ) const
+                                const wxFont *font ) const

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    // Do not test for DC validity here, querying text extents is supposed to
+    // work even with a non-initialized wxMemoryDC. And the code below does
+    // actually work in this case.

 
 

-    if (string.IsEmpty())
+    if (string.empty())

     {
         if (width) (*width) = 0;
         if (height) (*height) = 0;
         return;
     }
     {
         if (width) (*width) = 0;
         if (height) (*height) = 0;
         return;
     }

-    
+

 #if wxUSE_UNICODE
     PangoLayout *layout = pango_layout_new( m_context );
 
 #if wxUSE_UNICODE
     PangoLayout *layout = pango_layout_new( m_context );
 


@@ -1612,15 +1676,15 @@ void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoor
         pango_layout_set_font_description( layout, font->GetNativeFontInfo()->description );
     else
         pango_layout_set_font_description(layout, m_fontdesc);
         pango_layout_set_font_description( layout, font->GetNativeFontInfo()->description );
     else
         pango_layout_set_font_description(layout, m_fontdesc);

-        
-    const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
-    pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
- 
+
+    const wxScopedCharBuffer data(string.utf8_str());
+    pango_layout_set_text(layout, data, data.length());
+

     // Measure text.
     int w,h;
     pango_layout_get_pixel_size(layout, &w, &h);
     // Measure text.
     int w,h;
     pango_layout_get_pixel_size(layout, &w, &h);

-    
-    if (width) (*width) = (wxCoord) w; 
+
+    if (width) (*width) = (wxCoord) w;

     if (height) (*height) = (wxCoord) h;
     if (descent)
     {
     if (height) (*height) = (wxCoord) h;
     if (descent)
     {


@@ -1628,22 +1692,22 @@ void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoor
         (*descent) = 0;
     }
     if (externalLeading) (*externalLeading) = 0;  // ??
         (*descent) = 0;
     }
     if (externalLeading) (*externalLeading) = 0;  // ??

-    
+

     g_object_unref( G_OBJECT( layout ) );
 #else
     wxFont fontToUse = m_font;
     if (font) fontToUse = *font;
 
     g_object_unref( G_OBJECT( layout ) );
 #else
     wxFont fontToUse = m_font;
     if (font) fontToUse = *font;
 

-    wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
+    wxCHECK_RET( fontToUse.IsOk(), wxT("invalid font") );

 
     XFontStruct *xfont = (XFontStruct*) fontToUse.GetFontStruct( m_scaleY, m_display );
 
     wxCHECK_RET( xfont, wxT("invalid font") );
 
     XFontStruct *xfont = (XFontStruct*) fontToUse.GetFontStruct( m_scaleY, m_display );
 
     wxCHECK_RET( xfont, wxT("invalid font") );

-    
+

     int direction, ascent, descent2;
     XCharStruct overall;
 
     int direction, ascent, descent2;
     XCharStruct overall;
 

-    XTextExtents( xfont, (char*) string.c_str(), string.Len(), &direction,
+    XTextExtents( xfont, (const char*) string.c_str(), string.length(), &direction,

         &ascent, &descent2, &overall);
 
     if (width)
         &ascent, &descent2, &overall);
 
     if (width)


@@ -1657,28 +1721,27 @@ void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoor
 #endif
 }
 
 #endif
 }
 

-wxCoord wxWindowDC::GetCharWidth() const
+wxCoord wxWindowDCImpl::GetCharWidth() const

 {
 {

-    wxCHECK_MSG( Ok(), 0, wxT("invalid dc") );
-    
+    // Do not test for DC validity here for the same reasons as in
+    // DoGetTextExtent() above.
+

 #if wxUSE_UNICODE
     PangoLayout *layout = pango_layout_new( m_context );
 #if wxUSE_UNICODE
     PangoLayout *layout = pango_layout_new( m_context );

-    
-    if (!m_fontdesc)
-    {
-        char *crash = NULL;
-        *crash = 0;
-    }
-    
-    pango_layout_set_font_description(layout, m_fontdesc);
+
+    if (m_fontdesc)
+        pango_layout_set_font_description(layout, m_fontdesc);
+    else
+        pango_layout_set_font_description(layout, this->GetFont().GetNativeFontInfo()->description);
+

     pango_layout_set_text(layout, "H", 1 );
     int w,h;
     pango_layout_get_pixel_size(layout, &w, &h);
     g_object_unref( G_OBJECT( layout ) );
     pango_layout_set_text(layout, "H", 1 );
     int w,h;
     pango_layout_get_pixel_size(layout, &w, &h);
     g_object_unref( G_OBJECT( layout ) );

-    
+

     return w;
 #else
     return w;
 #else

-    wxCHECK_MSG( m_font.Ok(), 0, wxT("invalid font") );
+    wxCHECK_MSG( m_font.IsOk(), 0, wxT("invalid font") );

 
     XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
 
 
     XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
 


@@ -1686,36 +1749,34 @@ wxCoord wxWindowDC::GetCharWidth() const
 
     int direction, ascent, descent;
     XCharStruct overall;
 
     int direction, ascent, descent;
     XCharStruct overall;

-    
+

     XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
     XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );

-        
+

     return (wxCoord)(overall.width / m_scaleX);
 #endif
 }
 
     return (wxCoord)(overall.width / m_scaleX);
 #endif
 }
 

-wxCoord wxWindowDC::GetCharHeight() const
+wxCoord wxWindowDCImpl::GetCharHeight() const

 {
 {

-    wxCHECK_MSG( Ok(), 0, wxT("invalid dc") );
-    
+    // Do not test for DC validity here for the same reasons as in
+    // DoGetTextExtent() above.
+

 #if wxUSE_UNICODE
     PangoLayout *layout = pango_layout_new( m_context );
 #if wxUSE_UNICODE
     PangoLayout *layout = pango_layout_new( m_context );

-    
-    if (!m_fontdesc)
-    {
-        char *crash = NULL;
-        *crash = 0;
-    }
-    
-    pango_layout_set_font_description(layout, m_fontdesc);
-    
+
+    if (m_fontdesc)
+        pango_layout_set_font_description(layout, m_fontdesc);
+    else
+        pango_layout_set_font_description(layout, this->GetFont().GetNativeFontInfo()->description);
+

     pango_layout_set_text(layout, "H", 1 );
     int w,h;
     pango_layout_get_pixel_size(layout, &w, &h);
     g_object_unref( G_OBJECT( layout ) );
     pango_layout_set_text(layout, "H", 1 );
     int w,h;
     pango_layout_get_pixel_size(layout, &w, &h);
     g_object_unref( G_OBJECT( layout ) );

-    
+

     return h;
 #else
     return h;
 #else

-    wxCHECK_MSG( m_font.Ok(), 0, wxT("invalid font") );
+    wxCHECK_MSG( m_font.IsOk(), 0, wxT("invalid font") );

 
     XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
 
 
     XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
 


@@ -1723,18 +1784,18 @@ wxCoord wxWindowDC::GetCharHeight() const
 
     int direction, ascent, descent;
     XCharStruct overall;
 
     int direction, ascent, descent;
     XCharStruct overall;

-    
+

     XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
     XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );

-        
+

     return (wxCoord)((ascent+descent) / m_scaleY);
 #endif
 }
 
     return (wxCoord)((ascent+descent) / m_scaleY);
 #endif
 }
 

-void wxWindowDC::Clear()
+void wxWindowDCImpl::Clear()

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
 

-    if (!m_window) return;
+    if (!m_x11window) return;

 
     /* - we either are a memory dc or have a window as the
        owner. anything else shouldn't happen.
 
     /* - we either are a memory dc or have a window as the
        owner. anything else shouldn't happen.


@@ -1743,41 +1804,45 @@ void wxWindowDC::Clear()
        much pain to keep the DC's and the window's back-
        ground colour in synch. */
 
        much pain to keep the DC's and the window's back-
        ground colour in synch. */
 

-    if (m_owner)
+    if (m_window)

     {
         int width,height;
     {
         int width,height;

-        m_owner->GetSize( &width, &height );
-        XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_bgGC, 0, 0, width, height );
+        m_window->GetSize( &width, &height );
+        XFillRectangle( (Display*) m_display, (Window) m_x11window, (GC) m_bgGC, 0, 0, width, height );

         return;
     }
 
     if (m_isMemDC)
     {
         int width,height;
         return;
     }
 
     if (m_isMemDC)
     {
         int width,height;

-        GetSize( &width, &height );
-        XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_bgGC, 0, 0, width, height );
+        DoGetSize( &width, &height );
+        XFillRectangle( (Display*) m_display, (Window) m_x11window, (GC) m_bgGC, 0, 0, width, height );

         return;
     }
 }
 
         return;
     }
 }
 

-void wxWindowDC::SetFont( const wxFont &font )
+void wxWindowDCImpl::SetFont( const wxFont &font )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );

 
     m_font = font;
 
     m_font = font;

+
+#if wxUSE_UNICODE
+    m_fontdesc = font.GetNativeFontInfo()->description;
+#endif

 }
 
 }
 

-void wxWindowDC::SetPen( const wxPen &pen )
+void wxWindowDCImpl::SetPen( const wxPen &pen )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
     if (m_pen == pen) return;
 
     m_pen = pen;
 
 
     if (m_pen == pen) return;
 
     m_pen = pen;
 

-    if (!m_pen.Ok()) return;
+    if (!m_pen.IsOk()) return;

 
 

-    if (!m_window) return;
+    if (!m_x11window) return;

 
     int width = m_pen.GetWidth();
     if (width <= 0)
 
     int width = m_pen.GetWidth();
     if (width <= 0)


@@ -1852,7 +1917,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
         default:
         {
             lineStyle = LineSolid;
         default:
         {
             lineStyle = LineSolid;

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

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


@@ -1894,24 +1959,24 @@ void wxWindowDC::SetPen( const wxPen &pen )
     XSetForeground( (Display*) m_display, (GC) m_penGC, m_pen.GetColour().GetPixel() );
 }
 
     XSetForeground( (Display*) m_display, (GC) m_penGC, m_pen.GetColour().GetPixel() );
 }
 

-void wxWindowDC::SetBrush( const wxBrush &brush )
+void wxWindowDCImpl::SetBrush( const wxBrush &brush )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
     if (m_brush == brush) return;
 
     m_brush = brush;
 
 
     if (m_brush == brush) return;
 
     m_brush = brush;
 

-    if (!m_brush.Ok()) return;
+    if (!m_brush.IsOk()) return;

 
 

-    if (!m_window) return;
+    if (!m_x11window) return;

 
     m_brush.GetColour().CalcPixel( m_cmap );
     XSetForeground( (Display*) m_display, (GC) m_brushGC, m_brush.GetColour().GetPixel() );
 
     m_brush.GetColour().CalcPixel( m_cmap );
     XSetForeground( (Display*) m_display, (GC) m_brushGC, m_brush.GetColour().GetPixel() );

-    
+

     XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillSolid );
 
     XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillSolid );
 

-    if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->Ok()))
+    if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->IsOk()))

     {
         if (m_brush.GetStipple()->GetPixmap())
         {
     {
         if (m_brush.GetStipple()->GetPixmap())
         {


@@ -1931,7 +1996,7 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
         XSetStipple( (Display*) m_display, (GC) m_textGC, (Pixmap) m_brush.GetStipple()->GetMask()->GetBitmap() );
     }
 
         XSetStipple( (Display*) m_display, (GC) m_textGC, (Pixmap) m_brush.GetStipple()->GetMask()->GetBitmap() );
     }
 

-    if (IS_HATCH(m_brush.GetStyle()))
+    if (m_brush.IsHatch())

     {
         XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
         int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
     {
         XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
         int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;


@@ -1939,20 +2004,20 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
     }
 }
 
     }
 }
 

-void wxWindowDC::SetBackground( const wxBrush &brush )
+void wxWindowDCImpl::SetBackground( const wxBrush &brush )

 {
    /* CMB 21/7/98: Added SetBackground. Sets background brush
     * for Clear() and bg colour for shapes filled with cross-hatch brush */
 
 {
    /* CMB 21/7/98: Added SetBackground. Sets background brush
     * for Clear() and bg colour for shapes filled with cross-hatch brush */
 

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
     if (m_backgroundBrush == brush) return;
 
     m_backgroundBrush = brush;
 
 
     if (m_backgroundBrush == brush) return;
 
     m_backgroundBrush = brush;
 

-    if (!m_backgroundBrush.Ok()) return;
+    if (!m_backgroundBrush.IsOk()) return;

 
 

-    if (!m_window) return;
+    if (!m_x11window) return;

 
     m_backgroundBrush.GetColour().CalcPixel( m_cmap );
     XSetBackground( (Display*) m_display, (GC) m_brushGC, m_backgroundBrush.GetColour().GetPixel() );
 
     m_backgroundBrush.GetColour().CalcPixel( m_cmap );
     XSetBackground( (Display*) m_display, (GC) m_brushGC, m_backgroundBrush.GetColour().GetPixel() );


@@ -1962,7 +2027,7 @@ void wxWindowDC::SetBackground( const wxBrush &brush )
 
     XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillSolid );
 
 
     XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillSolid );
 

-    if ((m_backgroundBrush.GetStyle() == wxSTIPPLE) && (m_backgroundBrush.GetStipple()->Ok()))
+    if ((m_backgroundBrush.GetStyle() == wxSTIPPLE) && (m_backgroundBrush.GetStipple()->IsOk()))

     {
         if (m_backgroundBrush.GetStipple()->GetPixmap())
         {
     {
         if (m_backgroundBrush.GetStipple()->GetPixmap())
         {


@@ -1976,7 +2041,7 @@ void wxWindowDC::SetBackground( const wxBrush &brush )
         }
     }
 
         }
     }
 

-    if (IS_HATCH(m_backgroundBrush.GetStyle()))
+    if (m_backgroundBrush.IsHatch())

     {
         XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
         int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
     {
         XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
         int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;


@@ -1984,9 +2049,9 @@ void wxWindowDC::SetBackground( const wxBrush &brush )
     }
 }
 
     }
 }
 

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

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );

 
     int x_function;
 
 
     int x_function;
 


@@ -1994,9 +2059,9 @@ void wxWindowDC::SetLogicalFunction( int function )
         return;
 
     // VZ: shouldn't this be a CHECK?
         return;
 
     // VZ: shouldn't this be a CHECK?

-    if (!m_window)
+    if (!m_x11window)

         return;
         return;

-        
+

     switch (function)
     {
     case wxCLEAR:
     switch (function)
     {
     case wxCLEAR:


@@ -2057,49 +2122,49 @@ void wxWindowDC::SetLogicalFunction( int function )
     // operations (i.e. DrawText/DrawRotatedText).
     // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
     XSetFunction( (Display*) m_display, (GC) m_textGC, x_function );
     // operations (i.e. DrawText/DrawRotatedText).
     // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
     XSetFunction( (Display*) m_display, (GC) m_textGC, x_function );

-    
+

     m_logicalFunction = function;
 }
 
     m_logicalFunction = function;
 }
 

-void wxWindowDC::SetTextForeground( const wxColour &col )
+void wxWindowDCImpl::SetTextForeground( const wxColour &col )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
     // don't set m_textForegroundColour to an invalid colour as we'd crash
     // later then (we use m_textForegroundColour.GetColor() without checking
     // in a few places)
 
     // don't set m_textForegroundColour to an invalid colour as we'd crash
     // later then (we use m_textForegroundColour.GetColor() without checking
     // in a few places)

-    if ( !col.Ok() || (m_textForegroundColour == col) )
+    if ( !col.IsOk() || (m_textForegroundColour == col) )

         return;
 
     m_textForegroundColour = col;
 
         return;
 
     m_textForegroundColour = col;
 

-    if (m_window)
+    if (m_x11window)

     {
         m_textForegroundColour.CalcPixel( m_cmap );
         XSetForeground( (Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel() );
     }
 }
 
     {
         m_textForegroundColour.CalcPixel( m_cmap );
         XSetForeground( (Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel() );
     }
 }
 

-void wxWindowDC::SetTextBackground( const wxColour &col )
+void wxWindowDCImpl::SetTextBackground( const wxColour &col )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
     // same as above
 
     // same as above

-    if ( !col.Ok() || (m_textBackgroundColour == col) )
+    if ( !col.IsOk() || (m_textBackgroundColour == col) )

         return;
 
     m_textBackgroundColour = col;
 
         return;
 
     m_textBackgroundColour = col;
 

-    if (m_window)
+    if (m_x11window)

     {
         m_textBackgroundColour.CalcPixel( m_cmap );
         XSetBackground( (Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel() );
     }
 }
 
     {
         m_textBackgroundColour.CalcPixel( m_cmap );
         XSetBackground( (Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel() );
     }
 }
 

-void wxWindowDC::SetBackgroundMode( int mode )
+void wxWindowDCImpl::SetBackgroundMode( int mode )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
     m_backgroundMode = mode;
 
 
     m_backgroundMode = mode;
 


@@ -2107,7 +2172,7 @@ void wxWindowDC::SetBackgroundMode( int mode )
     GrSetGCUseBackground((GC) m_textGC, mode == wxTRANSPARENT ? FALSE : TRUE);
 #endif
 
     GrSetGCUseBackground((GC) m_textGC, mode == wxTRANSPARENT ? FALSE : TRUE);
 #endif
 

-    if (!m_window) return;
+    if (!m_x11window) return;

 
     // CMB 21/7/98: fill style of cross-hatch brushes is affected by
     // transparent/solid background mode
 
     // CMB 21/7/98: fill style of cross-hatch brushes is affected by
     // transparent/solid background mode


@@ -2119,28 +2184,34 @@ void wxWindowDC::SetBackgroundMode( int mode )
     }
 }
 
     }
 }
 

-void wxWindowDC::SetPalette( const wxPalette& palette )
+void wxWindowDCImpl::SetPalette( const wxPalette& WXUNUSED(palette) )

 {
 #if 0
 {
 #if 0

-    if (m_window)
+    if (m_x11window)

     {
     {

-        if (palette.Ok())
+        if (palette.IsOk())

             /* Use GetXColormap */
             /* Use GetXColormap */

-            XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
+            XSetWindowColormap ((Display*) m_display, (Window) m_x11window->GetXWindow(),

             (Colormap) palette.GetXColormap());
         else
             /* Use wxGetMainColormap */
             (Colormap) palette.GetXColormap());
         else
             /* Use wxGetMainColormap */

-            XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
+            XSetWindowColormap ((Display*) m_display, (Window) m_x11window->GetXWindow(),

             (Colormap) wxTheApp->GetMainColormap(m_display));
     }
 #endif
 }
 
             (Colormap) wxTheApp->GetMainColormap(m_display));
     }
 #endif
 }
 

-void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
+void wxWindowDCImpl::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+
+    if (!m_x11window) return;
+
+    if (width <= 0)
+        width = 1;

 
 

-    if (!m_window) return;
+    if (height <= 0)
+        height = 1;

 
     wxRect rect;
     rect.x = XLOG2DEV(x);
 
     wxRect rect;
     rect.x = XLOG2DEV(x);


@@ -2148,19 +2219,19 @@ void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoo
     rect.width = XLOG2DEVREL(width);
     rect.height = YLOG2DEVREL(height);
 
     rect.width = XLOG2DEVREL(width);
     rect.height = YLOG2DEVREL(height);
 

-    if (!m_currentClippingRegion.IsNull())
+    if (!m_currentClippingRegion.IsEmpty())

         m_currentClippingRegion.Intersect( rect );
     else
         m_currentClippingRegion.Intersect( rect );
     else

-        m_currentClippingRegion.Union( rect );
+        m_currentClippingRegion = rect;

 
 #if USE_PAINT_REGION
 
 #if USE_PAINT_REGION

-    if (!m_paintClippingRegion.IsNull())
+    if (!m_paintClippingRegion.IsEmpty())

         m_currentClippingRegion.Intersect( m_paintClippingRegion );
 #endif
 
     wxCoord xx, yy, ww, hh;
     m_currentClippingRegion.GetBox( xx, yy, ww, hh );
         m_currentClippingRegion.Intersect( m_paintClippingRegion );
 #endif
 
     wxCoord xx, yy, ww, hh;
     m_currentClippingRegion.GetBox( xx, yy, ww, hh );

-    wxDC::DoSetClippingRegion( xx, yy, ww, hh );
+    wxX11DCImpl::DoSetClippingRegion( xx, yy, ww, hh );

 
     XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
     XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
 
     XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
     XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );


@@ -2168,9 +2239,9 @@ void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoo
     XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
 }
 
     XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
 }
 

-void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion& region )
+void wxWindowDCImpl::DoSetDeviceClippingRegion( const wxRegion& region )

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
     if (region.Empty())
     {
 
     if (region.Empty())
     {


@@ -2178,21 +2249,21 @@ void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion& region )
         return;
     }
 
         return;
     }
 

-    if (!m_window) return;
+    if (!m_x11window) return;

 
 

-    if (!m_currentClippingRegion.IsNull())
+    if (!m_currentClippingRegion.IsEmpty())

         m_currentClippingRegion.Intersect( region );
     else
         m_currentClippingRegion.Intersect( region );
     else

-        m_currentClippingRegion.Union( region );
+        m_currentClippingRegion = region;

 
 #if USE_PAINT_REGION
 
 #if USE_PAINT_REGION

-    if (!m_paintClippingRegion.IsNull())
+    if (!m_paintClippingRegion.IsEmpty())

         m_currentClippingRegion.Intersect( m_paintClippingRegion );
 #endif
 
     wxCoord xx, yy, ww, hh;
     m_currentClippingRegion.GetBox( xx, yy, ww, hh );
         m_currentClippingRegion.Intersect( m_paintClippingRegion );
 #endif
 
     wxCoord xx, yy, ww, hh;
     m_currentClippingRegion.GetBox( xx, yy, ww, hh );

-    wxDC::DoSetClippingRegion( xx, yy, ww, hh );
+    wxX11DCImpl::DoSetClippingRegion( xx, yy, ww, hh );

 
     XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
     XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
 
     XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
     XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );


@@ -2200,11 +2271,11 @@ void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion& region )
     XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
 }
 
     XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
 }
 

-void wxWindowDC::DestroyClippingRegion()
+void wxWindowDCImpl::DestroyClippingRegion()

 {
 {

-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );

 
 

-    wxDC::DestroyClippingRegion();
+    wxDCImpl::DestroyClippingRegion();

 
     m_currentClippingRegion.Clear();
 
 
     m_currentClippingRegion.Clear();
 


@@ -2213,7 +2284,7 @@ void wxWindowDC::DestroyClippingRegion()
         m_currentClippingRegion.Union( m_paintClippingRegion );
 #endif
 
         m_currentClippingRegion.Union( m_paintClippingRegion );
 #endif
 

-    if (!m_window) return;
+    if (!m_x11window) return;

 
     if (m_currentClippingRegion.IsEmpty())
     {
 
     if (m_currentClippingRegion.IsEmpty())
     {


@@ -2231,7 +2302,7 @@ void wxWindowDC::DestroyClippingRegion()
     }
 }
 
     }
 }
 

-void wxWindowDC::Destroy()
+void wxWindowDCImpl::Destroy()

 {
     if (m_penGC) wxFreePoolGC( (GC) m_penGC );
     m_penGC = NULL;
 {
     if (m_penGC) wxFreePoolGC( (GC) m_penGC );
     m_penGC = NULL;


@@ -2243,17 +2314,17 @@ void wxWindowDC::Destroy()
     m_bgGC = NULL;
 }
 
     m_bgGC = NULL;
 }
 

-void wxWindowDC::ComputeScaleAndOrigin()
+void wxWindowDCImpl::ComputeScaleAndOrigin()

 {
     /* CMB: copy scale to see if it changes */
     double origScaleX = m_scaleX;
     double origScaleY = m_scaleY;
 
 {
     /* CMB: copy scale to see if it changes */
     double origScaleX = m_scaleX;
     double origScaleY = m_scaleY;
 

-    wxDC::ComputeScaleAndOrigin();
+    wxDCImpl::ComputeScaleAndOrigin();

 
     /* CMB: if scale has changed call SetPen to recalulate the line width */
     if ((m_scaleX != origScaleX || m_scaleY != origScaleY) &&
 
     /* CMB: if scale has changed call SetPen to recalulate the line width */
     if ((m_scaleX != origScaleX || m_scaleY != origScaleY) &&

-        (m_pen.Ok()))
+        (m_pen.IsOk()))

     {
       /* this is a bit artificial, but we need to force wxDC to think
          the pen has changed */
     {
       /* this is a bit artificial, but we need to force wxDC to think
          the pen has changed */


@@ -2263,12 +2334,12 @@ void wxWindowDC::ComputeScaleAndOrigin()
   }
 }
 
   }
 }
 

-wxSize wxWindowDC::GetPPI() const
+wxSize wxWindowDCImpl::GetPPI() const

 {
     return wxSize(100, 100);
 }
 
 {
     return wxSize(100, 100);
 }
 

-int wxWindowDC::GetDepth() const
+int wxWindowDCImpl::GetDepth() const

 {
     wxFAIL_MSG(wxT("not implemented"));
 
 {
     wxFAIL_MSG(wxT("not implemented"));
 


@@ -2279,40 +2350,40 @@ int wxWindowDC::GetDepth() const
 // wxClientDC
 //-----------------------------------------------------------------------------
 
 // wxClientDC
 //-----------------------------------------------------------------------------
 

-IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
+IMPLEMENT_ABSTRACT_CLASS(wxClientDCImpl, wxWindowDCImpl)

 
 

-wxClientDC::wxClientDC( wxWindow *window )
-          : wxWindowDC( window )
+wxClientDCImpl::wxClientDCImpl( wxDC *owner, wxWindow *window )
+          : wxWindowDCImpl( owner, window )

 {
 {

-    wxCHECK_RET( window, _T("NULL window in wxClientDC::wxClientDC") );
-    
-    m_window = (WXWindow*) window->GetClientAreaWindow();
-    
+    wxCHECK_RET( window, wxT("NULL window in wxClientDC::wxClientDC") );
+
+    m_x11window = (WXWindow*) window->GetClientAreaWindow();
+

     // Adjust the client area when the wxWindow is not using 2 X11 windows.
     // Adjust the client area when the wxWindow is not using 2 X11 windows.

-    if (m_window == (WXWindow*) window->GetMainWindow())
+    if (m_x11window == (WXWindow*) window->X11GetMainWindow())

     {
         wxPoint ptOrigin = window->GetClientAreaOrigin();
         SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
         wxSize size = window->GetClientSize();
     {
         wxPoint ptOrigin = window->GetClientAreaOrigin();
         SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
         wxSize size = window->GetClientSize();

-        SetClippingRegion(wxPoint(0, 0), size);
+        DoSetClippingRegion( 0, 0, size.x, size.y );

     }
 }
 
     }
 }
 

-void wxClientDC::DoGetSize(int *width, int *height) const
+void wxClientDCImpl::DoGetSize(int *width, int *height) const

 {
 {

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

 
 

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

 }
 
 // ----------------------------------------------------------------------------
 // wxPaintDC
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // wxPaintDC
 // ----------------------------------------------------------------------------
 

-IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
+IMPLEMENT_ABSTRACT_CLASS(wxPaintDCImpl, wxClientDCImpl)

 
 

-wxPaintDC::wxPaintDC(wxWindow* window)
-  : wxClientDC(window)
+wxPaintDCImpl::wxPaintDCImpl(wxDC *owner, wxWindow* window)
+  : wxClientDCImpl(owner, window)

 {
 #if USE_PAINT_REGION
     if (!window->GetClipPaintRegion())
 {
 #if USE_PAINT_REGION
     if (!window->GetClipPaintRegion())


@@ -2339,8 +2410,15 @@ wxPaintDC::wxPaintDC(wxWindow* window)
 class wxDCModule : public wxModule
 {
 public:
 class wxDCModule : public wxModule
 {
 public:

-    bool OnInit();
-    void OnExit();
+    // we must be cleaned up before wxDisplayModule which closes the global
+    // display
+    wxDCModule()
+    {
+        AddDependency(wxClassInfo::FindClass(wxT("wxX11DisplayModule")));
+    }
+
+    bool OnInit() { wxInitGCPool(); return true; }
+    void OnExit() { wxCleanUpGCPool(); }

 
 private:
     DECLARE_DYNAMIC_CLASS(wxDCModule)
 
 private:
     DECLARE_DYNAMIC_CLASS(wxDCModule)


@@ -2348,13 +2426,3 @@ private:
 
 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
 

-bool wxDCModule::OnInit()
-{
-    wxInitGCPool();
-    return TRUE;
-}
-
-void wxDCModule::OnExit()
-{
-    wxCleanUpGCPool();
-}