missing commit

[wxWidgets.git] / src / motif / dcclient.cpp
diff --git a/src/motif/dcclient.cpp b/src/motif/dcclient.cpp

index 914b32f18b0336e965c2040f6b391c103940a1dd..1c7b8f4c621557e255d7a9e3b5c37e6e8cbf8ed9 100644 (file)
--- a/src/motif/dcclient.cpp
+++ b/src/motif/dcclient.cpp
@@ -1,6 +1,6 @@
  /////////////////////////////////////////////////////////////////////////////
  /////////////////////////////////////////////////////////////////////////////
-// Name:        dcclient.cpp
-// Purpose:     wxClientDC class
+// Name:        src/motif/dcclient.cpp
+// Purpose:     wxClientDCImpl class
  // Author:      Julian Smart
  // Modified by:
  // Created:     01/02/97
  // Author:      Julian Smart
  // Modified by:
  // Created:     01/02/97
@@ -10,7 +10,7 @@
  /////////////////////////////////////////////////////////////////////////////
  
  /*
  /////////////////////////////////////////////////////////////////////////////
  
  /*
-  About pens, brushes, and the autoSetting flag:
+  About pens, brushes, and the m_autoSetting flag:
  
    Under X, pens and brushes control some of the same X drawing
    parameters.  Therefore, it is impossible to independently maintain
  
    Under X, pens and brushes control some of the same X drawing
    parameters.  Therefore, it is impossible to independently maintain
@@ -18,9 +18,9 @@
    the current logical function. The m_currentFill, etc. instance
    variables remember state across the brush and pen.
  
    the current logical function. The m_currentFill, etc. instance
    variables remember state across the brush and pen.
  
-  Since pens are used more than brushes, the autoSetting flag is used to
+  Since pens are used more than brushes, the m_autoSetting flag is used to
    indicate that a brush was recently used, and SetPen must be called to
    indicate that a brush was recently used, and SetPen must be called to
-  reinstall the current pen's parameters. If autoSetting includes 0x2, then the
+  reinstall the current pen's parameters. If m_autoSetting includes 0x2, then the
    pens color may need to be set based on XOR.
  
    There is, unfortunately, some confusion between setting the current pen/brush
    pens color may need to be set based on XOR.
  
    There is, unfortunately, some confusion between setting the current pen/brush
@@ -36,19 +36,19 @@
  // headers
  // ----------------------------------------------------------------------------
  
  // headers
  // ----------------------------------------------------------------------------
  
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "dcclient.h"
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/log.h"
+    #include "wx/app.h"
+    #include "wx/window.h"
+    #include "wx/dcmemory.h"
+    #include "wx/math.h"
+    #include "wx/image.h"
+    #include "wx/dcclient.h"
  #endif
  
  #endif
  
-#include "wx/dcclient.h"
-#include "wx/dcmemory.h"
-#include "wx/window.h"
-#include "wx/app.h"
-#include "wx/image.h"
-#include "wx/log.h"
-
-#include <math.h>
-
  #ifdef __VMS__
  #pragma message disable nosimpint
  #endif
  #ifdef __VMS__
  #pragma message disable nosimpint
  #endif
@@ -58,6 +58,7 @@
  #endif
  
  #include "wx/motif/private.h"
  #endif
  
  #include "wx/motif/private.h"
+#include "wx/motif/dcclient.h"
  
  #ifdef __EMX__
      #include <float.h>          // for M_PI
  
  #ifdef __EMX__
      #include <float.h>          // for M_PI
@@ -83,9 +84,14 @@ static Pixmap bdiag, cdiag, fdiag, cross, horiz, verti;
  // macros
  // ----------------------------------------------------------------------------
  
  // macros
  // ----------------------------------------------------------------------------
  
-    IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
-    IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxWindowDC)
-    IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
+IMPLEMENT_ABSTRACT_CLASS(wxClientDCImpl, wxWindowDCImpl)
+IMPLEMENT_ABSTRACT_CLASS(wxPaintDCImpl, wxWindowDCImpl)
+IMPLEMENT_ABSTRACT_CLASS(wxWindowDCImpl, wxMotifDCImpl)
+
+#define IS_HATCH(s)    ((s)>=wxFIRST_HATCH && (s)<=wxLAST_HATCH)
+
+// FIXME: left over after removal of wxDC::GetOptimization()
+#define GET_OPTIMIZATION false
  
  // ----------------------------------------------------------------------------
  // prototypes
  
  // ----------------------------------------------------------------------------
  // prototypes
@@ -123,10 +129,10 @@ static int roundmin(double a, double b)
  
  
  // ----------------------------------------------------------------------------
  
  
  // ----------------------------------------------------------------------------
-// wxWindowDC
+// wxWindowDCImpl
  // ----------------------------------------------------------------------------
  
  // ----------------------------------------------------------------------------
  
-void wxWindowDC::Init()
+void wxWindowDCImpl::Init()
  {
      m_gc = (WXGC) 0;
      m_gcBacking = (WXGC) 0;
  {
      m_gc = (WXGC) 0;
      m_gcBacking = (WXGC) 0;
@@ -135,32 +141,33 @@ void wxWindowDC::Init()
      m_currentPenWidth = 1;
      m_currentPenJoin = -1;
      m_currentPenDashCount = -1;
      m_currentPenWidth = 1;
      m_currentPenJoin = -1;
      m_currentPenDashCount = -1;
-    m_currentPenDash = (wxX11Dash*) NULL;
+    m_currentPenDash = NULL;
      m_currentStyle = -1;
      m_currentFill = -1;
      m_colour = wxColourDisplay();
      m_currentStyle = -1;
      m_currentFill = -1;
      m_colour = wxColourDisplay();
-    m_display = (WXDisplay*) NULL;
+    m_display = NULL;
      m_pixmap = (WXPixmap) 0;
      m_autoSetting = 0;
      m_pixmap = (WXPixmap) 0;
      m_autoSetting = 0;
-    m_oldFont = (WXFont) 0;
      m_ok = false;
      m_clipRegion = (WXRegion) 0;
  }
  
      m_ok = false;
      m_clipRegion = (WXRegion) 0;
  }
  
-wxWindowDC::wxWindowDC()
+wxWindowDCImpl::wxWindowDCImpl(wxDC *owner)
+              : wxMotifDCImpl(owner)
  {
      Init();
  }
  
  {
      Init();
  }
  
-wxWindowDC::wxWindowDC( wxWindow *window )
+wxWindowDCImpl::wxWindowDCImpl(wxDC *owner, wxWindow *window)
+              : wxMotifDCImpl(owner)
  {
  {
-    wxASSERT_MSG( (window != (wxWindow*) NULL), "You must pass a valid wxWindow to wxWindowDC/wxClientDC/wxPaintDC constructor." );
+    wxASSERT_MSG( (window != NULL), "You must pass a valid wxWindow to wxWindowDCImpl/wxClientDCImpl/wxPaintDCImpl constructor." );
  
      Init();
  
      m_window = window;
      m_font = window->GetFont();
  
      Init();
  
      m_window = window;
      m_font = window->GetFont();
-    m_ok = TRUE;
+    m_ok = true;
  
      m_display = window->GetXDisplay();
      m_pixmap = window->GetXWindow();
  
      m_display = window->GetXDisplay();
      m_pixmap = window->GetXWindow();
@@ -174,8 +181,16 @@ wxWindowDC::wxWindowDC( wxWindow *window )
      gcvalues.graphics_exposures = False;
      gcvalues.subwindow_mode = IncludeInferiors;
      gcvalues.line_width = 1;
      gcvalues.graphics_exposures = False;
      gcvalues.subwindow_mode = IncludeInferiors;
      gcvalues.line_width = 1;
+#if !wxMOTIF_NEW_FONT_HANDLING
+    WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
+    gcvalues.font = ((XFontStruct*)pFontStruct)->fid;
+#endif
      m_gc = (WXGC) XCreateGC (display, RootWindow (display, DefaultScreen (display)),
      m_gc = (WXGC) XCreateGC (display, RootWindow (display, DefaultScreen (display)),
-        GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth | GCSubwindowMode,
+        GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth | GCSubwindowMode
+#if !wxMOTIF_NEW_FONT_HANDLING
+        | GCFont
+#endif
+                             ,
          &gcvalues);
  
      if (m_window->GetBackingPixmap())
          &gcvalues);
  
      if (m_window->GetBackingPixmap())
@@ -186,26 +201,13 @@ wxWindowDC::wxWindowDC( wxWindow *window )
              &gcvalues);
      }
  
              &gcvalues);
      }
  
-    m_backgroundPixel = (int) gcvalues.background;
-
-    // Get the current Font so we can set it back later
-    XGCValues valReturn;
-    XGetGCValues((Display*) m_display, (GC) m_gc, GCFont, &valReturn);
-    m_oldFont = (WXFont) valReturn.font;
+    m_backgroundPixel = gcvalues.background;
  
      SetBackground(wxBrush(m_window->GetBackgroundColour(), wxSOLID));
  }
  
  
      SetBackground(wxBrush(m_window->GetBackgroundColour(), wxSOLID));
  }
  
-wxWindowDC::~wxWindowDC()
+wxWindowDCImpl::~wxWindowDCImpl()
  {
  {
-    if (m_gc && (m_oldFont != (WXFont) 0) && ((long) m_oldFont != -1))
-    {
-        XSetFont ((Display*) m_display, (GC) m_gc, (Font) m_oldFont);
-
-        if (m_window && m_window->GetBackingPixmap())
-            XSetFont ((Display*) m_display,(GC) m_gcBacking, (Font) m_oldFont);
-    }
-
      if (m_gc)
          XFreeGC ((Display*) m_display, (GC) m_gc);
      m_gc = (WXGC) 0;
      if (m_gc)
          XFreeGC ((Display*) m_display, (GC) m_gc);
      m_gc = (WXGC) 0;
@@ -219,32 +221,32 @@ wxWindowDC::~wxWindowDC()
      m_clipRegion = (WXRegion) 0;
  }
  
      m_clipRegion = (WXRegion) 0;
  }
  
-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(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      int x1d, y1d, x2d, y2d;
  
  
      int x1d, y1d, x2d, y2d;
  
@@ -267,9 +269,9 @@ void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
      CalcBoundingBox(x2, y2);
  }
  
      CalcBoundingBox(x2, y2);
  }
  
-void wxWindowDC::DoCrossHair( wxCoord x, wxCoord y )
+void wxWindowDCImpl::DoCrossHair( wxCoord x, wxCoord y )
  {
  {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      if (m_autoSetting)
          SetPen (m_pen);
  
      if (m_autoSetting)
          SetPen (m_pen);
@@ -296,9 +298,9 @@ void wxWindowDC::DoCrossHair( wxCoord x, wxCoord y )
      }
  }
  
      }
  }
  
-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(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      int xx1 = XLOG2DEV (x1);
      int yy1 = YLOG2DEV (y1);
  
      int xx1 = XLOG2DEV (x1);
      int yy1 = YLOG2DEV (y1);
@@ -350,7 +352,7 @@ void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCo
      while (alpha2 > 360 * 64)
          alpha2 -= 360 * 64;
  
      while (alpha2 > 360 * 64)
          alpha2 -= 360 * 64;
  
-    if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)
      {
          SetBrush (m_brush);
          XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) (GC) m_gc,
      {
          SetBrush (m_brush);
          XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) (GC) m_gc,
@@ -362,7 +364,7 @@ void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCo
  
      }
  
  
      }
  
-    if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
      {
          if (m_autoSetting)
              SetPen (m_pen);
      {
          if (m_autoSetting)
              SetPen (m_pen);
@@ -377,9 +379,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(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      int xd, yd, wd, hd;
  
  
      int xd, yd, wd, hd;
  
@@ -397,9 +399,9 @@ void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord
      if (end>start) end-=start;
      else end+=360*64-start;
  
      if (end>start) end-=start;
      else end+=360*64-start;
  
-    if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)
      {
      {
-        m_autoSetting = TRUE;    // must be reset
+        m_autoSetting = true;    // must be reset
  
          SetBrush (m_brush);
          XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, start, end);
  
          SetBrush (m_brush);
          XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, start, end);
@@ -409,7 +411,7 @@ void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord
              XLOG2DEV_2 (x), YLOG2DEV_2 (y),wd,hd,start,end);
      }
  
              XLOG2DEV_2 (x), YLOG2DEV_2 (y),wd,hd,start,end);
      }
  
-    if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
      {
          if (m_autoSetting)
              SetPen (m_pen);
      {
          if (m_autoSetting)
              SetPen (m_pen);
@@ -422,11 +424,11 @@ 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(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
  
-    if (m_pen.Ok() && m_autoSetting)
+    if (m_pen.IsOk() && m_autoSetting)
          SetPen (m_pen);
  
      XDrawPoint ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y));
          SetPen (m_pen);
  
      XDrawPoint ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y));
@@ -436,11 +438,11 @@ void wxWindowDC::DoDrawPoint( wxCoord x, wxCoord y )
      CalcBoundingBox (x, y);
  }
  
      CalcBoundingBox (x, y);
  }
  
-void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset )
+void wxWindowDCImpl::DoDrawLines( int n, const wxPoint points[], wxCoord xoffset, wxCoord yoffset )
  {
  {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
  
-    if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
      {
          if (m_autoSetting)
              SetPen (m_pen);
      {
          if (m_autoSetting)
              SetPen (m_pen);
@@ -450,8 +452,8 @@ void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord
  
          for (i = 0; i < n; i++)
          {
  
          for (i = 0; i < n; i++)
          {
-            xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
-            xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
+            xpoints[i].x = (short)XLOG2DEV (points[i].x + xoffset);
+            xpoints[i].y = (short)YLOG2DEV (points[i].y + yoffset);
          }
          XDrawLines ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints, n, 0);
  
          }
          XDrawLines ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints, n, 0);
  
@@ -459,8 +461,8 @@ void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord
          {
              for (i = 0; i < n; i++)
              {
          {
              for (i = 0; i < n; i++)
              {
-                xpoints[i].x = XLOG2DEV_2 (points[i].x + xoffset);
-                xpoints[i].y = YLOG2DEV_2 (points[i].y + yoffset);
+                xpoints[i].x = (short)XLOG2DEV_2 (points[i].x + xoffset);
+                xpoints[i].y = (short)YLOG2DEV_2 (points[i].y + yoffset);
              }
              XDrawLines ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, xpoints, n, 0);
          }
              }
              XDrawLines ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, xpoints, n, 0);
          }
@@ -468,20 +470,20 @@ void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord
      }
  }
  
      }
  }
  
-void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
-                                wxCoord xoffset, wxCoord yoffset, int fillStyle )
+void wxWindowDCImpl::DoDrawPolygon( int n, const wxPoint points[],
+                                wxCoord xoffset, wxCoord yoffset, wxPolygonFillMode fillStyle )
  {
  {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      XPoint *xpoints1 = new XPoint[n + 1];
      XPoint *xpoints2 = new XPoint[n + 1];
      int i;
      for (i = 0; i < n; i++)
      {
  
      XPoint *xpoints1 = new XPoint[n + 1];
      XPoint *xpoints2 = new XPoint[n + 1];
      int i;
      for (i = 0; i < n; i++)
      {
-        xpoints1[i].x = XLOG2DEV (points[i].x + xoffset);
-        xpoints1[i].y = YLOG2DEV (points[i].y + yoffset);
-        xpoints2[i].x = XLOG2DEV_2 (points[i].x + xoffset);
-        xpoints2[i].y = YLOG2DEV_2 (points[i].y + yoffset);
+        xpoints1[i].x = (short)XLOG2DEV (points[i].x + xoffset);
+        xpoints1[i].y = (short)YLOG2DEV (points[i].y + yoffset);
+        xpoints2[i].x = (short)XLOG2DEV_2 (points[i].x + xoffset);
+        xpoints2[i].y = (short)YLOG2DEV_2 (points[i].y + yoffset);
          CalcBoundingBox (points[i].x + xoffset, points[i].y + yoffset);
      }
  
          CalcBoundingBox (points[i].x + xoffset, points[i].y + yoffset);
      }
  
@@ -491,7 +493,7 @@ void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
      xpoints2[i].x = xpoints2[0].x;
      xpoints2[i].y = xpoints2[0].y;
  
      xpoints2[i].x = xpoints2[0].x;
      xpoints2[i].y = xpoints2[0].y;
  
-    if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)
      {
          SetBrush (m_brush);
          XSetFillRule ((Display*) m_display, (GC) m_gc, fillStyle == wxODDEVEN_RULE ? EvenOddRule : WindingRule);
      {
          SetBrush (m_brush);
          XSetFillRule ((Display*) m_display, (GC) m_gc, fillStyle == wxODDEVEN_RULE ? EvenOddRule : WindingRule);
@@ -506,7 +508,7 @@ void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
          }
      }
  
          }
      }
  
-    if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
      {
          if (m_autoSetting)
              SetPen (m_pen);
      {
          if (m_autoSetting)
              SetPen (m_pen);
@@ -520,9 +522,9 @@ void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
      delete[]xpoints2;
  }
  
      delete[]xpoints2;
  }
  
-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(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      int xd, yd, wfd, hfd, wd, hd;
  
  
      int xd, yd, wfd, hfd, wd, hd;
  
@@ -537,7 +539,7 @@ void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord h
      if (wd < 0) { wd = - wd; xd = xd - wd; }
      if (hd < 0) { hd = - hd; yd = yd - hd; }
  
      if (wd < 0) { wd = - wd; xd = xd - wd; }
      if (hd < 0) { hd = - hd; yd = yd - hd; }
  
-    if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)
      {
          SetBrush (m_brush);
          XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wfd, hfd);
      {
          SetBrush (m_brush);
          XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wfd, hfd);
@@ -548,7 +550,7 @@ void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord h
              wfd, hfd);
      }
  
              wfd, hfd);
      }
  
-    if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
      {
          if (m_autoSetting)
              SetPen (m_pen);
      {
          if (m_autoSetting)
              SetPen (m_pen);
@@ -563,9 +565,9 @@ 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(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      // If radius is negative, it's a proportion of the smaller dimension.
  
  
      // If radius is negative, it's a proportion of the smaller dimension.
  
@@ -584,7 +586,7 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
      // X drawing errors with small radii
      if (rd == 0)
      {
      // X drawing errors with small radii
      if (rd == 0)
      {
-        DrawRectangle( x, y, width, height );
+        DoDrawRectangle( x, y, width, height );
          return;
      }
  
          return;
      }
  
@@ -615,7 +617,7 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
      int rw_d2 = rd2 * 2;
      int rh_d2 = rw_d2;
  
      int rw_d2 = rd2 * 2;
      int rh_d2 = rw_d2;
  
-    if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)
      {
          SetBrush (m_brush);
  
      {
          SetBrush (m_brush);
  
@@ -665,7 +667,7 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
          }
      }
  
          }
      }
  
-    if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
      {
          SetPen (m_pen);
          XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd,
      {
          SetPen (m_pen);
          XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd,
@@ -723,9 +725,9 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
      CalcBoundingBox (x + width, y + height);
  }
  
      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(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      // Check for negative width and height
      if (height < 0)
  
      // Check for negative width and height
      if (height < 0)
@@ -749,7 +751,7 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
      wd = XLOG2DEVREL(width) ;
      hd = YLOG2DEVREL(height) ;
  
      wd = XLOG2DEVREL(width) ;
      hd = YLOG2DEVREL(height) ;
  
-    if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)
      {
          SetBrush (m_brush);
          XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, 0, angle);
      {
          SetBrush (m_brush);
          XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, 0, angle);
@@ -760,7 +762,7 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
              YLOG2DEVREL (height) - WX_GC_CF, 0, angle);
      }
  
              YLOG2DEVREL (height) - WX_GC_CF, 0, angle);
      }
  
-    if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
      {
          if (m_autoSetting)
              SetPen (m_pen);
      {
          if (m_autoSetting)
              SetPen (m_pen);
@@ -776,64 +778,69 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
  
  }
  
  
  }
  
-bool wxWindowDC::CanDrawBitmap() const
+bool wxWindowDCImpl::CanDrawBitmap() const
  {
  {
-    wxCHECK_MSG( Ok(), FALSE, "invalid dc" );
+    wxCHECK_MSG( IsOk(), false, "invalid dc" );
  
  
-    return TRUE;
+    return true;
  }
  
  }
  
-// TODO: use scaled Blit e.g. as per John Price's implementation 
+// TODO: use scaled Blit e.g. as per John Price's implementation
  // in Contrib/Utilities
  // in Contrib/Utilities
-bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
+bool wxWindowDCImpl::DoBlit( wxCoord xdest, wxCoord ydest,
                           wxCoord width, wxCoord height,
                           wxDC *source, wxCoord xsrc, wxCoord ysrc,
                           wxCoord width, wxCoord height,
                           wxDC *source, wxCoord xsrc, wxCoord ysrc,
-                         int rop, bool useMask,
+                         wxRasterOperationMode rop, bool useMask,
                           wxCoord xsrcMask, wxCoord ysrcMask )
  {
                           wxCoord xsrcMask, wxCoord ysrcMask )
  {
-    wxCHECK_MSG( Ok(), FALSE, "invalid dc" );
+    wxCHECK_MSG( IsOk(), false, "invalid dc" );
  
  
-    wxWindowDC* sourceDC = wxDynamicCast(source, wxWindowDC);
+    wxWindowDC const * sourceDC = wxDynamicCast(source, wxWindowDC);
+    wxCHECK_MSG( sourceDC, false, "Blit source DC must be wxWindowDCImpl or derived class." );
+
+    // cast is safe in virtue of the above wxCHECK_MSG()
+    const wxWindowDCImpl * const
+        srcImpl = static_cast<const wxWindowDCImpl *>(sourceDC->GetImpl());
+    WXDisplay * const srcDpy = srcImpl->m_display;
  
  
-    wxASSERT_MSG( sourceDC, "Blit source DC must be wxWindowDC or derived class." );
  
      // Be sure that foreground pixels (1) of the Icon will be painted with
      // foreground colour. [m_textForegroundColour] Background pixels (0)
      // will be painted with backgound colour (m_textBackgroundColour)
      // Using ::SetPen is horribly slow, so avoid doing it
  
      // Be sure that foreground pixels (1) of the Icon will be painted with
      // foreground colour. [m_textForegroundColour] Background pixels (0)
      // will be painted with backgound colour (m_textBackgroundColour)
      // Using ::SetPen is horribly slow, so avoid doing it
-    int oldBackgroundPixel = -1;
-    int oldForegroundPixel = -1;
+    WXPixel oldBackgroundPixel = -1;
+    WXPixel oldForegroundPixel = -1;
  
  
-    if (m_textBackgroundColour.Ok())
+    if (m_textBackgroundColour.IsOk())
      {
          oldBackgroundPixel = m_backgroundPixel;
      {
          oldBackgroundPixel = m_backgroundPixel;
-        int pixel = m_textBackgroundColour.AllocColour(m_display);
+        WXPixel pixel = m_textBackgroundColour.AllocColour(m_display);
  
          XSetBackground ((Display*) m_display, (GC) m_gc, pixel);
          if (m_window && m_window->GetBackingPixmap())
              XSetBackground ((Display*) m_display,(GC) m_gcBacking,
                              pixel);
      }
  
          XSetBackground ((Display*) m_display, (GC) m_gc, pixel);
          if (m_window && m_window->GetBackingPixmap())
              XSetBackground ((Display*) m_display,(GC) m_gcBacking,
                              pixel);
      }
-    if (m_textForegroundColour.Ok())
+    if (m_textForegroundColour.IsOk())
      {
          oldForegroundPixel = m_currentColour.GetPixel();
  
          if( m_textForegroundColour.GetPixel() <= -1 )
              CalculatePixel( m_textForegroundColour,
      {
          oldForegroundPixel = m_currentColour.GetPixel();
  
          if( m_textForegroundColour.GetPixel() <= -1 )
              CalculatePixel( m_textForegroundColour,
-                            m_textForegroundColour, TRUE);
- 
-        int pixel = m_textForegroundColour.GetPixel();
+                            m_textForegroundColour, true);
+
+        WXPixel pixel = m_textForegroundColour.GetPixel();
          if (pixel > -1)
              SetForegroundPixelWithLogicalFunction(pixel);
      }
  
      // Do bitmap scaling if necessary
  
          if (pixel > -1)
              SetForegroundPixelWithLogicalFunction(pixel);
      }
  
      // Do bitmap scaling if necessary
  
-    wxBitmap *scaledBitmap = (wxBitmap*) NULL;
+    wxBitmap *scaledBitmap = NULL;
      Pixmap sourcePixmap = (Pixmap) NULL;
      double scaleX, scaleY;
      GetUserScale(& scaleX, & scaleY);
      Pixmap sourcePixmap = (Pixmap) NULL;
      double scaleX, scaleY;
      GetUserScale(& scaleX, & scaleY);
-    bool retVal = FALSE;
+    bool retVal = false;
  
      /* TODO: use the mask origin when drawing transparently */
      if (xsrcMask == -1 && ysrcMask == -1)
  
      /* TODO: use the mask origin when drawing transparently */
      if (xsrcMask == -1 && ysrcMask == -1)
@@ -845,12 +852,12 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
      if (!useMask && (scaleX != 1.0 || scaleY != 1.0) && sourceDC->IsKindOf(CLASSINFO(wxMemoryDC)))
      {
          wxMemoryDC* memDC = (wxMemoryDC*) sourceDC;
      if (!useMask && (scaleX != 1.0 || scaleY != 1.0) && sourceDC->IsKindOf(CLASSINFO(wxMemoryDC)))
      {
          wxMemoryDC* memDC = (wxMemoryDC*) sourceDC;
-        wxBitmap& bitmap = memDC->GetBitmap();
+        wxBitmap& bitmap = memDC->GetSelectedBitmap();
  
  
-        wxASSERT_MSG( (bitmap.Ok()), "Bad source bitmap in wxWindowDC::Blit");
+        wxASSERT_MSG( (bitmap.IsOk()), "Bad source bitmap in wxWindowDCImpl::Blit");
  
          wxImage image = bitmap.ConvertToImage();
  
          wxImage image = bitmap.ConvertToImage();
-        if (!image.Ok())
+        if (!image.IsOk())
          {
              sourcePixmap = (Pixmap) bitmap.GetDrawable();
          }
          {
              sourcePixmap = (Pixmap) bitmap.GetDrawable();
          }
@@ -865,21 +872,23 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
          }
      }
      else
          }
      }
      else
-        sourcePixmap = (Pixmap) sourceDC->m_pixmap;
+    {
+        sourcePixmap = (Pixmap) srcImpl->m_pixmap;
+    }
  
      if (m_pixmap && sourcePixmap)
      {
          /* MATTHEW: [9] */
  
      if (m_pixmap && sourcePixmap)
      {
          /* MATTHEW: [9] */
-        int orig = m_logicalFunction;
+        wxRasterOperationMode orig = m_logicalFunction;
  
          SetLogicalFunction (rop);
  
  
          SetLogicalFunction (rop);
  
-        if (m_display != sourceDC->m_display)
+        if (m_display != srcDpy)
          {
              XImage *cache = NULL;
  
              if (m_window && m_window->GetBackingPixmap())
          {
              XImage *cache = NULL;
  
              if (m_window && m_window->GetBackingPixmap())
-                XCopyRemote((Display*) sourceDC->m_display, (Display*) m_display,
+                XCopyRemote((Display*) srcDpy, (Display*) m_display,
                  (Pixmap) sourcePixmap, (Pixmap) m_window->GetBackingPixmap(),
                  (GC) m_gcBacking,
                  source->LogicalToDeviceX (xsrc),
                  (Pixmap) sourcePixmap, (Pixmap) m_window->GetBackingPixmap(),
                  (GC) m_gcBacking,
                  source->LogicalToDeviceX (xsrc),
@@ -887,26 +896,26 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
                  source->LogicalToDeviceXRel(width),
                  source->LogicalToDeviceYRel(height),
                  XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest),
                  source->LogicalToDeviceXRel(width),
                  source->LogicalToDeviceYRel(height),
                  XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest),
-                TRUE, &cache);
+                True, &cache);
  
              if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
              {
                  wxMemoryDC *memDC = (wxMemoryDC *)source;
  
              if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
              {
                  wxMemoryDC *memDC = (wxMemoryDC *)source;
-                wxBitmap& sel = memDC->GetBitmap();
-                if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetBitmap() )
+                wxBitmap& sel = memDC->GetSelectedBitmap();
+                if ( sel.IsOk() && sel.GetMask() && sel.GetMask()->GetBitmap() )
                  {
                      XSetClipMask   ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetBitmap());
                      XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
                  }
              }
  
                  {
                      XSetClipMask   ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetBitmap());
                      XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
                  }
              }
  
-            XCopyRemote((Display*) sourceDC->m_display, (Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_pixmap, (GC) m_gc,
+            XCopyRemote((Display*) srcDpy, (Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_pixmap, (GC) m_gc,
                  source->LogicalToDeviceX (xsrc),
                  source->LogicalToDeviceY (ysrc),
                  source->LogicalToDeviceXRel(width),
                  source->LogicalToDeviceYRel(height),
                  XLOG2DEV (xdest), YLOG2DEV (ydest),
                  source->LogicalToDeviceX (xsrc),
                  source->LogicalToDeviceY (ysrc),
                  source->LogicalToDeviceXRel(width),
                  source->LogicalToDeviceYRel(height),
                  XLOG2DEV (xdest), YLOG2DEV (ydest),
-                FALSE, &cache);
+                False, &cache);
  
              if ( useMask )
              {
  
              if ( useMask )
              {
@@ -921,12 +930,12 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
  
          } else
          {        //XGCValues values;
  
          } else
          {        //XGCValues values;
-        //XGetGCValues((Display*)m_display, (GC)m_gc, GCForeground, &values);   
+        //XGetGCValues((Display*)m_display, (GC)m_gc, GCForeground, &values);
  
              if (m_window && m_window->GetBackingPixmap())
              {
                  // +++ MARKUS (mho@comnets.rwth-aachen): error on blitting bitmaps with depth 1
  
              if (m_window && m_window->GetBackingPixmap())
              {
                  // +++ MARKUS (mho@comnets.rwth-aachen): error on blitting bitmaps with depth 1
-                if (source->IsKindOf(CLASSINFO(wxMemoryDC)) && ((wxMemoryDC*) source)->GetBitmap().GetDepth() == 1)
+                if (source->IsKindOf(CLASSINFO(wxMemoryDC)) && ((wxMemoryDC*) source)->GetSelectedBitmap().GetDepth() == 1)
                  {
                      XCopyPlane ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
                          source->LogicalToDeviceX (xsrc),
                  {
                      XCopyPlane ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
                          source->LogicalToDeviceX (xsrc),
@@ -948,8 +957,8 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
              if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
              {
                  wxMemoryDC *memDC = (wxMemoryDC *)source;
              if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
              {
                  wxMemoryDC *memDC = (wxMemoryDC *)source;
-                wxBitmap& sel = memDC->GetBitmap();
-                if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetBitmap() )
+                wxBitmap& sel = memDC->GetSelectedBitmap();
+                if ( sel.IsOk() && sel.GetMask() && sel.GetMask()->GetBitmap() )
                  {
                      XSetClipMask   ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetBitmap());
                      XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
                  {
                      XSetClipMask   ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetBitmap());
                      XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
@@ -958,7 +967,8 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
  
              // Check if we're copying from a mono bitmap
              if (source->IsKindOf(CLASSINFO(wxMemoryDC)) &&
  
              // Check if we're copying from a mono bitmap
              if (source->IsKindOf(CLASSINFO(wxMemoryDC)) &&
-                ((wxMemoryDC*)source)->GetBitmap().Ok() && (((wxMemoryDC*)source)->GetBitmap().GetDepth () == 1))
+                ((wxMemoryDC*)source)->GetSelectedBitmap().IsOk() &&
+                (((wxMemoryDC*)source)->GetSelectedBitmap().GetDepth () == 1))
              {
                  XCopyPlane ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_pixmap, (GC) m_gc,
                      source->LogicalToDeviceX (xsrc),
              {
                  XCopyPlane ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_pixmap, (GC) m_gc,
                      source->LogicalToDeviceX (xsrc),
@@ -994,7 +1004,7 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
  
          SetLogicalFunction(orig);
  
  
          SetLogicalFunction(orig);
  
-        retVal = TRUE;
+        retVal = true;
    }
    if (scaledBitmap) delete scaledBitmap;
  
    }
    if (scaledBitmap) delete scaledBitmap;
  
@@ -1016,15 +1026,15 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
    return retVal;
  }
  
    return retVal;
  }
  
-void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
+void wxWindowDCImpl::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
  {
  {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      // Since X draws from the baseline of the text, must add the text height
      int cx = 0;
      int cy = 0;
      int ascent = 0;
  
      // Since X draws from the baseline of the text, must add the text height
      int cx = 0;
      int cy = 0;
      int ascent = 0;
-    int slen;
+    int slen = text.length();
  
      // Set FillStyle, otherwise X will use current stipple!
      XGCValues gcV, gcBackingV;
  
      // Set FillStyle, otherwise X will use current stipple!
      XGCValues gcV, gcBackingV;
@@ -1038,35 +1048,17 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
          XSetFillStyle ((Display*) m_display, (GC) m_gcBacking, FillSolid);
      }
  
          XSetFillStyle ((Display*) m_display, (GC) m_gcBacking, FillSolid);
      }
  
-    slen = strlen(text);
-
-    if (m_font.Ok())
-    {
-        WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
-        int direction, descent;
-        XCharStruct overall_return;
-#if 0
-        if (use16)
-            (void)XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *)(const char*) text, slen, &direction,
-            &ascent, &descent, &overall_return);
-        else
-#endif // 0
-            (void)XTextExtents((XFontStruct*) pFontStruct,
-                               wxConstCast(text.c_str(), char),
-                               slen, &direction,
-                               &ascent, &descent, &overall_return);
-
-        cx = overall_return.width;
-        cy = ascent + descent;
-    }
+    if (m_font.IsOk())
+        wxGetTextExtent (m_display, m_font, m_userScaleY * m_logicalScaleY,
+                         text, &cx, &cy, &ascent, NULL);
  
      // 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))
      {
          wxColour oldPenColour = m_currentColour;
          m_currentColour = m_textBackgroundColour;
      {
          wxColour oldPenColour = m_currentColour;
          m_currentColour = m_textBackgroundColour;
-        bool sameColour = (oldPenColour.Ok () && m_textBackgroundColour.Ok () &&
+        bool sameColour = (oldPenColour.IsOk () && m_textBackgroundColour.IsOk () &&
              (oldPenColour.Red () == m_textBackgroundColour.Red ()) &&
              (oldPenColour.Blue () == m_textBackgroundColour.Blue ()) &&
              (oldPenColour.Green () == m_textBackgroundColour.Green ()));
              (oldPenColour.Red () == m_textBackgroundColour.Red ()) &&
              (oldPenColour.Blue () == m_textBackgroundColour.Blue ()) &&
              (oldPenColour.Green () == m_textBackgroundColour.Green ()));
@@ -1076,9 +1068,9 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
          sameColour = (sameColour &&
              (oldPenColour.GetPixel() == m_textBackgroundColour.GetPixel()));
  
          sameColour = (sameColour &&
              (oldPenColour.GetPixel() == m_textBackgroundColour.GetPixel()));
  
-        if (!sameColour || !GetOptimization())
+        if (!sameColour || !GET_OPTIMIZATION)
          {
          {
-            int pixel = m_textBackgroundColour.AllocColour(m_display);
+            WXPixel pixel = m_textBackgroundColour.AllocColour(m_display);
              m_currentColour = m_textBackgroundColour;
  
              // Set the GC to the required colour
              m_currentColour = m_textBackgroundColour;
  
              // Set the GC to the required colour
@@ -1099,20 +1091,20 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
      }
  
      // Now set the text foreground and draw the text
      }
  
      // Now set the text foreground and draw the text
-    if (m_textForegroundColour.Ok ())
+    if (m_textForegroundColour.IsOk ())
      {
          wxColour oldPenColour = m_currentColour;
          m_currentColour = m_textForegroundColour;
      {
          wxColour oldPenColour = m_currentColour;
          m_currentColour = m_textForegroundColour;
-        bool sameColour = (oldPenColour.Ok () && m_currentColour.Ok () &&
+        bool sameColour = (oldPenColour.IsOk () && m_currentColour.IsOk () &&
              (oldPenColour.Red () == m_currentColour.Red ()) &&
              (oldPenColour.Blue () == m_currentColour.Blue ()) &&
              (oldPenColour.Green () == m_currentColour.Green ()) &&
              (oldPenColour.GetPixel() == m_currentColour.GetPixel()));
  
              (oldPenColour.Red () == m_currentColour.Red ()) &&
              (oldPenColour.Blue () == m_currentColour.Blue ()) &&
              (oldPenColour.Green () == m_currentColour.Green ()) &&
              (oldPenColour.GetPixel() == m_currentColour.GetPixel()));
  
-        if (!sameColour || !GetOptimization())
+        if (!sameColour || !GET_OPTIMIZATION)
          {
          {
-            int pixel = CalculatePixel(m_textForegroundColour,
-                                       m_currentColour, FALSE);
+            WXPixel pixel = CalculatePixel(m_textForegroundColour,
+                                           m_currentColour, false);
  
              // Set the GC to the required colour
              if (pixel > -1)
  
              // Set the GC to the required colour
              if (pixel > -1)
@@ -1134,7 +1126,12 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
          (XChar2b *)(char*) (const char*) text, slen);
      else
  #endif // 0
          (XChar2b *)(char*) (const char*) text, slen);
      else
  #endif // 0
+#if wxMOTIF_NEW_FONT_HANDLING
+        XFontSet fset = (XFontSet) m_font.GetFontSet (m_userScaleY * m_logicalScaleY, m_display);
+        XmbDrawString((Display*) m_display, (Pixmap) m_pixmap, fset, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y) + ascent, text, slen);
+#else
          XDrawString((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y) + ascent, text, slen);
          XDrawString((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y) + ascent, text, slen);
+#endif
  
      if (m_window && m_window->GetBackingPixmap()) {
  #if 0
  
      if (m_window && m_window->GetBackingPixmap()) {
  #if 0
@@ -1144,9 +1141,15 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
              (XChar2b *)(char*) (const char*) text, slen);
          else
  #endif // 0
              (XChar2b *)(char*) (const char*) text, slen);
          else
  #endif // 0
+#if wxMOTIF_NEW_FONT_HANDLING
+            XmbDrawString((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), fset, (GC) m_gcBacking,
+            XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent,
+                        text.mb_str(), slen);
+#else
              XDrawString((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
              XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent,
              XDrawString((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
              XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent,
-                        wxConstCast(text.c_str(), char), slen);
+                        text.mb_str(), slen);
+#endif
      }
  
      // restore fill style
      }
  
      // restore fill style
@@ -1156,40 +1159,40 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
                         gcBackingV.fill_style);
  
      wxCoord w, h;
                         gcBackingV.fill_style);
  
      wxCoord w, h;
-    GetTextExtent (text, &w, &h);
+    DoGetTextExtent (text, &w, &h);
      CalcBoundingBox (x + w, y + h);
      CalcBoundingBox (x, y);
  }
  
      CalcBoundingBox (x + w, y + h);
      CalcBoundingBox (x, y);
  }
  
-void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y,
+void wxWindowDCImpl::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y,
                                      double angle )
  {
      if (angle == 0.0)
      {
                                      double angle )
  {
      if (angle == 0.0)
      {
-        DrawText(text, x, y);
+        DoDrawText(text, x, y);
          return;
      }
  
          return;
      }
  
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
  
-    int oldBackgroundPixel = -1;
-    int oldForegroundPixel = -1;
-    int foregroundPixel = -1;
-    int backgroundPixel = -1;
+    WXPixel oldBackgroundPixel = -1;
+    WXPixel oldForegroundPixel = -1;
+    WXPixel foregroundPixel = -1;
+    WXPixel backgroundPixel = -1;
  
  
-    if (m_textBackgroundColour.Ok())
+    if (m_textBackgroundColour.IsOk())
      {
          oldBackgroundPixel = m_backgroundPixel;
          backgroundPixel = m_textBackgroundColour.AllocColour(m_display);
      }
      {
          oldBackgroundPixel = m_backgroundPixel;
          backgroundPixel = m_textBackgroundColour.AllocColour(m_display);
      }
-    if (m_textForegroundColour.Ok())
+    if (m_textForegroundColour.IsOk())
      {
          oldForegroundPixel = m_currentColour.GetPixel();
  
          if( m_textForegroundColour.GetPixel() <= -1 )
              CalculatePixel( m_textForegroundColour,
      {
          oldForegroundPixel = m_currentColour.GetPixel();
  
          if( m_textForegroundColour.GetPixel() <= -1 )
              CalculatePixel( m_textForegroundColour,
-                            m_textForegroundColour, TRUE);
- 
+                            m_textForegroundColour, true);
+
          foregroundPixel = m_textForegroundColour.GetPixel();
      }
  
          foregroundPixel = m_textForegroundColour.GetPixel();
      }
  
@@ -1197,31 +1200,10 @@ void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y,
      int cx = 0;
      int cy = 0;
      int ascent = 0;
      int cx = 0;
      int cy = 0;
      int ascent = 0;
-    int slen = text.length();
-
-    if (m_font.Ok())
-    {
-        // Calculate text extent.
-        WXFontStructPtr pFontStruct =
-            m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
-        int direction, descent;
-        XCharStruct overall_return;
-#if 0
-        if (use16)
-            (void)XTextExtents16((XFontStruct*) pFontStruct,
-                                 (XChar2b *)(const char*) text,
-                                 slen, &direction,
-            &ascent, &descent, &overall_return);
-        else
-#endif // 0
-            (void)XTextExtents((XFontStruct*) pFontStruct,
-                               wxConstCast(text.c_str(), char),
-                               slen, &direction,
-                               &ascent, &descent, &overall_return);
  
  
-        cx = overall_return.width;
-        cy = ascent + descent;
-    }
+    if (m_font.IsOk())
+        wxGetTextExtent (m_display, m_font, m_userScaleY * m_logicalScaleY,
+                         text, &cx, &cy, &ascent, NULL);
  
      wxBitmap src(cx, cy);
      wxMemoryDC dc;
  
      wxBitmap src(cx, cy);
      wxMemoryDC dc;
@@ -1318,22 +1300,20 @@ void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y,
      CalcBoundingBox (maxx, maxy);
  }
  
      CalcBoundingBox (maxx, maxy);
  }
  
-bool wxWindowDC::CanGetTextExtent() const
+bool wxWindowDCImpl::CanGetTextExtent() const
  {
  {
-    return TRUE;
+    return true;
  }
  
  }
  
-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(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
  
-    wxFont* theFont = font;
-    if (!theFont)
-        theFont = (wxFont *)&m_font; // const_cast
+    const wxFont* theFont = font ? font : &m_font;
  
  
-    if (!theFont->Ok())
+    if (!theFont->IsOk())
      {
          // TODO: this should be an error log function
          wxFAIL_MSG("set a valid font before calling GetTextExtent!");
      {
          // TODO: this should be an error log function
          wxFAIL_MSG("set a valid font before calling GetTextExtent!");
@@ -1343,67 +1323,42 @@ void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoor
          return;
      }
  
          return;
      }
  
-    WXFontStructPtr pFontStruct = theFont->GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
-
-    int direction, ascent, descent2;
-    XCharStruct overall;
-    int slen;
-
-#if 0
-    if (use16)
-        slen = str16len(string);
-    else
-#endif // 0
-        slen = strlen(string);
+    wxGetTextExtent(m_display, *theFont, m_userScaleY * m_logicalScaleY,
+                    string, width, height, NULL, descent);
  
  
-#if 0
-    if (use16)
-        XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *) (char*) (const char*) string, slen, &direction,
-        &ascent, &descent2, &overall);
-    else
-#endif // 0
-        XTextExtents((XFontStruct*) pFontStruct,
-                     wxConstCast(string.c_str(), char), slen, &direction,
-        &ascent, &descent2, &overall);
-
-    if (width) *width = XDEV2LOGREL (overall.width);
-    if (height) *height = YDEV2LOGREL (ascent + descent2);
-    if (descent)
-        *descent = descent2;
+    if (width) *width = XDEV2LOGREL (*width);
+    if (height) *height = YDEV2LOGREL (*height);
      if (externalLeading)
          *externalLeading = 0;
  }
  
      if (externalLeading)
          *externalLeading = 0;
  }
  
-wxCoord wxWindowDC::GetCharWidth() const
+wxCoord wxWindowDCImpl::GetCharWidth() const
  {
  {
-    wxCHECK_MSG( Ok(), 0, "invalid dc" );
-    wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
+    wxCHECK_MSG( IsOk(), 0, "invalid dc" );
+    wxCHECK_MSG( m_font.IsOk(), 0, "invalid font" );
+
+    int width;
  
  
-    WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY * m_logicalScaleY, m_display);
+    wxGetTextExtent (m_display, m_font, m_userScaleY * m_logicalScaleY,
+                     "x", &width, NULL, NULL, NULL);
  
  
-    int direction, ascent, descent;
-    XCharStruct overall;
-    XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
-        &descent, &overall);
-    return XDEV2LOGREL(overall.width);
+    return XDEV2LOGREL(width);
  }
  
  }
  
-wxCoord wxWindowDC::GetCharHeight() const
+wxCoord wxWindowDCImpl::GetCharHeight() const
  {
  {
-    wxCHECK_MSG( Ok(), 0, "invalid dc" );
-    wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
+    wxCHECK_MSG( IsOk(), 0, "invalid dc" );
+    wxCHECK_MSG( m_font.IsOk(), 0, "invalid font" );
  
  
-    WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
+    int height;
+
+    wxGetTextExtent (m_display, m_font, m_userScaleY * m_logicalScaleY,
+                     "x", NULL, &height, NULL, NULL);
  
  
-    int direction, ascent, descent;
-    XCharStruct overall;
-    XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
-        &descent, &overall);
-    //  return XDEV2LOGREL(overall.ascent + overall.descent);
-    return XDEV2LOGREL(ascent + descent);
+    return XDEV2LOGREL(height);
  }
  
  }
  
-void wxWindowDC::DoGetSize( int *width, int *height ) const
+void wxWindowDCImpl::DoGetSize( int *width, int *height ) const
  {
      int w = 0, h = 0;
  
  {
      int w = 0, h = 0;
  
@@ -1422,17 +1377,17 @@ void wxWindowDC::DoGetSize( int *width, int *height ) const
      if( height ) *height = h;
  }
  
      if( height ) *height = h;
  }
  
-void wxWindowDC::Clear()
+void wxWindowDCImpl::Clear()
  {
  {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
  
-    wxRect rect( wxPoint( 0, 0 ), GetSize() );
+    wxRect rect( GetSize() );
      Clear( rect );
  }
  
      Clear( rect );
  }
  
-void wxWindowDC::Clear(const wxRect& rect)
+void wxWindowDCImpl::Clear(const wxRect& rect)
  {
  {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      int x = rect.x; int y = rect.y;
      int w = rect.width; int h = rect.height;
  
      int x = rect.x; int y = rect.y;
      int w = rect.width; int h = rect.height;
@@ -1451,24 +1406,18 @@ void wxWindowDC::Clear(const wxRect& rect)
      m_brush = saveBrush;
  }
  
      m_brush = saveBrush;
  }
  
-void wxWindowDC::SetFont( const wxFont &font )
+void wxWindowDCImpl::SetFont( const wxFont &font )
  {
  {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      m_font = font;
  
  
      m_font = font;
  
-    if (!m_font.Ok())
+    if (!m_font.IsOk())
      {
      {
-        if ((m_oldFont != (WXFont) 0) && ((wxCoord) m_oldFont != -1))
-        {
-            XSetFont ((Display*) m_display, (GC) m_gc, (Font) m_oldFont);
-
-            if (m_window && m_window->GetBackingPixmap())
-                XSetFont ((Display*) m_display,(GC) m_gcBacking, (Font) m_oldFont);
-        }
          return;
      }
  
          return;
      }
  
+#if !wxMOTIF_NEW_FONT_HANDLING
      WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
  
      Font fontId = ((XFontStruct*)pFontStruct)->fid;
      WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
  
      Font fontId = ((XFontStruct*)pFontStruct)->fid;
@@ -1476,9 +1425,10 @@ void wxWindowDC::SetFont( const wxFont &font )
  
      if (m_window && m_window->GetBackingPixmap())
          XSetFont ((Display*) m_display,(GC) m_gcBacking, fontId);
  
      if (m_window && m_window->GetBackingPixmap())
          XSetFont ((Display*) m_display,(GC) m_gcBacking, fontId);
+#endif
  }
  
  }
  
-void wxWindowDC::SetForegroundPixelWithLogicalFunction(int pixel)
+void wxWindowDCImpl::SetForegroundPixelWithLogicalFunction(WXPixel pixel)
  {
      if (m_logicalFunction == wxXOR)
      {
  {
      if (m_logicalFunction == wxXOR)
      {
@@ -1498,12 +1448,12 @@ void wxWindowDC::SetForegroundPixelWithLogicalFunction(int pixel)
      }
  }
  
      }
  }
  
-int wxWindowDC::CalculatePixel(wxColour& colour, wxColour& curCol,
+WXPixel wxWindowDCImpl::CalculatePixel(wxColour& colour, wxColour& curCol,
                                 bool roundToWhite) const
  {
      const unsigned char wp = (unsigned char)255;
                                 bool roundToWhite) const
  {
      const unsigned char wp = (unsigned char)255;
-        
-    int pixel = -1;
+
+    WXPixel pixel = -1;
      if(!m_colour) // Mono display
      {
          unsigned char red = colour.Red ();
      if(!m_colour) // Mono display
      {
          unsigned char red = colour.Red ();
@@ -1515,16 +1465,16 @@ int wxWindowDC::CalculatePixel(wxColour& colour, wxColour& curCol,
             ((red != 0 || blue != 0 || green != 0) && roundToWhite))
          {
              curCol = *wxWHITE;
             ((red != 0 || blue != 0 || green != 0) && roundToWhite))
          {
              curCol = *wxWHITE;
-            pixel = (int)WhitePixel((Display*) m_display,
-                                    DefaultScreen((Display*) m_display));
+            pixel = WhitePixel((Display*) m_display,
+                               DefaultScreen((Display*) m_display));
              curCol.SetPixel(pixel);
              colour.SetPixel(pixel);
          }
          else
          {
              curCol = *wxBLACK;
              curCol.SetPixel(pixel);
              colour.SetPixel(pixel);
          }
          else
          {
              curCol = *wxBLACK;
-            pixel = (int)BlackPixel((Display*) m_display,
-                                    DefaultScreen((Display*) m_display));
+            pixel = BlackPixel((Display*) m_display,
+                               DefaultScreen((Display*) m_display));
              curCol.SetPixel(pixel);
              colour.SetPixel(pixel);
          }
              curCol.SetPixel(pixel);
              colour.SetPixel(pixel);
          }
@@ -1539,12 +1489,12 @@ int wxWindowDC::CalculatePixel(wxColour& colour, wxColour& curCol,
      return pixel;
  }
  
      return pixel;
  }
  
-void wxWindowDC::SetPen( const wxPen &pen )
+void wxWindowDCImpl::SetPen( const wxPen &pen )
  {
  {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      m_pen = pen;
  
      m_pen = pen;
-    if (!m_pen.Ok())
+    if (!m_pen.IsOk())
          return;
  
      wxBitmap oldStipple = m_currentStipple;
          return;
  
      wxBitmap oldStipple = m_currentStipple;
@@ -1577,13 +1527,13 @@ void wxWindowDC::SetPen( const wxPen &pen )
          old_pen_dash == m_currentPenDash &&
          old_pen_width == m_currentPenWidth);
  
          old_pen_dash == m_currentPenDash &&
          old_pen_width == m_currentPenWidth);
  
-    bool sameColour = (oldPenColour.Ok () &&
+    bool sameColour = (oldPenColour.IsOk () &&
          (oldPenColour.Red () == m_currentColour.Red ()) &&
          (oldPenColour.Blue () == m_currentColour.Blue ()) &&
          (oldPenColour.Green () == m_currentColour.Green ()) &&
          (oldPenColour.GetPixel() == m_currentColour.GetPixel()));
  
          (oldPenColour.Red () == m_currentColour.Red ()) &&
          (oldPenColour.Blue () == m_currentColour.Blue ()) &&
          (oldPenColour.Green () == m_currentColour.Green ()) &&
          (oldPenColour.GetPixel() == m_currentColour.GetPixel()));
  
-    if (!sameStyle || !GetOptimization())
+    if (!sameStyle || !GET_OPTIMIZATION)
      {
          int scaled_width = (int) XLOG2DEVREL (m_pen.GetWidth ());
          if (scaled_width < 0)
      {
          int scaled_width = (int) XLOG2DEVREL (m_pen.GetWidth ());
          if (scaled_width < 0)
@@ -1634,7 +1584,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
          case wxTRANSPARENT:
          default:
              style = LineSolid;
          case wxTRANSPARENT:
          default:
              style = LineSolid;
-            req_dash = (wxX11Dash*)NULL;
+            req_dash = NULL;
              req_nb_dash = 0;
          }
  
              req_nb_dash = 0;
          }
  
@@ -1645,7 +1595,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
              {
                  int factor = scaled_width == 0 ? 1 : scaled_width;
                  for (int i = 0; i < req_nb_dash; i++)
              {
                  int factor = scaled_width == 0 ? 1 : scaled_width;
                  for (int i = 0; i < req_nb_dash; i++)
-                    real_req_dash[i] = req_dash[i] * factor;
+                    real_req_dash[i] = (wxX11Dash)(req_dash[i] * factor);
                  XSetDashes ((Display*) m_display, (GC) m_gc, 0, real_req_dash, req_nb_dash);
  
                  if (m_window && m_window->GetBackingPixmap())
                  XSetDashes ((Display*) m_display, (GC) m_gc, 0, real_req_dash, req_nb_dash);
  
                  if (m_window && m_window->GetBackingPixmap())
@@ -1696,7 +1646,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
              XSetLineAttributes ((Display*) m_display,(GC) m_gcBacking, scaled_width, style, cap, join);
      }
  
              XSetLineAttributes ((Display*) m_display,(GC) m_gcBacking, scaled_width, style, cap, join);
      }
  
-    if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GetOptimization()))
+    if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GET_OPTIMIZATION))
      {
          Pixmap myStipple;
  
      {
          Pixmap myStipple;
  
@@ -1753,8 +1703,8 @@ void wxWindowDC::SetPen( const wxPen &pen )
          if (m_window && m_window->GetBackingPixmap())
              XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
      }
          if (m_window && m_window->GetBackingPixmap())
              XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
      }
-    else if (m_currentStipple.Ok()
-        && ((m_currentStipple != oldStipple) || !GetOptimization()))
+    else if (m_currentStyle == wxSTIPPLE && m_currentStipple.IsOk()
+        && ((!m_currentStipple.IsSameAs(oldStipple)) || !GET_OPTIMIZATION))
      {
          XSetStipple ((Display*) m_display, (GC) m_gc, (Pixmap) m_currentStipple.GetDrawable());
  
      {
          XSetStipple ((Display*) m_display, (GC) m_gc, (Pixmap) m_currentStipple.GetDrawable());
  
@@ -1762,7 +1712,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
              XSetStipple ((Display*) m_display,(GC) m_gcBacking, (Pixmap) m_currentStipple.GetDrawable());
      }
  
              XSetStipple ((Display*) m_display,(GC) m_gcBacking, (Pixmap) m_currentStipple.GetDrawable());
      }
  
-    if ((m_currentFill != oldFill) || !GetOptimization())
+    if ((m_currentFill != oldFill) || !GET_OPTIMIZATION)
      {
          int fill_style;
  
      {
          int fill_style;
  
@@ -1778,15 +1728,17 @@ void wxWindowDC::SetPen( const wxPen &pen )
      }
  
      // must test m_logicalFunction, because it involves background!
      }
  
      // must test m_logicalFunction, because it involves background!
-    if (!sameColour || !GetOptimization()
+    if (!sameColour || !GET_OPTIMIZATION
          || ((m_logicalFunction == wxXOR) || (m_autoSetting & 0x2)))
      {
          || ((m_logicalFunction == wxXOR) || (m_autoSetting & 0x2)))
      {
-        int pixel = -1;
+        WXPixel pixel = -1;
          if (m_pen.GetStyle () == wxTRANSPARENT)
              pixel = m_backgroundPixel;
          else
          {
          if (m_pen.GetStyle () == wxTRANSPARENT)
              pixel = m_backgroundPixel;
          else
          {
-            pixel = CalculatePixel(m_pen.GetColour(), m_currentColour, FALSE);
+            wxColour penClr = m_pen.GetColour();
+            pixel = CalculatePixel( penClr, m_currentColour, false);
+            m_pen.SetColour(penClr);
          }
  
          // Finally, set the GC to the required colour
          }
  
          // Finally, set the GC to the required colour
@@ -1799,13 +1751,13 @@ void wxWindowDC::SetPen( const wxPen &pen )
      m_autoSetting = 0;
  }
  
      m_autoSetting = 0;
  }
  
-void wxWindowDC::SetBrush( const wxBrush &brush )
+void wxWindowDCImpl::SetBrush( const wxBrush &brush )
  {
  {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      m_brush = brush;
  
  
      m_brush = brush;
  
-    if (!m_brush.Ok() || m_brush.GetStyle () == wxTRANSPARENT)
+    if (!m_brush.IsOk() || m_brush.GetStyle () == wxTRANSPARENT)
          return;
  
      int oldFill = m_currentFill;
          return;
  
      int oldFill = m_currentFill;
@@ -1820,7 +1772,7 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
      wxColour oldBrushColour(m_currentColour);
      m_currentColour = m_brush.GetColour ();
  
      wxColour oldBrushColour(m_currentColour);
      m_currentColour = m_brush.GetColour ();
  
-    bool sameColour = (oldBrushColour.Ok () &&
+    bool sameColour = (oldBrushColour.IsOk () &&
          (oldBrushColour.Red () == m_currentColour.Red ()) &&
          (oldBrushColour.Blue () == m_currentColour.Blue ()) &&
          (oldBrushColour.Green () == m_currentColour.Green ()) &&
          (oldBrushColour.Red () == m_currentColour.Red ()) &&
          (oldBrushColour.Blue () == m_currentColour.Blue ()) &&
          (oldBrushColour.Green () == m_currentColour.Green ()) &&
@@ -1828,7 +1780,7 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
  
      int stippleDepth = -1;
  
  
      int stippleDepth = -1;
  
-    if ((oldFill != m_brush.GetStyle ()) || !GetOptimization())
+    if ((oldFill != m_brush.GetStyle ()) || !GET_OPTIMIZATION)
      {
          switch (brush.GetStyle ())
          {
      {
          switch (brush.GetStyle ())
          {
@@ -1850,7 +1802,7 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
                  // determine whether fill style should be solid or
                  // transparent
                  int style = stippleDepth == 1 ?
                  // determine whether fill style should be solid or
                  // transparent
                  int style = stippleDepth == 1 ?
-                    (m_backgroundMode == wxSOLID ? 
+                    (m_backgroundMode == wxSOLID ?
                       FillOpaqueStippled : FillStippled) :
                      FillTiled;
                  XSetFillStyle ((Display*) m_display, (GC) m_gc, style);
                       FillOpaqueStippled : FillStippled) :
                      FillTiled;
                  XSetFillStyle ((Display*) m_display, (GC) m_gc, style);
@@ -1867,7 +1819,7 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
          }
      }
  
          }
      }
  
-    if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GetOptimization()))
+    if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GET_OPTIMIZATION))
      {
          Pixmap myStipple;
  
      {
          Pixmap myStipple;
  
@@ -1925,7 +1877,7 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
      // X can forget the stipple value when resizing a window (apparently)
      // so always set the stipple.
      else if (m_currentFill != wxSOLID && m_currentFill != wxTRANSPARENT &&
      // X can forget the stipple value when resizing a window (apparently)
      // so always set the stipple.
      else if (m_currentFill != wxSOLID && m_currentFill != wxTRANSPARENT &&
-             m_currentStipple.Ok()) // && m_currentStipple != oldStipple)
+             m_currentStipple.IsOk()) // && m_currentStipple != oldStipple)
      {
          if (m_currentStipple.GetDepth() == 1)
          {
      {
          if (m_currentStipple.GetDepth() == 1)
          {
@@ -1946,10 +1898,12 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
      }
  
      // must test m_logicalFunction, because it involves background!
      }
  
      // must test m_logicalFunction, because it involves background!
-    if (!sameColour || !GetOptimization() || m_logicalFunction == wxXOR)
+    if (!sameColour || !GET_OPTIMIZATION || m_logicalFunction == wxXOR)
      {
      {
-        int pixel = CalculatePixel(m_brush.GetColour(), m_currentColour, TRUE);
- 
+        wxColour brushClr = m_brush.GetColour();
+        WXPixel pixel = CalculatePixel( brushClr, m_currentColour, true);
+        m_brush.SetColour(brushClr);
+
          if (pixel > -1)
              SetForegroundPixelWithLogicalFunction(pixel);
      }
          if (pixel > -1)
              SetForegroundPixelWithLogicalFunction(pixel);
      }
@@ -1957,13 +1911,13 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
          m_brush.GetColour().SetPixel(oldBrushColour.GetPixel());
  }
  
          m_brush.GetColour().SetPixel(oldBrushColour.GetPixel());
  }
  
-void wxWindowDC::SetBackground( const wxBrush &brush )
+void wxWindowDCImpl::SetBackground( const wxBrush &brush )
  {
  {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      m_backgroundBrush = brush;
  
  
      m_backgroundBrush = brush;
  
-    if (!m_backgroundBrush.Ok())
+    if (!m_backgroundBrush.IsOk())
          return;
  
      m_backgroundPixel = m_backgroundBrush.GetColour().AllocColour(m_display);
          return;
  
      m_backgroundPixel = m_backgroundBrush.GetColour().AllocColour(m_display);
@@ -1976,9 +1930,9 @@ void wxWindowDC::SetBackground( const wxBrush &brush )
                          m_backgroundPixel);
  }
  
                          m_backgroundPixel);
  }
  
-void wxWindowDC::SetLogicalFunction( int function )
+void wxWindowDCImpl::SetLogicalFunction( wxRasterOperationMode function )
  {
  {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      int x_function;
  
  
      int x_function;
  
@@ -2051,30 +2005,30 @@ void wxWindowDC::SetLogicalFunction( int function )
  
  }
  
  
  }
  
-void wxWindowDC::SetTextForeground( const wxColour &col )
+void wxWindowDCImpl::SetTextForeground( const wxColour &col )
  {
  {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      m_textForegroundColour = col;
  }
  
  
      m_textForegroundColour = col;
  }
  
-void wxWindowDC::SetTextBackground( const wxColour &col )
+void wxWindowDCImpl::SetTextBackground( const wxColour &col )
  {
  {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
  
      m_textBackgroundColour = col;
  }
  
  
      m_textBackgroundColour = col;
  }
  
-void wxWindowDC::SetBackgroundMode( int mode )
+void wxWindowDCImpl::SetBackgroundMode( int mode )
  {
      m_backgroundMode = mode;
  }
  
  {
      m_backgroundMode = mode;
  }
  
-void wxWindowDC::SetPalette( const wxPalette& palette )
+void wxWindowDCImpl::SetPalette( const wxPalette& palette )
  {
      if (m_window)
      {
  {
      if (m_window)
      {
-        if (palette.Ok())
+        if (palette.IsOk())
              /* Use GetXColormap */
              XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
              (Colormap) palette.GetXColormap());
              /* Use GetXColormap */
              XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
              (Colormap) palette.GetXColormap());
@@ -2093,9 +2047,9 @@ static void wxCopyRegion( WXRegion src, WXRegion& dst )
  }
  
  // Helper function; userRegion is the region set by calling SetClippingRegion
  }
  
  // Helper function; userRegion is the region set by calling SetClippingRegion
-void wxWindowDC::SetDCClipping( WXRegion userRegion )
+void wxWindowDCImpl::SetDCClipping( WXRegion userRegion )
  {
  {
-    bool hasUpdateRegion = m_window && m_window->GetUpdateRegion().Ok();
+    bool hasUpdateRegion = m_window && m_window->GetUpdateRegion().IsOk();
      // this means that we should start the clip region from scratch,
      // or from the update region, if any
      if( !userRegion )
      // this means that we should start the clip region from scratch,
      // or from the update region, if any
      if( !userRegion )
@@ -2125,12 +2079,13 @@ void wxWindowDC::SetDCClipping( WXRegion userRegion )
          XSetClipMask( (Display*)m_display, (GC)m_gc, None );
  }
  
          XSetClipMask( (Display*)m_display, (GC)m_gc, None );
  }
  
-void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y,
+void wxWindowDCImpl::DoSetClippingRegion( wxCoord x, wxCoord y,
                                        wxCoord width, wxCoord height )
  {
                                        wxCoord width, wxCoord height )
  {
-    wxDC::DoSetClippingRegion( x, y, width, height );
+    wxMotifDCImpl::DoSetClippingRegion( x, y, width, height );
  
  
-    wxRegion temp(x, y, width, height);
+    wxRegion temp(XLOG2DEV(x), YLOG2DEV(y),
+                  XLOG2DEVREL(width), YLOG2DEVREL(height));
  
      SetDCClipping(temp.GetX11Region());
  
  
      SetDCClipping(temp.GetX11Region());
  
@@ -2139,41 +2094,39 @@ void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y,
      if (m_window && m_window->GetBackingPixmap())
      {
          XRectangle rects[1];
      if (m_window && m_window->GetBackingPixmap())
      {
          XRectangle rects[1];
-        rects[0].x = XLOG2DEV_2(x);
-        rects[0].y = YLOG2DEV_2(y);
-        rects[0].width = XLOG2DEVREL(width);
-        rects[0].height = YLOG2DEVREL(height);
+        rects[0].x = (short)XLOG2DEV_2(x);
+        rects[0].y = (short)YLOG2DEV_2(y);
+        rects[0].width = (unsigned short)XLOG2DEVREL(width);
+        rects[0].height = (unsigned short)YLOG2DEVREL(height);
          XSetClipRectangles((Display*) m_display, (GC) m_gcBacking,
                             0, 0, rects, 1, Unsorted);
      }
  }
  
          XSetClipRectangles((Display*) m_display, (GC) m_gcBacking,
                             0, 0, rects, 1, Unsorted);
      }
  }
  
-void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion& region )
+void wxWindowDCImpl::DoSetDeviceClippingRegion( const wxRegion& region )
  {
  {
-    wxRect box = region.GetBox();
-
-    wxDC::DoSetClippingRegion( box.x, box.y, box.width, box.height );
-
      SetDCClipping(region.GetX11Region());
  
      // Needs to work differently for Pixmap: without this,
      // there's a nasty (Display*) m_display bug. 8/12/94
      if (m_window && m_window->GetBackingPixmap())
      {
      SetDCClipping(region.GetX11Region());
  
      // Needs to work differently for Pixmap: without this,
      // there's a nasty (Display*) m_display bug. 8/12/94
      if (m_window && m_window->GetBackingPixmap())
      {
+        wxRect box = region.GetBox();
+
          XRectangle rects[1];
          XRectangle rects[1];
-        rects[0].x = XLOG2DEV_2(box.x);
-        rects[0].y = YLOG2DEV_2(box.y);
-        rects[0].width = XLOG2DEVREL(box.width);
-        rects[0].height = YLOG2DEVREL(box.height);
+        rects[0].x = (short)box.x;
+        rects[0].y = (short)box.y;
+        rects[0].width = (unsigned short)box.width;
+        rects[0].height = (unsigned short)box.height;
          XSetClipRectangles((Display*) m_display, (GC) m_gcBacking,
                             0, 0, rects, 1, Unsorted);
      }
  }
  
  
          XSetClipRectangles((Display*) m_display, (GC) m_gcBacking,
                             0, 0, rects, 1, Unsorted);
      }
  }
  
  
-void wxWindowDC::DestroyClippingRegion()
+void wxWindowDCImpl::DestroyClippingRegion()
  {
  {
-    wxDC::DestroyClippingRegion();
+    wxMotifDCImpl::DestroyClippingRegion();
  
      SetDCClipping(NULL);
  
  
      SetDCClipping(NULL);
  
@@ -2182,13 +2135,13 @@ void wxWindowDC::DestroyClippingRegion()
  }
  
  // Resolution in pixels per logical inch
  }
  
  // Resolution in pixels per logical inch
-wxSize wxWindowDC::GetPPI() const
+wxSize wxWindowDCImpl::GetPPI() const
  {
      // TODO
      return wxSize(100, 100);
  }
  
  {
      // TODO
      return wxSize(100, 100);
  }
  
-int wxWindowDC::GetDepth() const
+int wxWindowDCImpl::GetDepth() const
  {
      // TODO
      return 24;
  {
      // TODO
      return 24;
@@ -2198,16 +2151,17 @@ int wxWindowDC::GetDepth() const
  
  
  // ----------------------------------------------------------------------------
  
  
  // ----------------------------------------------------------------------------
-// wxPaintDC
+// wxPaintDCImpl
  // ----------------------------------------------------------------------------
  
  // ----------------------------------------------------------------------------
  
-wxPaintDC::wxPaintDC(wxWindow* win) : wxWindowDC(win)
+wxPaintDCImpl::wxPaintDCImpl(wxDC *owner, wxWindow* win)
+             : wxWindowDCImpl(owner, win)
  {
      // Set the clipping region.to the update region
  {
      // Set the clipping region.to the update region
-    SetDCClipping((WXRegion)NULL);   
+    SetDCClipping((WXRegion)NULL);
  }
  
  }
  
-wxPaintDC::~wxPaintDC()
+wxPaintDCImpl::~wxPaintDCImpl()
  {
      if (m_window)
          m_window->ClearUpdateRegion();
  {
      if (m_window)
          m_window->ClearUpdateRegion();
@@ -2236,7 +2190,7 @@ static void XCopyRemote(Display *src_display, Display *dest_display,
      static const int CACHE_SIZE = 256;
  
      unsigned int i, j;
      static const int CACHE_SIZE = 256;
  
      unsigned int i, j;
-    unsigned long cachesrc[CACHE_SIZE], cachedest[CACHE_SIZE];
+    Pixel cachesrc[CACHE_SIZE], cachedest[CACHE_SIZE];
      int k, cache_pos, all_cache;
  
      if (!cache || !*cache)
      int k, cache_pos, all_cache;
  
      if (!cache || !*cache)
@@ -2250,11 +2204,11 @@ static void XCopyRemote(Display *src_display, Display *dest_display,
      destcm = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dest_display);
  
      cache_pos = 0;
      destcm = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dest_display);
  
      cache_pos = 0;
-    all_cache = FALSE;
+    all_cache = False;
  
      for (i = 0; i < w; i++)
          for (j = 0; j < h; j++) {
  
      for (i = 0; i < w; i++)
          for (j = 0; j < h; j++) {
-            unsigned long pixel;
+            Pixel pixel;
              XColor xcol;
  
              pixel = XGetPixel(image, i, j);
              XColor xcol;
  
              pixel = XGetPixel(image, i, j);
@@ -2278,7 +2232,7 @@ static void XCopyRemote(Display *src_display, Display *dest_display,
  
                          if (++cache_pos >= CACHE_SIZE) {
                              cache_pos = 0;
  
                          if (++cache_pos >= CACHE_SIZE) {
                              cache_pos = 0;
-                            all_cache = TRUE;
+                            all_cache = true;
                          }
  
  install:
                          }
  
  install:
@@ -2288,25 +2242,9 @@ install:
          XPutImage(dest_display, dest, destgc, destimage, 0, 0, destx, desty, w, h);
          XDestroyImage(destimage);
  
          XPutImage(dest_display, dest, destgc, destimage, 0, 0, destx, desty, w, h);
          XDestroyImage(destimage);
  
-        if (more)
+        if (more && cache)
              *cache = image;
          else
              XDestroyImage(image);
  }
  
              *cache = image;
          else
              XDestroyImage(image);
  }
  
-#if 0
-
-/* Helper function for 16-bit fonts */
-static int str16len(const char *s)
-{
-    int count = 0;
-
-    while (s[0] && s[1]) {
-        count++;
-        s += 2;
-    }
-
-    return count;
-}
-
-#endif // 0