X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/95724b1aa2f7248091cdec506d4678b4fbcea20d..94c09a19ec0406118b51b60657232ea3b14d6c4f:/src/motif/dcclient.cpp

diff --git a/src/motif/dcclient.cpp b/src/motif/dcclient.cpp
index d126382fd2..51919e9a08 100644
--- a/src/motif/dcclient.cpp
+++ b/src/motif/dcclient.cpp
@@ -12,11 +12,11 @@
 /*
   About pens, brushes, and the autoSetting flag:
 
-  Under X, pens and brushes control some of the same X drawing parameters.
-  Therefore, it is impossible to independently maintain the current pen and the
-  current brush. Also, some settings depend on the current logical function. The
-  m_currentFill, etc. instance variables remember state across the brush and
-  pen.
+  Under X, pens and brushes control some of the same X drawing
+  parameters.  Therefore, it is impossible to independently maintain
+  the current pen and the current brush. Also, some settings depend on
+  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
   indicate that a brush was recently used, and SetPen must be called to
@@ -36,17 +36,16 @@
 // headers
 // ----------------------------------------------------------------------------
 
-#ifdef __GNUG__
-    #pragma implementation "dcclient.h"
-#endif
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
 
 #include "wx/dcclient.h"
 #include "wx/dcmemory.h"
 #include "wx/window.h"
 #include "wx/app.h"
 #include "wx/image.h"
-
-#include <math.h>
+#include "wx/log.h"
+#include "wx/math.h"
 
 #ifdef __VMS__
 #pragma message disable nosimpint
@@ -82,12 +81,19 @@ static Pixmap bdiag, cdiag, fdiag, cross, horiz, verti;
 // macros
 // ----------------------------------------------------------------------------
 
-#if !USE_SHARED_LIBRARY
-    IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
-    IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxWindowDC)
-    IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
+IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
+IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxWindowDC)
+IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
+
+#ifndef IS_HATCH
+    // IS_HATCH exists for WXWIN_COMPATIBILITY_2_4 only
+    // but wxMotif needs it for its internals here
+    #define IS_HATCH(s)    ((s)>=wxFIRST_HATCH && (s)<=wxLAST_HATCH)
 #endif
 
+// FIXME: left over after removal of wxDC::GetOptimization()
+#define GET_OPTIMIZATION false
+
 // ----------------------------------------------------------------------------
 // prototypes
 // ----------------------------------------------------------------------------
@@ -127,7 +133,7 @@ static int roundmin(double a, double b)
 // wxWindowDC
 // ----------------------------------------------------------------------------
 
-wxWindowDC::wxWindowDC()
+void wxWindowDC::Init()
 {
     m_gc = (WXGC) 0;
     m_gcBacking = (WXGC) 0;
@@ -136,40 +142,31 @@ wxWindowDC::wxWindowDC()
     m_currentPenWidth = 1;
     m_currentPenJoin = -1;
     m_currentPenDashCount = -1;
-    m_currentPenDash = (char*) NULL;
+    m_currentPenDash = (wxX11Dash*) NULL;
     m_currentStyle = -1;
     m_currentFill = -1;
-    //    m_currentBkMode = wxTRANSPARENT;
     m_colour = wxColourDisplay();
     m_display = (WXDisplay*) NULL;
-    m_currentRegion = (WXRegion) 0;
-    m_userRegion = (WXRegion) 0;
     m_pixmap = (WXPixmap) 0;
     m_autoSetting = 0;
-    m_oldFont = (WXFont) 0;
+    m_ok = false;
+    m_clipRegion = (WXRegion) 0;
+}
+
+wxWindowDC::wxWindowDC()
+{
+    Init();
 }
 
 wxWindowDC::wxWindowDC( wxWindow *window )
 {
     wxASSERT_MSG( (window != (wxWindow*) NULL), "You must pass a valid wxWindow to wxWindowDC/wxClientDC/wxPaintDC constructor." );
 
+    Init();
+
     m_window = window;
     m_font = window->GetFont();
-    m_gc = (WXGC) 0;
-    m_gcBacking = (WXGC) 0;
-    m_backgroundPixel = -1;
-    m_currentPenWidth = 1;
-    m_currentPenJoin = -1;
-    m_currentPenDashCount = -1;
-    m_currentPenDash = (char*) NULL;
-    m_currentStyle = -1;
-    m_currentFill = -1;
-    //    m_currentBkMode = wxTRANSPARENT;
-    m_colour = wxColourDisplay();
-    m_currentRegion = (WXRegion) 0;
-    m_userRegion = (WXRegion) 0;
-    m_ok = TRUE;
-    m_autoSetting = 0;
+    m_ok = true;
 
     m_display = window->GetXDisplay();
     m_pixmap = window->GetXWindow();
@@ -181,39 +178,27 @@ wxWindowDC::wxWindowDC( wxWindow *window )
     gcvalues.foreground = BlackPixel (display, DefaultScreen (display));
     gcvalues.background = WhitePixel (display, DefaultScreen (display));
     gcvalues.graphics_exposures = False;
+    gcvalues.subwindow_mode = IncludeInferiors;
     gcvalues.line_width = 1;
     m_gc = (WXGC) XCreateGC (display, RootWindow (display, DefaultScreen (display)),
-        GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth,
+        GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth | GCSubwindowMode,
         &gcvalues);
 
     if (m_window->GetBackingPixmap())
     {
         m_gcBacking = (WXGC) XCreateGC (display, RootWindow (display,
             DefaultScreen (display)),
-            GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth,
+            GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth | GCSubwindowMode,
             &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;
-
     SetBackground(wxBrush(m_window->GetBackgroundColour(), wxSOLID));
 }
 
 wxWindowDC::~wxWindowDC()
 {
-    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;
@@ -222,26 +207,32 @@ wxWindowDC::~wxWindowDC()
         XFreeGC ((Display*) m_display, (GC) m_gcBacking);
     m_gcBacking = (WXGC) 0;
 
-    if (m_currentRegion)
-        XDestroyRegion ((Region) m_currentRegion);
-    m_currentRegion = (WXRegion) 0;
-
-    if (m_userRegion)
-        XDestroyRegion ((Region) m_userRegion);
-    m_userRegion = (WXRegion) 0;
+    if (m_clipRegion)
+        XDestroyRegion ((Region) m_clipRegion);
+    m_clipRegion = (WXRegion) 0;
 }
 
-void wxWindowDC::DoFloodFill( wxCoord WXUNUSED(x1), wxCoord WXUNUSED(y1),
-                           const wxColour& WXUNUSED(col), int WXUNUSED(style) )
+extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
+                          const wxColour & col, int style);
+
+bool wxWindowDC::DoFloodFill(wxCoord x, wxCoord y,
+                             const wxColour& col, int style)
 {
-    wxFAIL_MSG("not implemented");
+    return wxDoFloodFill(this, x, y, col, style);
 }
 
-bool wxWindowDC::DoGetPixel( wxCoord WXUNUSED(x1), wxCoord WXUNUSED(y1), wxColour *WXUNUSED(col) ) const
+bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
 {
-    wxFAIL_MSG("not implemented");
-
-    return FALSE;
+    // 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.SelectObject(wxNullBitmap);
+    wxImage image = bitmap.ConvertToImage();
+    col->Set(image.GetRed(0, 0), image.GetGreen(0, 0), image.GetBlue(0, 0));
+    return true;
 }
 
 void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
@@ -250,8 +241,6 @@ void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
 
     int x1d, y1d, x2d, y2d;
 
-    //  FreeGetPixelCache();
-
     x1d = XLOG2DEV(x1);
     y1d = YLOG2DEV(y1);
     x2d = XLOG2DEV(x2);
@@ -304,8 +293,6 @@ void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCo
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
-    //  FreeGetPixelCache();
-
     int xx1 = XLOG2DEV (x1);
     int yy1 = YLOG2DEV (y1);
     int xx2 = XLOG2DEV (x2);
@@ -317,7 +304,7 @@ void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCo
 
     wxCoord dx = xx1 - xxc;
     wxCoord dy = yy1 - yyc;
-    double radius = sqrt (dx * dx + dy * dy);
+    double radius = sqrt ((double)(dx * dx + dy * dy));
     wxCoord r = (wxCoord) radius;
 
     double radius1, radius2;
@@ -405,7 +392,7 @@ void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord
 
     if (m_brush.Ok() && 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);
@@ -432,8 +419,6 @@ void wxWindowDC::DoDrawPoint( wxCoord x, wxCoord y )
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
-    //  FreeGetPixelCache();
-
     if (m_pen.Ok() && m_autoSetting)
         SetPen (m_pen);
 
@@ -448,8 +433,6 @@ void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
-    //  FreeGetPixelCache();
-
     if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         if (m_autoSetting)
@@ -483,8 +466,6 @@ void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
-    //  FreeGetPixelCache();
-
     XPoint *xpoints1 = new XPoint[n + 1];
     XPoint *xpoints2 = new XPoint[n + 1];
     int i;
@@ -536,8 +517,6 @@ void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord h
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
-    //  FreeGetPixelCache();
-
     int xd, yd, wfd, hfd, wd, hd;
 
     xd = XLOG2DEV(x);
@@ -581,8 +560,6 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
-    //  FreeGetPixelCache();
-
     // If radius is negative, it's a proportion of the smaller dimension.
 
     if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
@@ -737,8 +714,6 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
     }
     CalcBoundingBox (x, y);
     CalcBoundingBox (x + width, y + height);
-
-
 }
 
 void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
@@ -758,8 +733,6 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
         width = - width ;
     }
 
-    //  FreeGetPixelCache();
-
     static const int angle = 23040;
 
     int xd, yd, wd, hd;
@@ -798,88 +771,54 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
 
 bool wxWindowDC::CanDrawBitmap() const
 {
-    wxCHECK_MSG( Ok(), FALSE, "invalid dc" );
+    wxCHECK_MSG( Ok(), false, "invalid dc" );
 
-    return TRUE;
+    return true;
 }
 
-#if 0
-void wxWindowDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y)
+// TODO: use scaled Blit e.g. as per John Price's implementation
+// in Contrib/Utilities
+bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
+                         wxCoord width, wxCoord height,
+                         wxDC *source, wxCoord xsrc, wxCoord ysrc,
+                         int rop, bool useMask,
+                         wxCoord xsrcMask, wxCoord ysrcMask )
 {
-    //  FreeGetPixelCache();
+    wxCHECK_MSG( Ok(), false, "invalid dc" );
 
-    // Be sure that foreground pixels (1) of
-    // the Icon will be painted with pen colour. [m_pen.SetColour()]
-    // Background pixels (0) will be painted with
-    // last selected background color. [::SetBackground]
-    if (m_pen.Ok() && m_autoSetting)
-        SetPen (m_pen);
+    wxWindowDC* sourceDC = wxDynamicCast(source, wxWindowDC);
 
-    int width, height;
-    Pixmap iconPixmap = (Pixmap) icon.GetPixmap();
-    width = icon.GetWidth();
-    height = icon.GetHeight();
-    if (icon.GetDisplay() == m_display)
-    {
-        if (icon.GetDepth() <= 1)
-        {
-            XCopyPlane  ((Display*) m_display, iconPixmap, (Pixmap) m_pixmap, (GC) m_gc,
-                0, 0, width, height,
-                (int) XLOG2DEV (x), (int) YLOG2DEV (y), 1);
-        }
-        else
-        {
-            XCopyArea  ((Display*) m_display, iconPixmap, (Pixmap) m_pixmap, (GC) m_gc,
-                0, 0, width, height,
-                (int) XLOG2DEV (x), (int) YLOG2DEV (y));
-        }
+    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
+    int oldBackgroundPixel = -1;
+    int oldForegroundPixel = -1;
 
+    if (m_textBackgroundColour.Ok())
+    {
+        oldBackgroundPixel = m_backgroundPixel;
+        int pixel = m_textBackgroundColour.AllocColour(m_display);
+
+        XSetBackground ((Display*) m_display, (GC) m_gc, pixel);
         if (m_window && m_window->GetBackingPixmap())
-        {
-            if (icon.GetDepth() <= 1)
-            {
-                XCopyPlane ((Display*) m_display, iconPixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
-                    0, 0, width, height, (int) XLOG2DEV_2 (x), (int) YLOG2DEV_2 (y), 1);
-            }
-            else
-            {
-                XCopyArea  ((Display*) m_display, iconPixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
-                    0, 0, width, height,
-                    (int) XLOG2DEV_2 (x), (int) YLOG2DEV_2 (y));
-            }
-        }
-    } else { /* Remote copy (different (Display*) m_displays) */
-        XImage *cache = NULL;
-        if (m_window && m_window->GetBackingPixmap())
-            XCopyRemote((Display*) icon.GetDisplay(), (Display*) m_display, iconPixmap, (Pixmap) m_window->GetBackingPixmap(),
-            (GC) m_gcBacking, 0, 0, width, height,
-            (int) XLOG2DEV_2 (x), (int) YLOG2DEV_2 (y), TRUE, &cache);
-        XCopyRemote((Display*) icon.GetDisplay(), (Display*) m_display, iconPixmap, (Pixmap) m_pixmap, (GC) m_gc,
-            0, 0, width, height,
-            (int) XLOG2DEV (x), (int) YLOG2DEV (y), FALSE, &cache);
+            XSetBackground ((Display*) m_display,(GC) m_gcBacking,
+                            pixel);
     }
-    CalcBoundingBox (x, y);
-}
-#endif // 0
-
-// TODO: use scaled Blit e.g. as per John Price's implementation in Contrib/Utilities
-bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
-                         wxDC *source, wxCoord xsrc, wxCoord ysrc, int rop, bool useMask )
-{
-    wxCHECK_MSG( Ok(), FALSE, "invalid dc" );
-
-    wxWindowDC* sourceDC = wxDynamicCast(source, wxWindowDC);
-
-    wxASSERT_MSG( sourceDC, "Blit source DC must be wxWindowDC or derived class." );
+    if (m_textForegroundColour.Ok())
+    {
+        oldForegroundPixel = m_currentColour.GetPixel();
 
-    //  FreeGetPixelCache();
+        if( m_textForegroundColour.GetPixel() <= -1 )
+            CalculatePixel( m_textForegroundColour,
+                            m_textForegroundColour, true);
 
-    // Be sure that foreground pixels (1) of the Icon will be painted with pen
-    // colour. [m_pen.SetColour()] Background pixels (0) will be painted with
-    // last selected background color. [::SetBackground]
-    if (m_pen.Ok() && m_autoSetting)
-        SetPen (m_pen);
+        int pixel = m_textForegroundColour.GetPixel();
+        if (pixel > -1)
+            SetForegroundPixelWithLogicalFunction(pixel);
+    }
 
     // Do bitmap scaling if necessary
 
@@ -887,6 +826,13 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
     Pixmap sourcePixmap = (Pixmap) NULL;
     double scaleX, scaleY;
     GetUserScale(& scaleX, & scaleY);
+    bool retVal = false;
+
+    /* TODO: use the mask origin when drawing transparently */
+    if (xsrcMask == -1 && ysrcMask == -1)
+    {
+        xsrcMask = xsrc; ysrcMask = ysrc;
+    }
 
     // Sorry, can't scale masks just yet
     if (!useMask && (scaleX != 1.0 || scaleY != 1.0) && sourceDC->IsKindOf(CLASSINFO(wxMemoryDC)))
@@ -896,10 +842,10 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
 
         wxASSERT_MSG( (bitmap.Ok()), "Bad source bitmap in wxWindowDC::Blit");
 
-        wxImage image(bitmap);
+        wxImage image = bitmap.ConvertToImage();
         if (!image.Ok())
         {
-            sourcePixmap = (Pixmap) bitmap.GetPixmap();
+            sourcePixmap = (Pixmap) bitmap.GetDrawable();
         }
         else
         {
@@ -907,8 +853,8 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
             int scaledH = (int) (bitmap.GetHeight() * scaleY);
 
             image = image.Scale(scaledW, scaledH);
-            scaledBitmap = new wxBitmap(image.ConvertToBitmap());
-            sourcePixmap = (Pixmap) scaledBitmap->GetPixmap();
+            scaledBitmap = new wxBitmap(image);
+            sourcePixmap = (Pixmap) scaledBitmap->GetDrawable();
         }
     }
     else
@@ -934,15 +880,15 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
                 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;
                 wxBitmap& sel = memDC->GetBitmap();
-                if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetPixmap() )
+                if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetBitmap() )
                 {
-                    XSetClipMask   ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetPixmap());
+                    XSetClipMask   ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetBitmap());
                     XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
                 }
             }
@@ -953,16 +899,23 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
                 source->LogicalToDeviceXRel(width),
                 source->LogicalToDeviceYRel(height),
                 XLOG2DEV (xdest), YLOG2DEV (ydest),
-                FALSE, &cache);
+                False, &cache);
 
             if ( useMask )
             {
-                XSetClipMask   ((Display*) m_display, (GC) m_gc, None);
+                if ( m_clipRegion )
+                    XSetRegion ((Display*) m_display, (GC) m_gc,
+                                (Region) m_clipRegion);
+                else
+                    XSetClipMask   ((Display*) m_display, (GC) m_gc, None);
+
                 XSetClipOrigin ((Display*) m_display, (GC) m_gc, 0, 0);
             }
 
         } else
-        {
+        {        //XGCValues 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
@@ -989,9 +942,9 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
             {
                 wxMemoryDC *memDC = (wxMemoryDC *)source;
                 wxBitmap& sel = memDC->GetBitmap();
-                if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetPixmap() )
+                if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetBitmap() )
                 {
-                    XSetClipMask   ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetPixmap());
+                    XSetClipMask   ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetBitmap());
                     XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
                 }
             }
@@ -1019,7 +972,12 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
             }
             if ( useMask )
             {
-                XSetClipMask   ((Display*) m_display, (GC) m_gc, None);
+                if ( m_clipRegion )
+                    XSetRegion ((Display*) m_display, (GC) m_gc,
+                                (Region) m_clipRegion);
+                else
+                    XSetClipMask   ((Display*) m_display, (GC) m_gc, None);
+
                 XSetClipOrigin ((Display*) m_display, (GC) m_gc, 0, 0);
             }
 
@@ -1029,13 +987,26 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
 
         SetLogicalFunction(orig);
 
-        if (scaledBitmap) delete scaledBitmap;
-
-        return TRUE;
+        retVal = true;
   }
   if (scaledBitmap) delete scaledBitmap;
 
-  return FALSE;
+  if (oldBackgroundPixel > -1)
+  {
+      XSetBackground ((Display*) m_display, (GC) m_gc, oldBackgroundPixel);
+      if (m_window && m_window->GetBackingPixmap())
+          XSetBackground ((Display*) m_display,(GC) m_gcBacking,
+                          oldBackgroundPixel);
+  }
+  if (oldForegroundPixel > -1)
+  {
+      XSetForeground ((Display*) m_display, (GC) m_gc, oldForegroundPixel);
+      if (m_window && m_window->GetBackingPixmap())
+          XSetForeground ((Display*) m_display,(GC) m_gcBacking,
+                          oldForegroundPixel);
+  }
+
+  return retVal;
 }
 
 void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
@@ -1046,28 +1017,24 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
     int cx = 0;
     int cy = 0;
     int ascent = 0;
-    int slen;
+    int slen = text.length();
 
-    slen = strlen(text);
+    // Set FillStyle, otherwise X will use current stipple!
+    XGCValues gcV, gcBackingV;
 
-    if (m_font.Ok())
+    XGetGCValues ((Display*) m_display, (GC)m_gc, GCFillStyle, &gcV);
+    XSetFillStyle ((Display*) m_display, (GC) m_gc, FillSolid);
+    if (m_window && m_window->GetBackingPixmap())
     {
-        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, (char*) (const char*) text, slen, &direction,
-                               &ascent, &descent, &overall_return);
-
-        cx = overall_return.width;
-        cy = ascent + descent;
+        XGetGCValues ((Display*) m_display, (GC)m_gcBacking, GCFillStyle,
+                      &gcBackingV );
+        XSetFillStyle ((Display*) m_display, (GC) m_gcBacking, FillSolid);
     }
 
+    if (m_font.Ok())
+        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
     if (m_textBackgroundColour.Ok () && (m_backgroundMode != wxTRANSPARENT))
@@ -1084,7 +1051,7 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
         sameColour = (sameColour &&
             (oldPenColour.GetPixel() == m_textBackgroundColour.GetPixel()));
 
-        if (!sameColour || !GetOptimization())
+        if (!sameColour || !GET_OPTIMIZATION)
         {
             int pixel = m_textBackgroundColour.AllocColour(m_display);
             m_currentColour = m_textBackgroundColour;
@@ -1117,36 +1084,10 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
             (oldPenColour.Green () == m_currentColour.Green ()) &&
             (oldPenColour.GetPixel() == m_currentColour.GetPixel()));
 
-        if (!sameColour || !GetOptimization())
+        if (!sameColour || !GET_OPTIMIZATION)
         {
-            int pixel = -1;
-            if (!m_colour) // Mono display
-            {
-                // Unless foreground is really white, draw it in black
-                unsigned char red = m_textForegroundColour.Red ();
-                unsigned char blue = m_textForegroundColour.Blue ();
-                unsigned char green = m_textForegroundColour.Green ();
-                if (red == (unsigned char) 255 && blue == (unsigned char) 255
-                    && green == (unsigned char) 255)
-                {
-                    m_currentColour = *wxWHITE;
-                    pixel = (int) WhitePixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
-                    m_currentColour.SetPixel(pixel);
-                    m_textForegroundColour.SetPixel(pixel);
-                }
-                else
-                {
-                    m_currentColour = *wxBLACK;
-                    pixel = (int) BlackPixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
-                    m_currentColour.SetPixel(pixel);
-                    m_textForegroundColour.SetPixel(pixel);
-                }
-            }
-            else
-            {
-                pixel = m_textForegroundColour.AllocColour((Display*) m_display);
-                m_currentColour.SetPixel(pixel);
-            }
+            int pixel = CalculatePixel(m_textForegroundColour,
+                                       m_currentColour, false);
 
             // Set the GC to the required colour
             if (pixel > -1)
@@ -1168,7 +1109,12 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
         (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);
+#endif
 
     if (m_window && m_window->GetBackingPixmap()) {
 #if 0
@@ -1178,17 +1124,31 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
             (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,
+                        wxConstCast(text.c_str(), char), slen);
+#else
             XDrawString((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
-            XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent, (char*) (const char*) text, slen);
+            XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent,
+                        wxConstCast(text.c_str(), char), slen);
+#endif
     }
 
+    // restore fill style
+    XSetFillStyle ((Display*) m_display, (GC) m_gc, gcV.fill_style);
+    if (m_window && m_window->GetBackingPixmap())
+        XSetFillStyle ((Display*) m_display, (GC) m_gcBacking,
+                       gcBackingV.fill_style);
+
     wxCoord w, h;
     GetTextExtent (text, &w, &h);
     CalcBoundingBox (x + w, y + h);
     CalcBoundingBox (x, y);
 }
 
-void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y, double angle )
+void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y,
+                                    double angle )
 {
     if (angle == 0.0)
     {
@@ -1198,32 +1158,35 @@ void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y,
 
     wxCHECK_RET( Ok(), "invalid dc" );
 
+    int oldBackgroundPixel = -1;
+    int oldForegroundPixel = -1;
+    int foregroundPixel = -1;
+    int backgroundPixel = -1;
+
+    if (m_textBackgroundColour.Ok())
+    {
+        oldBackgroundPixel = m_backgroundPixel;
+        backgroundPixel = m_textBackgroundColour.AllocColour(m_display);
+    }
+    if (m_textForegroundColour.Ok())
+    {
+        oldForegroundPixel = m_currentColour.GetPixel();
+
+        if( m_textForegroundColour.GetPixel() <= -1 )
+            CalculatePixel( m_textForegroundColour,
+                            m_textForegroundColour, true);
+
+        foregroundPixel = m_textForegroundColour.GetPixel();
+    }
+
     // 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;
-
-    slen = strlen(text);
 
     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, (char*) (const char*) text, slen, &direction,
-                               &ascent, &descent, &overall_return);
-
-        cx = overall_return.width;
-        cy = ascent + descent;
-    }
+        wxGetTextExtent (m_display, m_font, m_userScaleY * m_logicalScaleY,
+                         text, &cx, &cy, &ascent, NULL);
 
     wxBitmap src(cx, cy);
     wxMemoryDC dc;
@@ -1238,98 +1201,91 @@ void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y,
     // Calculate the size of the rotated bounding box.
     double dx = cos(angle / 180.0 * M_PI);
     double dy = sin(angle / 180.0 * M_PI);
-    double x4 = -cy * dy;
+    double x4 = cy * dy;
     double y4 = cy * dx;
     double x3 = cx * dx;
-    double y3 = cx * dy;
+    double y3 = -cx * dy;
     double x2 = x3 + x4;
     double y2 = y3 + y4;
     double x1 = x;
     double y1 = y;
 
     // Create image from the source bitmap after writing the text into it.
-    wxImage  image(src);
+    wxImage  image = src.ConvertToImage();
 
     int minx = roundmin(0, roundmin(x4, roundmin(x2, x3)));
     int miny = roundmin(0, roundmin(y4, roundmin(y2, y3)));
     int maxx = roundmax(0, roundmax(x4, roundmax(x2, x3)));
     int maxy = roundmax(0, roundmax(y4, roundmax(y2, y3)));
 
+    bool lastFore = false, lastBack = false;
+
     // This rotates counterclockwise around the top left corner.
     for (int rx = minx; rx < maxx; rx++)
     {
         for (int ry = miny; ry < maxy; ry++)
         {
             // transform dest coords to source coords
-            int sx = (int) (rx * dx + ry * dy + 0.5);
-            int sy = (int) (ry * dx - rx * dy + 0.5);
+            int sx = (int) (rx * dx - ry * dy + 0.5);
+            int sy = - (int) (-ry * dx - rx * dy + 0.5);
             if (sx >= 0 && sx < cx && sy >= 0 && sy < cy)
             {
+                bool textPixel = image.GetRed(sx, sy) == 0;
+
+                if (!textPixel && m_backgroundMode != wxSOLID)
+                    continue;
+
+                wxCoord ox = (wxCoord) (x1 + rx),
+                        oy = (wxCoord) (y1 + ry);
                 // draw black pixels, ignore white ones (i.e. transparent b/g)
-                if (image.GetRed(sx, sy) == 0)
-                {
+                if (textPixel && !lastFore)
                 {
-                    DrawPoint(x1 + maxx - rx, cy + y1 - ry);
+                    XSetForeground ((Display*) m_display, (GC) m_gc,
+                                    foregroundPixel);
+                    lastFore = true;
+                    lastBack = false;
                 }
-                else
+                else if (!textPixel && !lastBack)
                 {
-                    // Background
-                    //DrawPoint(x1 + maxx - rx, cy + y1 + maxy - ry);
+                    XSetForeground ((Display*) m_display, (GC) m_gc,
+                                    backgroundPixel);
+                    lastFore = false;
+                    lastBack = true;
                 }
-            }
-        }
-    }
-
-#if 0
-    // First draw a rectangle representing the text background, if a text
-    // background is specified
-    if (m_textBackgroundColour.Ok () && (m_backgroundMode != wxTRANSPARENT))
-    {
-        wxColour oldPenColour = m_currentColour;
-        m_currentColour = m_textBackgroundColour;
-        bool sameColour = (oldPenColour.Ok () && m_textBackgroundColour.Ok () &&
-            (oldPenColour.Red () == m_textBackgroundColour.Red ()) &&
-            (oldPenColour.Blue () == m_textBackgroundColour.Blue ()) &&
-            (oldPenColour.Green () == m_textBackgroundColour.Green ()));
 
-        // This separation of the big && test required for gcc2.7/HP UX 9.02
-        // or pixel value can be corrupted!
-        sameColour = (sameColour &&
-            (oldPenColour.GetPixel() == m_textBackgroundColour.GetPixel()));
-
-        if (!sameColour || !GetOptimization())
-        {
-            int pixel = m_textBackgroundColour.AllocColour(m_display);
-            m_currentColour = m_textBackgroundColour;
-
-            // Set the GC to the required colour
-            if (pixel > -1)
-            {
-                XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
+                XDrawPoint ((Display*) m_display, (Pixmap) m_pixmap,
+                            (GC) m_gc, XLOG2DEV (ox), YLOG2DEV (oy));
                 if (m_window && m_window->GetBackingPixmap())
-                    XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
+                    XDrawPoint ((Display*) m_display,
+                                (Pixmap) m_window->GetBackingPixmap(),
+                                (GC) m_gcBacking,
+                                XLOG2DEV_2 (ox), YLOG2DEV_2 (oy));
             }
         }
-        else
-            m_textBackgroundColour = oldPenColour ;
+    }
 
-        XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y), cx, cy);
+    if (oldBackgroundPixel > -1)
+    {
+        XSetBackground ((Display*) m_display, (GC) m_gc, oldBackgroundPixel);
         if (m_window && m_window->GetBackingPixmap())
-            XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
-            XLOG2DEV_2 (x), YLOG2DEV_2 (y), cx, cy);
+            XSetBackground ((Display*) m_display,(GC) m_gcBacking,
+                            oldBackgroundPixel);
+    }
+    if (oldForegroundPixel > -1)
+    {
+        XSetForeground ((Display*) m_display, (GC) m_gc, oldForegroundPixel);
+        if (m_window && m_window->GetBackingPixmap())
+            XSetForeground ((Display*) m_display,(GC) m_gcBacking,
+                            oldForegroundPixel);
     }
-#endif
 
-    long w, h;
-    // XXX use pixmap size
-    GetTextExtent (text, &w, &h);
-    CalcBoundingBox (x + w, y + h);
-    CalcBoundingBox (x, y);
+    CalcBoundingBox (minx, miny);
+    CalcBoundingBox (maxx, maxy);
 }
 
 bool wxWindowDC::CanGetTextExtent() const
 {
-    return TRUE;
+    return true;
 }
 
 void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoord *height,
@@ -1338,9 +1294,7 @@ void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoor
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
-    wxFont* theFont = font;
-    if (!theFont)
-        theFont = (wxFont *)&m_font; // const_cast
+    const wxFont* theFont = font ? font : &m_font;
 
     if (!theFont->Ok())
     {
@@ -1352,32 +1306,11 @@ void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoor
         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);
-
-#if 0
-    if (use16)
-        XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *) (char*) (const char*) string, slen, &direction,
-        &ascent, &descent2, &overall);
-    else
-#endif // 0
-        XTextExtents((XFontStruct*) pFontStruct, (char*) (const char*) string, slen, &direction,
-        &ascent, &descent2, &overall);
+    wxGetTextExtent(m_display, *theFont, m_userScaleY * m_logicalScaleY,
+                    string, width, height, NULL, descent);
 
-    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;
 }
@@ -1386,14 +1319,13 @@ wxCoord wxWindowDC::GetCharWidth() const
 {
     wxCHECK_MSG( Ok(), 0, "invalid dc" );
     wxCHECK_MSG( m_font.Ok(), 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
@@ -1401,52 +1333,39 @@ wxCoord wxWindowDC::GetCharHeight() const
     wxCHECK_MSG( Ok(), 0, "invalid dc" );
     wxCHECK_MSG( m_font.Ok(), 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::Clear()
+void wxWindowDC::DoGetSize( int *width, int *height ) const
 {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    int w = 0, h = 0;
 
-    int w, h;
-    if (m_window)
+    if( m_window )
     {
-        m_window->GetSize(&w, &h);
-
-        if (m_window && m_window->GetBackingPixmap())
+        if( m_window->GetBackingPixmap() )
         {
             w = m_window->GetPixmapWidth();
             h = m_window->GetPixmapHeight();
         }
-    }
-    else
-    {
-        if (this->IsKindOf(CLASSINFO(wxMemoryDC)))
-        {
-            wxMemoryDC* memDC = (wxMemoryDC*) this;
-            w = memDC->GetBitmap().GetWidth();
-            h = memDC->GetBitmap().GetHeight();
-        }
         else
-            return;
+            m_window->GetSize( &w, &h );
     }
 
-    wxBrush saveBrush = m_brush;
-    SetBrush (m_backgroundBrush);
-
-    XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, 0, 0, w, h);
+    if( width ) *width = w;
+    if( height ) *height = h;
+}
 
-    if (m_window && m_window->GetBackingPixmap())
-        XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, 0, 0, w, h);
+void wxWindowDC::Clear()
+{
+    wxCHECK_RET( Ok(), "invalid dc" );
 
-    m_brush = saveBrush;
+    wxRect rect( GetSize() );
+    Clear( rect );
 }
 
 void wxWindowDC::Clear(const wxRect& rect)
@@ -1459,10 +1378,13 @@ void wxWindowDC::Clear(const wxRect& rect)
     wxBrush saveBrush = m_brush;
     SetBrush (m_backgroundBrush);
 
-    XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, x, y, w, h);
+    XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc,
+                    x, y, w, h);
 
     if (m_window && m_window->GetBackingPixmap())
-        XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, x, y, w, h);
+        XFillRectangle ((Display*) m_display,
+                        (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+                        x, y, w, h);
 
     m_brush = saveBrush;
 }
@@ -1475,16 +1397,10 @@ void wxWindowDC::SetFont( const wxFont &font )
 
     if (!m_font.Ok())
     {
-        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;
     }
 
+#if !wxMOTIF_NEW_FONT_HANDLING
     WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
 
     Font fontId = ((XFontStruct*)pFontStruct)->fid;
@@ -1492,6 +1408,68 @@ void wxWindowDC::SetFont( const wxFont &font )
 
     if (m_window && m_window->GetBackingPixmap())
         XSetFont ((Display*) m_display,(GC) m_gcBacking, fontId);
+#endif
+}
+
+void wxWindowDC::SetForegroundPixelWithLogicalFunction(int pixel)
+{
+    if (m_logicalFunction == wxXOR)
+    {
+        XGCValues values;
+        XGetGCValues ((Display*) m_display, (GC) m_gc, GCBackground, &values);
+        XSetForeground ((Display*) m_display, (GC) m_gc,
+                        pixel ^ values.background);
+        if (m_window && m_window->GetBackingPixmap())
+            XSetForeground ((Display*) m_display,(GC) m_gcBacking,
+                            pixel ^ values.background);
+    }
+    else
+    {
+        XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
+        if (m_window && m_window->GetBackingPixmap())
+            XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
+    }
+}
+
+int wxWindowDC::CalculatePixel(wxColour& colour, wxColour& curCol,
+                               bool roundToWhite) const
+{
+    const unsigned char wp = (unsigned char)255;
+
+    int pixel = -1;
+    if(!m_colour) // Mono display
+    {
+        unsigned char red = colour.Red ();
+        unsigned char blue = colour.Blue ();
+        unsigned char green = colour.Green ();
+        // white
+        if((red == wp && blue == wp && green == wp) ||
+           // not black and roundToWhite was specified
+           ((red != 0 || blue != 0 || green != 0) && roundToWhite))
+        {
+            curCol = *wxWHITE;
+            pixel = (int)WhitePixel((Display*) m_display,
+                                    DefaultScreen((Display*) m_display));
+            curCol.SetPixel(pixel);
+            colour.SetPixel(pixel);
+        }
+        else
+        {
+            curCol = *wxBLACK;
+            pixel = (int)BlackPixel((Display*) m_display,
+                                    DefaultScreen((Display*) m_display));
+            curCol.SetPixel(pixel);
+            colour.SetPixel(pixel);
+        }
+    }
+    else
+    {
+        curCol = colour;
+        pixel = colour.AllocColour((Display*) m_display);
+        curCol.SetPixel(pixel);
+    }
+
+    return pixel;
 }
 
 void wxWindowDC::SetPen( const wxPen &pen )
@@ -1509,7 +1487,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
     int old_pen_join = m_currentPenJoin;
     int old_pen_cap = m_currentPenCap;
     int old_pen_nb_dash = m_currentPenDashCount;
-    char *old_pen_dash = m_currentPenDash;
+    wxX11Dash *old_pen_dash = m_currentPenDash;
 
     wxColour oldPenColour = m_currentColour;
     m_currentColour = m_pen.GetColour ();
@@ -1519,7 +1497,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
     m_currentPenJoin = m_pen.GetJoin ();
     m_currentPenCap = m_pen.GetCap ();
     m_currentPenDashCount = m_pen.GetDashCount();
-    m_currentPenDash = m_pen.GetDash();
+    m_currentPenDash = (wxX11Dash*)m_pen.GetDash();
 
     if (m_currentStyle == wxSTIPPLE)
         m_currentStipple = * m_pen.GetStipple ();
@@ -1538,7 +1516,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
         (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)
@@ -1547,15 +1525,15 @@ void wxWindowDC::SetPen( const wxPen &pen )
         int style;
         int join;
         int cap;
-        static const char dotted[] = {2, 5};
-        static const char short_dashed[] = {4, 4};
-        static const char long_dashed[] = {4, 8};
-        static const char dotted_dashed[] = {6, 6, 2, 6};
+        static const wxX11Dash dotted[] = {2, 5};
+        static const wxX11Dash short_dashed[] = {4, 4};
+        static const wxX11Dash long_dashed[] = {4, 8};
+        static const wxX11Dash dotted_dashed[] = {6, 6, 2, 6};
 
         // We express dash pattern in pen width unit, so we are
         // independent of zoom factor and so on...
         int req_nb_dash;
-        const char *req_dash;
+        const wxX11Dash *req_dash;
 
         switch (m_pen.GetStyle ())
         {
@@ -1589,13 +1567,13 @@ void wxWindowDC::SetPen( const wxPen &pen )
         case wxTRANSPARENT:
         default:
             style = LineSolid;
-            req_dash = NULL;
+            req_dash = (wxX11Dash*)NULL;
             req_nb_dash = 0;
         }
 
         if (req_dash && req_nb_dash)
         {
-            char *real_req_dash = new char[req_nb_dash];
+            wxX11Dash *real_req_dash = new wxX11Dash[req_nb_dash];
             if (real_req_dash)
             {
                 int factor = scaled_width == 0 ? 1 : scaled_width;
@@ -1651,7 +1629,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
             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;
 
@@ -1709,15 +1687,15 @@ void wxWindowDC::SetPen( const wxPen &pen )
             XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
     }
     else if (m_currentStipple.Ok()
-        && ((m_currentStipple != oldStipple) || !GetOptimization()))
+        && ((m_currentStipple != oldStipple) || !GET_OPTIMIZATION))
     {
-        XSetStipple ((Display*) m_display, (GC) m_gc, (Pixmap) m_currentStipple.GetPixmap());
+        XSetStipple ((Display*) m_display, (GC) m_gc, (Pixmap) m_currentStipple.GetDrawable());
 
         if (m_window && m_window->GetBackingPixmap())
-            XSetStipple ((Display*) m_display,(GC) m_gcBacking, (Pixmap) m_currentStipple.GetPixmap());
+            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;
 
@@ -1733,56 +1711,20 @@ void wxWindowDC::SetPen( const wxPen &pen )
     }
 
     // must test m_logicalFunction, because it involves background!
-    if (!sameColour || !GetOptimization()
+    if (!sameColour || !GET_OPTIMIZATION
         || ((m_logicalFunction == wxXOR) || (m_autoSetting & 0x2)))
     {
         int pixel = -1;
         if (m_pen.GetStyle () == wxTRANSPARENT)
             pixel = m_backgroundPixel;
-        else if (!m_colour)
-        {
-            unsigned char red = m_pen.GetColour ().Red ();
-            unsigned char blue = m_pen.GetColour ().Blue ();
-            unsigned char green = m_pen.GetColour ().Green ();
-            if (red == (unsigned char) 255 && blue == (unsigned char) 255
-                && green == (unsigned char) 255)
-            {
-                pixel = (int) WhitePixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
-                m_currentColour = *wxWHITE;
-                m_pen.GetColour().SetPixel(pixel);
-                m_currentColour.SetPixel(pixel);
-            }
-            else
-            {
-                pixel = (int) BlackPixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
-                m_currentColour = *wxBLACK;
-                m_pen.GetColour().SetPixel(pixel);
-            }
-        }
         else
         {
-            pixel = m_pen.GetColour ().AllocColour(m_display);
-            m_currentColour.SetPixel(pixel);
+            pixel = CalculatePixel(m_pen.GetColour(), m_currentColour, false);
         }
 
         // Finally, set the GC to the required colour
         if (pixel > -1)
-        {
-            if (m_logicalFunction == wxXOR)
-            {
-                XGCValues values;
-                XGetGCValues ((Display*) m_display, (GC) m_gc, GCBackground, &values);
-                XSetForeground ((Display*) m_display, (GC) m_gc, pixel ^ values.background);
-                if (m_window && m_window->GetBackingPixmap())
-                    XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel ^ values.background);
-            }
-            else
-            {
-                XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
-                if (m_window && m_window->GetBackingPixmap())
-                    XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
-            }
-        }
+            SetForegroundPixelWithLogicalFunction(pixel);
     }
     else
         m_pen.GetColour().SetPixel(oldPenColour.GetPixel());
@@ -1817,23 +1759,33 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
         (oldBrushColour.Green () == m_currentColour.Green ()) &&
         (oldBrushColour.GetPixel() == m_currentColour.GetPixel()));
 
-    if ((oldFill != m_brush.GetStyle ()) || !GetOptimization())
+    int stippleDepth = -1;
+
+    if ((oldFill != m_brush.GetStyle ()) || !GET_OPTIMIZATION)
     {
         switch (brush.GetStyle ())
         {
         case wxTRANSPARENT:
             break;
+        case wxSTIPPLE:
+            stippleDepth = m_currentStipple.GetDepth();
+            // fall through!
         case wxBDIAGONAL_HATCH:
         case wxCROSSDIAG_HATCH:
         case wxFDIAGONAL_HATCH:
         case wxCROSS_HATCH:
         case wxHORIZONTAL_HATCH:
         case wxVERTICAL_HATCH:
-        case wxSTIPPLE:
             {
-                // Chris Breeze 23/07/97: use background mode to determine whether
-                // fill style should be solid or transparent
-                int style = (m_backgroundMode == wxSOLID ? FillOpaqueStippled : FillStippled);
+                if (stippleDepth == -1) stippleDepth = 1;
+
+                // Chris Breeze 23/07/97: use background mode to
+                // determine whether fill style should be solid or
+                // transparent
+                int style = stippleDepth == 1 ?
+                    (m_backgroundMode == wxSOLID ?
+                     FillOpaqueStippled : FillStippled) :
+                    FillTiled;
                 XSetFillStyle ((Display*) m_display, (GC) m_gc, style);
                 if (m_window && m_window->GetBackingPixmap())
                     XSetFillStyle ((Display*) m_display,(GC) m_gcBacking, style);
@@ -1843,11 +1795,12 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
         default:
             XSetFillStyle ((Display*) m_display, (GC) m_gc, FillSolid);
             if (m_window && m_window->GetBackingPixmap())
-                XSetFillStyle ((Display*) m_display,(GC) m_gcBacking, FillSolid);
+                XSetFillStyle ((Display*) m_display,(GC) m_gcBacking,
+                               FillSolid);
         }
     }
 
-    if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GetOptimization()))
+    if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GET_OPTIMIZATION))
     {
         Pixmap myStipple;
 
@@ -1904,74 +1857,34 @@ 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_currentStipple.Ok()) // && m_currentStipple != oldStipple)
+    else if (m_currentFill != wxSOLID && m_currentFill != wxTRANSPARENT &&
+             m_currentStipple.Ok()) // && m_currentStipple != oldStipple)
     {
-        XSetStipple ((Display*) m_display, (GC) m_gc, (Pixmap) m_currentStipple.GetPixmap());
+        if (m_currentStipple.GetDepth() == 1)
+        {
+            XSetStipple ((Display*) m_display, (GC) m_gc,
+                         (Pixmap) m_currentStipple.GetDrawable());
         if (m_window && m_window->GetBackingPixmap())
-            XSetStipple ((Display*) m_display,(GC) m_gcBacking, (Pixmap) m_currentStipple.GetPixmap());
+                XSetStipple ((Display*) m_display,(GC) m_gcBacking,
+                             (Pixmap) m_currentStipple.GetDrawable());
+        }
+        else
+        {
+            XSetTile ((Display*) m_display, (GC) m_gc,
+                      (Pixmap) m_currentStipple.GetDrawable());
+            if (m_window && m_window->GetBackingPixmap())
+                XSetTile ((Display*) m_display,(GC) m_gcBacking,
+                          (Pixmap) m_currentStipple.GetDrawable());
+        }
     }
 
     // must test m_logicalFunction, because it involves background!
-    if (!sameColour || !GetOptimization() || m_logicalFunction == wxXOR)
+    if (!sameColour || !GET_OPTIMIZATION || m_logicalFunction == wxXOR)
     {
-        int pixel = -1;
-        if (!m_colour)
-        {
-            // Policy - on a monochrome screen, all brushes are white,
-            // except when they're REALLY black!!!
-            unsigned char red = m_brush.GetColour ().Red ();
-            unsigned char blue = m_brush.GetColour ().Blue ();
-            unsigned char green = m_brush.GetColour ().Green ();
-
-            if (red == (unsigned char) 0 && blue == (unsigned char) 0
-                && green == (unsigned char) 0)
-            {
-                pixel = (int) BlackPixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
-                m_currentColour = *wxBLACK;
-                m_brush.GetColour().SetPixel(pixel);
-                m_currentColour.SetPixel(pixel);
-            }
-            else
-            {
-                pixel = (int) WhitePixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
-                m_currentColour = *wxWHITE;
-                m_brush.GetColour().SetPixel(pixel);
-                m_currentColour.SetPixel(pixel);
-            }
+        int pixel = CalculatePixel(m_brush.GetColour(), m_currentColour, true);
 
-            // N.B. comment out the above line and uncomment the following lines
-            // if you want non-white colours to be black on a monochrome display.
-            /*
-            if (red == (unsigned char )255 && blue == (unsigned char)255
-            && green == (unsigned char)255)
-            pixel = (int)WhitePixel((Display*) m_display, DefaultScreen((Display*) m_display));
-            else
-            pixel = (int)BlackPixel((Display*) m_display, DefaultScreen((Display*) m_display));
-            */
-        }
-        else if (m_brush.GetStyle () != wxTRANSPARENT)
-        {
-            pixel = m_brush.GetColour().AllocColour(m_display);
-            m_currentColour.SetPixel(pixel);
-        }
         if (pixel > -1)
-        {
-            // Finally, set the GC to the required colour
-            if (m_logicalFunction == wxXOR)
-            {
-                XGCValues values;
-                XGetGCValues ((Display*) m_display, (GC) m_gc, GCBackground, &values);
-                XSetForeground ((Display*) m_display, (GC) m_gc, pixel ^ values.background);
-                if (m_window && m_window->GetBackingPixmap())
-                    XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel ^ values.background);
-            }
-            else
-            {
-                XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
-                if (m_window && m_window->GetBackingPixmap())
-                    XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
-            }
-        }
+            SetForegroundPixelWithLogicalFunction(pixel);
     }
     else
         m_brush.GetColour().SetPixel(oldBrushColour.GetPixel());
@@ -1986,21 +1899,14 @@ void wxWindowDC::SetBackground( const wxBrush &brush )
     if (!m_backgroundBrush.Ok())
         return;
 
-    int pixel = m_backgroundBrush.GetColour().AllocColour(m_display);
-
-    // New behaviour, 10/2/99: setting the background brush of a DC
-    // doesn't affect the window background colour.
-/*
-    // XSetWindowBackground doesn't work for non-Window pixmaps
-    if (!this->IsKindOf(CLASSINFO(wxMemoryDC)))
-        XSetWindowBackground ((Display*) m_display, (Pixmap) m_pixmap, pixel);
-*/
+    m_backgroundPixel = m_backgroundBrush.GetColour().AllocColour(m_display);
 
     // Necessary for ::DrawIcon, which use fg/bg pixel or the GC.
     // And Blit,... (Any fct that use XCopyPlane, in fact.)
-    XSetBackground ((Display*) m_display, (GC) m_gc, pixel);
+    XSetBackground ((Display*) m_display, (GC) m_gc, m_backgroundPixel);
     if (m_window && m_window->GetBackingPixmap())
-        XSetBackground ((Display*) m_display,(GC) m_gcBacking, pixel);
+        XSetBackground ((Display*) m_display,(GC) m_gcBacking,
+                        m_backgroundPixel);
 }
 
 void wxWindowDC::SetLogicalFunction( int function )
@@ -2082,23 +1988,14 @@ void wxWindowDC::SetTextForeground( const wxColour &col )
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
-    if (m_textForegroundColour == col)
-        return;
-
     m_textForegroundColour = col;
-
 }
 
 void wxWindowDC::SetTextBackground( const wxColour &col )
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
-    if (m_textBackgroundColour == col)
-        return;
-
     m_textBackgroundColour = col;
-    if (!m_textBackgroundColour.Ok())
-        return;
 }
 
 void wxWindowDC::SetBackgroundMode( int mode )
@@ -2121,57 +2018,54 @@ void wxWindowDC::SetPalette( const wxPalette& palette )
     }
 }
 
-// Helper function
-void wxWindowDC::SetDCClipping()
+static void wxCopyRegion( WXRegion src, WXRegion& dst )
 {
-    // m_userRegion is the region set by calling SetClippingRegion
-
-    if (m_currentRegion)
-        XDestroyRegion ((Region) m_currentRegion);
-
-    // We need to take into account
-    // clipping imposed on a window by a repaint.
-    // We'll combine it with the user region. But for now,
-    // just use the currently-defined user clipping region.
-    if (m_userRegion || (m_window && m_window->GetUpdateRegion().Ok()) )
-        m_currentRegion = (WXRegion) XCreateRegion ();
-    else
-        m_currentRegion = (WXRegion) NULL;
-
-    if ((m_window && m_window->GetUpdateRegion().Ok()) && m_userRegion)
-        XIntersectRegion ((Region) m_window->GetUpdateRegion().GetXRegion(), (Region) m_userRegion, (Region) m_currentRegion);
-    else if (m_userRegion)
-        XIntersectRegion ((Region) m_userRegion, (Region) m_userRegion, (Region) m_currentRegion);
-    else if (m_window && m_window->GetUpdateRegion().Ok())
-        XIntersectRegion ((Region) m_window->GetUpdateRegion().GetXRegion(), (Region) m_window->GetUpdateRegion().GetXRegion(),
-        (Region) m_currentRegion);
+    if( !dst )
+        dst = XCreateRegion();
+    XUnionRegion( (Region)src, (Region)src, (Region)dst );
+}
 
-    if (m_currentRegion)
+// Helper function; userRegion is the region set by calling SetClippingRegion
+void wxWindowDC::SetDCClipping( WXRegion userRegion )
+{
+    bool hasUpdateRegion = m_window && m_window->GetUpdateRegion().Ok();
+    // this means that we should start the clip region from scratch,
+    // or from the update region, if any
+    if( !userRegion )
     {
-        XSetRegion ((Display*) m_display, (GC) m_gc, (Region) m_currentRegion);
+        if( m_clipRegion )
+            XDestroyRegion( (Region)m_clipRegion );
+        m_clipRegion = (WXRegion)NULL;
+
+        if( hasUpdateRegion )
+            wxCopyRegion( m_window->GetUpdateRegion().GetX11Region(),
+                          m_clipRegion );
     }
-    else
+    // intersect the user region, if any, with the
+    // exisiting clip region
+    else // if( userRegion )
     {
-        XSetClipMask ((Display*) m_display, (GC) m_gc, None);
+        if( !m_clipRegion )
+            wxCopyRegion( userRegion, m_clipRegion );
+        else
+            XIntersectRegion( (Region)m_clipRegion,
+                              (Region)userRegion, (Region)m_clipRegion );
     }
 
+    if( m_clipRegion )
+        XSetRegion( (Display*)m_display, (GC)m_gc, (Region)m_clipRegion );
+    else
+        XSetClipMask( (Display*)m_display, (GC)m_gc, None );
 }
 
-void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
+void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y,
+                                      wxCoord width, wxCoord height )
 {
     wxDC::DoSetClippingRegion( x, y, width, height );
 
-    if (m_userRegion)
-        XDestroyRegion ((Region) m_userRegion);
-    m_userRegion = (WXRegion) XCreateRegion ();
-    XRectangle r;
-    r.x = XLOG2DEV (x);
-    r.y = YLOG2DEV (y);
-    r.width = XLOG2DEVREL(width);
-    r.height = YLOG2DEVREL(height);
-    XUnionRectWithRegion (&r, (Region) m_userRegion, (Region) m_userRegion);
+    wxRegion temp(x, y, width, height);
 
-    SetDCClipping ();
+    SetDCClipping(temp.GetX11Region());
 
     // Needs to work differently for Pixmap: without this,
     // there's a nasty (Display*) m_display bug. 8/12/94
@@ -2182,7 +2076,8 @@ void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoo
         rects[0].y = YLOG2DEV_2(y);
         rects[0].width = XLOG2DEVREL(width);
         rects[0].height = 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);
     }
 }
 
@@ -2192,13 +2087,7 @@ void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion& region )
 
     wxDC::DoSetClippingRegion( box.x, box.y, box.width, box.height );
 
-    if (m_userRegion)
-        XDestroyRegion ((Region) m_userRegion);
-    m_userRegion = (WXRegion) XCreateRegion ();
-
-    XUnionRegion((Region) m_userRegion, (Region) region.GetXRegion(), (Region) m_userRegion);
-
-    SetDCClipping ();
+    SetDCClipping(region.GetX11Region());
 
     // Needs to work differently for Pixmap: without this,
     // there's a nasty (Display*) m_display bug. 8/12/94
@@ -2209,7 +2098,8 @@ void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion& region )
         rects[0].y = YLOG2DEV_2(box.y);
         rects[0].width = XLOG2DEVREL(box.width);
         rects[0].height = YLOG2DEVREL(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);
     }
 }
 
@@ -2218,21 +2108,16 @@ void wxWindowDC::DestroyClippingRegion()
 {
     wxDC::DestroyClippingRegion();
 
-    if (m_userRegion)
-        XDestroyRegion ((Region) m_userRegion);
-    m_userRegion = NULL;
+    SetDCClipping(NULL);
 
-    SetDCClipping ();
-
-    XGCValues gc_val;
-    gc_val.clip_mask = None;
     if (m_window && m_window->GetBackingPixmap())
-        XChangeGC((Display*) m_display, (GC) m_gcBacking, GCClipMask, &gc_val);
+        XSetClipMask ((Display*) m_display, (GC) m_gcBacking, None);
 }
 
 // Resolution in pixels per logical inch
 wxSize wxWindowDC::GetPPI() const
 {
+    // TODO
     return wxSize(100, 100);
 }
 
@@ -2242,175 +2127,6 @@ int wxWindowDC::GetDepth() const
     return 24;
 }
 
-#if wxUSE_SPLINES
-// ----------------------------------- spline code ----------------------------------------
-
-void wx_quadratic_spline(double a1, double b1, double a2, double b2,
-                         double a3, double b3, double a4, double b4);
-void wx_clear_stack();
-int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
-        double *y3, double *x4, double *y4);
-void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
-          double x4, double y4);
-static bool wx_spline_add_point(double x, double y);
-static void wx_spline_draw_point_array(wxDC *dc);
-
-wxList wx_spline_point_list;
-
-#define                half(z1, z2)        ((z1+z2)/2.0)
-#define                THRESHOLD        5
-
-/* iterative version */
-
-void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
-                 double b4)
-{
-    register double  xmid, ymid;
-    double           x1, y1, x2, y2, x3, y3, x4, y4;
-
-    wx_clear_stack();
-    wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
-
-    while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
-        xmid = (double)half(x2, x3);
-        ymid = (double)half(y2, y3);
-        if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
-            fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
-            wx_spline_add_point( x1, y1 );
-            wx_spline_add_point( xmid, ymid );
-        } else {
-            wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
-                 (double)half(x3, x4), (double)half(y3, y4), x4, y4);
-            wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
-                 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
-        }
-    }
-}
-
-/* utilities used by spline drawing routines */
-
-typedef struct wx_spline_stack_struct {
-    double           x1, y1, x2, y2, x3, y3, x4, y4;
-} Stack;
-
-#define         SPLINE_STACK_DEPTH             20
-static Stack    wx_spline_stack[SPLINE_STACK_DEPTH];
-static Stack   *wx_stack_top;
-static int      wx_stack_count;
-
-void wx_clear_stack()
-{
-    wx_stack_top = wx_spline_stack;
-    wx_stack_count = 0;
-}
-
-void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
-{
-    wx_stack_top->x1 = x1;
-    wx_stack_top->y1 = y1;
-    wx_stack_top->x2 = x2;
-    wx_stack_top->y2 = y2;
-    wx_stack_top->x3 = x3;
-    wx_stack_top->y3 = y3;
-    wx_stack_top->x4 = x4;
-    wx_stack_top->y4 = y4;
-    wx_stack_top++;
-    wx_stack_count++;
-}
-
-int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
-                  double *x3, double *y3, double *x4, double *y4)
-{
-    if (wx_stack_count == 0)
-        return (0);
-    wx_stack_top--;
-    wx_stack_count--;
-    *x1 = wx_stack_top->x1;
-    *y1 = wx_stack_top->y1;
-    *x2 = wx_stack_top->x2;
-    *y2 = wx_stack_top->y2;
-    *x3 = wx_stack_top->x3;
-    *y3 = wx_stack_top->y3;
-    *x4 = wx_stack_top->x4;
-    *y4 = wx_stack_top->y4;
-    return (1);
-}
-
-static bool wx_spline_add_point(double x, double y)
-{
-  wxPoint *point = new wxPoint ;
-  point->x = (int) x;
-  point->y = (int) y;
-  wx_spline_point_list.Append((wxObject*)point);
-  return TRUE;
-}
-
-static void wx_spline_draw_point_array(wxDC *dc)
-{
-  dc->DrawLines(&wx_spline_point_list, 0, 0 );
-  wxNode *node = wx_spline_point_list.First();
-  while (node)
-  {
-    wxPoint *point = (wxPoint *)node->Data();
-    delete point;
-    delete node;
-    node = wx_spline_point_list.First();
-  }
-}
-
-void wxWindowDC::DoDrawSpline( wxList *points )
-{
-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
-
-    wxPoint *p;
-    double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
-    double           x1, y1, x2, y2;
-
-    wxNode *node = points->First();
-    p = (wxPoint *)node->Data();
-
-    x1 = p->x;
-    y1 = p->y;
-
-    node = node->Next();
-    p = (wxPoint *)node->Data();
-
-    x2 = p->x;
-    y2 = p->y;
-    cx1 = (double)((x1 + x2) / 2);
-    cy1 = (double)((y1 + y2) / 2);
-    cx2 = (double)((cx1 + x2) / 2);
-    cy2 = (double)((cy1 + y2) / 2);
-
-    wx_spline_add_point(x1, y1);
-
-    while ((node = node->Next()) != NULL)
-    {
-        p = (wxPoint *)node->Data();
-        x1 = x2;
-        y1 = y2;
-        x2 = p->x;
-        y2 = p->y;
-        cx4 = (double)(x1 + x2) / 2;
-        cy4 = (double)(y1 + y2) / 2;
-        cx3 = (double)(x1 + cx4) / 2;
-        cy3 = (double)(y1 + cy4) / 2;
-
-        wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
-
-        cx1 = cx4;
-        cy1 = cy4;
-        cx2 = (double)(cx1 + x2) / 2;
-        cy2 = (double)(cy1 + y2) / 2;
-    }
-
-    wx_spline_add_point( cx1, cy1 );
-    wx_spline_add_point( x2, y2 );
-
-    wx_spline_draw_point_array( this );
-}
-
-#endif // wxUSE_SPLINE
 
 
 
@@ -2420,51 +2136,15 @@ void wxWindowDC::DoDrawSpline( wxList *points )
 
 wxPaintDC::wxPaintDC(wxWindow* win) : wxWindowDC(win)
 {
-    wxRegion* region = NULL;
-
-    // Combine all the update rects into a region
-    const wxRectList& updateRects(win->GetUpdateRects());
-    if ( updateRects.GetCount() != 0 )
-    {
-        for ( wxRectList::Node *node = updateRects.GetFirst();
-              node;
-              node = node->GetNext() )
-        {
-            wxRect* rect = node->GetData();
-
-            if (!region)
-                region = new wxRegion(*rect);
-            else
-                // TODO: is this correct? In SetDCClipping above,
-                // XIntersectRegion is used to combine paint and user
-                // regions. XIntersectRegion appears to work in that case...
-                region->Union(*rect);
-        }
-    }
-    else
-    {
-        int cw, ch;
-        win->GetClientSize(&cw, &ch);
-        region = new wxRegion(wxRect(0, 0, cw, ch));
-    }
-
-    win->SetUpdateRegion(*region);
-
-    wxRegion& theRegion(win->GetUpdateRegion());
-    theRegion.SetRects(updateRects); // We also store in terms of rects, for iteration to work.
-
-    // Set the clipping region. Any user-defined region will be combined with this
-    // one in SetDCClipping.
-    XSetRegion ((Display*) m_display, (GC) m_gc, (Region) region->GetXRegion());
-
-    delete region;
+    // Set the clipping region.to the update region
+    SetDCClipping((WXRegion)NULL);
 }
 
 wxPaintDC::~wxPaintDC()
 {
-    XSetClipMask ((Display*) m_display, (GC) m_gc, None);
     if (m_window)
         m_window->ClearUpdateRegion();
+    SetDCClipping((WXRegion)NULL);
 }
 
 // ----------------------------------------------------------------------------
@@ -2503,7 +2183,7 @@ static void XCopyRemote(Display *src_display, Display *dest_display,
     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++) {
@@ -2531,7 +2211,7 @@ static void XCopyRemote(Display *src_display, Display *dest_display,
 
                         if (++cache_pos >= CACHE_SIZE) {
                             cache_pos = 0;
-                            all_cache = TRUE;
+                            all_cache = true;
                         }
 
 install: