X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/96f201da8b08391fd719ad74875b87afacc8fc97..c5e2dc6f5ba909192ff6c22ead5e7600a00bad0f:/src/motif/dcclient.cpp

diff --git a/src/motif/dcclient.cpp b/src/motif/dcclient.cpp
index 7e2c71d1c8..914b32f18b 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,7 +36,7 @@
 // headers
 // ----------------------------------------------------------------------------
 
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
     #pragma implementation "dcclient.h"
 #endif
 
@@ -45,13 +45,24 @@
 #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
 #include <Xm/Xm.h>
+#ifdef __VMS__
+#pragma message enable nosimpint
+#endif
 
 #include "wx/motif/private.h"
 
+#ifdef __EMX__
+    #include <float.h>          // for M_PI
+#endif // __EMX__
+
 #include "bdiag.xbm"
 #include "fdiag.xbm"
 #include "cdiag.xbm"
@@ -65,8 +76,6 @@ static Pixmap bdiag, cdiag, fdiag, cross, horiz, verti;
 // constants
 // ----------------------------------------------------------------------------
 
-#define RAD2DEG 57.2957795131
-
 // Fudge factor (VZ: what??)
 #define WX_GC_CF 1
 
@@ -74,11 +83,9 @@ 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)
-#endif
 
 // ----------------------------------------------------------------------------
 // prototypes
@@ -96,11 +103,30 @@ static void XCopyRemote(Display *src_display, Display *dest_display,
 // implementation
 // ============================================================================
 
+/*
+ * compare two doubles and return the larger rounded
+ * to the nearest int
+ */
+static int roundmax(double a, double b)
+{
+    return (int)((a > b ? a : b) + 0.5);
+}
+
+/*
+ * compare two doubles and return the smaller rounded
+ * to the nearest int
+ */
+static int roundmin(double a, double b)
+{
+    return (int)((a < b ? a : b) - 0.5);
+}
+
+
 // ----------------------------------------------------------------------------
 // wxWindowDC
 // ----------------------------------------------------------------------------
 
-wxWindowDC::wxWindowDC()
+void wxWindowDC::Init()
 {
     m_gc = (WXGC) 0;
     m_gcBacking = (WXGC) 0;
@@ -109,39 +135,32 @@ 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_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_font = window->GetFont();
     m_ok = TRUE;
-    m_autoSetting = 0;
 
     m_display = window->GetXDisplay();
     m_pixmap = window->GetXWindow();
@@ -153,16 +172,17 @@ 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);
     }
 
@@ -194,36 +214,40 @@ 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( long WXUNUSED(x1), long 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( long WXUNUSED(x1), long 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( long x1, long y1, long x2, long y2 )
+void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
     int x1d, y1d, x2d, y2d;
 
-    //  FreeGetPixelCache();
-
     x1d = XLOG2DEV(x1);
     y1d = YLOG2DEV(y1);
     x2d = XLOG2DEV(x2);
@@ -243,7 +267,7 @@ void wxWindowDC::DoDrawLine( long x1, long y1, long x2, long y2 )
     CalcBoundingBox(x2, y2);
 }
 
-void wxWindowDC::DoCrossHair( long x, long y )
+void wxWindowDC::DoCrossHair( wxCoord x, wxCoord y )
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
@@ -272,12 +296,10 @@ void wxWindowDC::DoCrossHair( long x, long y )
     }
 }
 
-void wxWindowDC::DoDrawArc( long x1, long y1, long x2, long y2, long xc, long yc )
+void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc )
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
-    //  FreeGetPixelCache();
-
     int xx1 = XLOG2DEV (x1);
     int yy1 = YLOG2DEV (y1);
     int xx2 = XLOG2DEV (x2);
@@ -287,10 +309,10 @@ void wxWindowDC::DoDrawArc( long x1, long y1, long x2, long y2, long xc, long yc
     int xxc_2 = XLOG2DEV_2 (xc);
     int yyc_2 = YLOG2DEV_2 (yc);
 
-    long dx = xx1 - xxc;
-    long dy = yy1 - yyc;
-    double radius = sqrt (dx * dx + dy * dy);
-    long r = (long) radius;
+    wxCoord dx = xx1 - xxc;
+    wxCoord dy = yy1 - yyc;
+    double radius = sqrt ((double)(dx * dx + dy * dy));
+    wxCoord r = (wxCoord) radius;
 
     double radius1, radius2;
 
@@ -355,7 +377,7 @@ void wxWindowDC::DoDrawArc( long x1, long y1, long x2, long y2, long xc, long yc
     CalcBoundingBox (x2, y2);
 }
 
-void wxWindowDC::DoDrawEllipticArc( long x, long y, long width, long height, double sa, double ea )
+void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double sa, double ea )
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
@@ -400,12 +422,10 @@ void wxWindowDC::DoDrawEllipticArc( long x, long y, long width, long height, dou
     CalcBoundingBox (x + width, y + height);
 }
 
-void wxWindowDC::DoDrawPoint( long x, long y )
+void wxWindowDC::DoDrawPoint( wxCoord x, wxCoord y )
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
-    //  FreeGetPixelCache();
-
     if (m_pen.Ok() && m_autoSetting)
         SetPen (m_pen);
 
@@ -416,12 +436,10 @@ void wxWindowDC::DoDrawPoint( long x, long y )
     CalcBoundingBox (x, y);
 }
 
-void wxWindowDC::DoDrawLines( int n, wxPoint points[], long xoffset, long yoffset )
+void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset )
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
-    //  FreeGetPixelCache();
-
     if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         if (m_autoSetting)
@@ -451,12 +469,10 @@ void wxWindowDC::DoDrawLines( int n, wxPoint points[], long xoffset, long yoffse
 }
 
 void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
-                                long xoffset, long yoffset, int fillStyle )
+                                wxCoord xoffset, wxCoord yoffset, int fillStyle )
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
-    //  FreeGetPixelCache();
-
     XPoint *xpoints1 = new XPoint[n + 1];
     XPoint *xpoints2 = new XPoint[n + 1];
     int i;
@@ -504,12 +520,10 @@ void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
     delete[]xpoints2;
 }
 
-void wxWindowDC::DoDrawRectangle( long x, long y, long width, long height )
+void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
-    //  FreeGetPixelCache();
-
     int xd, yd, wfd, hfd, wd, hd;
 
     xd = XLOG2DEV(x);
@@ -549,12 +563,10 @@ void wxWindowDC::DoDrawRectangle( long x, long y, long width, long height )
     CalcBoundingBox (x + width, y + height);
 }
 
-void wxWindowDC::DoDrawRoundedRectangle( long x, long y, long width, long height, double radius )
+void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius )
 {
     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);
@@ -709,11 +721,9 @@ void wxWindowDC::DoDrawRoundedRectangle( long x, long y, long width, long height
     }
     CalcBoundingBox (x, y);
     CalcBoundingBox (x + width, y + height);
-
-
 }
 
-void wxWindowDC::DoDrawEllipse( long x, long y, long width, long height )
+void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
@@ -730,8 +740,6 @@ void wxWindowDC::DoDrawEllipse( long x, long y, long width, long height )
         width = - width ;
     }
 
-    //  FreeGetPixelCache();
-
     static const int angle = 23040;
 
     int xd, yd, wd, hd;
@@ -775,69 +783,13 @@ bool wxWindowDC::CanDrawBitmap() const
     return TRUE;
 }
 
-#if 0
-void wxWindowDC::DoDrawIcon( const wxIcon &icon, long x, long y)
-{
-    //  FreeGetPixelCache();
-
-    // 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 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));
-        }
-
-
-        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);
-    }
-    CalcBoundingBox (x, y);
-}
-#endif // 0
-
-// TODO: use scaled Blit e.g. as per John Price's implementation in Contrib/Utilities
-bool wxWindowDC::DoBlit( long xdest, long ydest, long width, long height,
-                         wxDC *source, long xsrc, long ysrc, int rop, bool useMask )
+// 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 )
 {
     wxCHECK_MSG( Ok(), FALSE, "invalid dc" );
 
@@ -845,13 +797,35 @@ bool wxWindowDC::DoBlit( long xdest, long ydest, long width, long height,
 
     wxASSERT_MSG( sourceDC, "Blit source DC must be wxWindowDC or derived class." );
 
-    //  FreeGetPixelCache();
+    // 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;
 
-    // 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);
+    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())
+            XSetBackground ((Display*) m_display,(GC) m_gcBacking,
+                            pixel);
+    }
+    if (m_textForegroundColour.Ok())
+    {
+        oldForegroundPixel = m_currentColour.GetPixel();
+
+        if( m_textForegroundColour.GetPixel() <= -1 )
+            CalculatePixel( m_textForegroundColour,
+                            m_textForegroundColour, TRUE);
+ 
+        int pixel = m_textForegroundColour.GetPixel();
+        if (pixel > -1)
+            SetForegroundPixelWithLogicalFunction(pixel);
+    }
 
     // Do bitmap scaling if necessary
 
@@ -859,6 +833,13 @@ bool wxWindowDC::DoBlit( long xdest, long ydest, long width, long height,
     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)))
@@ -868,10 +849,10 @@ bool wxWindowDC::DoBlit( long xdest, long ydest, long width, long height,
 
         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
         {
@@ -879,8 +860,8 @@ bool wxWindowDC::DoBlit( long xdest, long ydest, long width, long height,
             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
@@ -912,9 +893,9 @@ bool wxWindowDC::DoBlit( long xdest, long ydest, long width, long height,
             {
                 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));
                 }
             }
@@ -929,12 +910,19 @@ bool wxWindowDC::DoBlit( long xdest, long ydest, long width, long height,
 
             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
@@ -961,9 +949,9 @@ bool wxWindowDC::DoBlit( long xdest, long ydest, long width, long height,
             {
                 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));
                 }
             }
@@ -991,7 +979,12 @@ bool wxWindowDC::DoBlit( long xdest, long ydest, long width, long height,
             }
             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);
             }
 
@@ -1001,16 +994,29 @@ bool wxWindowDC::DoBlit( long xdest, long ydest, long width, long height,
 
         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, long x, long y )
+void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
 {
     wxCHECK_RET( Ok(), "invalid dc" );
 
@@ -1020,6 +1026,18 @@ void wxWindowDC::DoDrawText( const wxString &text, long x, long y )
     int ascent = 0;
     int slen;
 
+    // Set FillStyle, otherwise X will use current stipple!
+    XGCValues gcV, gcBackingV;
+
+    XGetGCValues ((Display*) m_display, (GC)m_gc, GCFillStyle, &gcV);
+    XSetFillStyle ((Display*) m_display, (GC) m_gc, FillSolid);
+    if (m_window && m_window->GetBackingPixmap())
+    {
+        XGetGCValues ((Display*) m_display, (GC)m_gcBacking, GCFillStyle,
+                      &gcBackingV );
+        XSetFillStyle ((Display*) m_display, (GC) m_gcBacking, FillSolid);
+    }
+
     slen = strlen(text);
 
     if (m_font.Ok())
@@ -1033,7 +1051,9 @@ void wxWindowDC::DoDrawText( const wxString &text, long x, long y )
             &ascent, &descent, &overall_return);
         else
 #endif // 0
-            (void)XTextExtents((XFontStruct*) pFontStruct, (char*) (const char*) text, slen, &direction,
+            (void)XTextExtents((XFontStruct*) pFontStruct,
+                               wxConstCast(text.c_str(), char),
+                               slen, &direction,
                                &ascent, &descent, &overall_return);
 
         cx = overall_return.width;
@@ -1091,34 +1111,8 @@ void wxWindowDC::DoDrawText( const wxString &text, long x, long y )
 
         if (!sameColour || !GetOptimization())
         {
-            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)
@@ -1151,22 +1145,186 @@ void wxWindowDC::DoDrawText( const wxString &text, long x, long y )
         else
 #endif // 0
             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);
     }
 
-    long w, h;
+    // 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 )
+{
+    if (angle == 0.0)
+    {
+        DrawText(text, x, y);
+        return;
+    }
+
+    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 = 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;
+    }
+
+    wxBitmap src(cx, cy);
+    wxMemoryDC dc;
+    dc.SelectObject(src);
+    dc.SetFont(GetFont());
+    dc.SetBackground(*wxWHITE_BRUSH);
+    dc.SetBrush(*wxBLACK_BRUSH);
+    dc.Clear();
+    dc.DrawText(text, 0, 0);
+    dc.SetFont(wxNullFont);
+
+    // 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 y4 = cy * dx;
+    double x3 = cx * dx;
+    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.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);
+            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 (textPixel && !lastFore)
+                {
+                    XSetForeground ((Display*) m_display, (GC) m_gc,
+                                    foregroundPixel);
+                    lastFore = true;
+                    lastBack = false;
+                }
+                else if (!textPixel && !lastBack)
+                {
+                    XSetForeground ((Display*) m_display, (GC) m_gc,
+                                    backgroundPixel);
+                    lastFore = false;
+                    lastBack = true;
+                }
+
+                XDrawPoint ((Display*) m_display, (Pixmap) m_pixmap,
+                            (GC) m_gc, XLOG2DEV (ox), YLOG2DEV (oy));
+                if (m_window && m_window->GetBackingPixmap())
+                    XDrawPoint ((Display*) m_display,
+                                (Pixmap) m_window->GetBackingPixmap(),
+                                (GC) m_gcBacking,
+                                XLOG2DEV_2 (ox), YLOG2DEV_2 (oy));
+            }
+        }
+    }
+
+    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);
+    }
+
+    CalcBoundingBox (minx, miny);
+    CalcBoundingBox (maxx, maxy);
+}
+
 bool wxWindowDC::CanGetTextExtent() const
 {
     return TRUE;
 }
 
-void wxWindowDC::GetTextExtent( const wxString &string, long *width, long *height,
-                                long *descent, long *externalLeading,
+void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoord *height,
+                                wxCoord *descent, wxCoord *externalLeading,
                                 wxFont *font ) const
 {
     wxCHECK_RET( Ok(), "invalid dc" );
@@ -1180,8 +1338,8 @@ void wxWindowDC::GetTextExtent( const wxString &string, long *width, long *heigh
         // TODO: this should be an error log function
         wxFAIL_MSG("set a valid font before calling GetTextExtent!");
 
-        *width = -1;
-        *height = -1;
+        if (width) *width = -1;
+        if (height) *height = -1;
         return;
     }
 
@@ -1204,18 +1362,19 @@ void wxWindowDC::GetTextExtent( const wxString &string, long *width, long *heigh
         &ascent, &descent2, &overall);
     else
 #endif // 0
-        XTextExtents((XFontStruct*) pFontStruct, (char*) (const char*) string, slen, &direction,
+        XTextExtents((XFontStruct*) pFontStruct,
+                     wxConstCast(string.c_str(), char), slen, &direction,
         &ascent, &descent2, &overall);
 
-    *width = XDEV2LOGREL (overall.width);
-    *height = YDEV2LOGREL (ascent + descent2);
+    if (width) *width = XDEV2LOGREL (overall.width);
+    if (height) *height = YDEV2LOGREL (ascent + descent2);
     if (descent)
         *descent = descent2;
     if (externalLeading)
         *externalLeading = 0;
 }
 
-long wxWindowDC::GetCharWidth() const
+wxCoord wxWindowDC::GetCharWidth() const
 {
     wxCHECK_MSG( Ok(), 0, "invalid dc" );
     wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
@@ -1229,7 +1388,7 @@ long wxWindowDC::GetCharWidth() const
     return XDEV2LOGREL(overall.width);
 }
 
-long wxWindowDC::GetCharHeight() const
+wxCoord wxWindowDC::GetCharHeight() const
 {
     wxCHECK_MSG( Ok(), 0, "invalid dc" );
     wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
@@ -1244,42 +1403,31 @@ long wxWindowDC::GetCharHeight() const
     return XDEV2LOGREL(ascent + descent);
 }
 
-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( wxPoint( 0, 0 ), GetSize() );
+    Clear( rect );
 }
 
 void wxWindowDC::Clear(const wxRect& rect)
@@ -1292,10 +1440,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;
 }
@@ -1308,7 +1459,7 @@ void wxWindowDC::SetFont( const wxFont &font )
 
     if (!m_font.Ok())
     {
-        if ((m_oldFont != (WXFont) 0) && ((long) m_oldFont != -1))
+        if ((m_oldFont != (WXFont) 0) && ((wxCoord) m_oldFont != -1))
         {
             XSetFont ((Display*) m_display, (GC) m_gc, (Font) m_oldFont);
 
@@ -1327,6 +1478,67 @@ void wxWindowDC::SetFont( const wxFont &font )
         XSetFont ((Display*) m_display,(GC) m_gcBacking, fontId);
 }
 
+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 )
 {
     wxCHECK_RET( Ok(), "invalid dc" );
@@ -1342,7 +1554,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 ();
@@ -1352,7 +1564,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 ();
@@ -1380,15 +1592,15 @@ void wxWindowDC::SetPen( const wxPen &pen )
         int style;
         int join;
         int cap;
-        const static char dotted[] = {2, 5};
-        const static char short_dashed[] = {4, 4};
-        const static char long_dashed[] = {4, 8};
-        const static 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 ())
         {
@@ -1422,13 +1634,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;
@@ -1544,10 +1756,10 @@ void wxWindowDC::SetPen( const wxPen &pen )
     else if (m_currentStipple.Ok()
         && ((m_currentStipple != oldStipple) || !GetOptimization()))
     {
-        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())
@@ -1572,50 +1784,14 @@ void wxWindowDC::SetPen( const wxPen &pen )
         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());
@@ -1650,23 +1826,33 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
         (oldBrushColour.Green () == m_currentColour.Green ()) &&
         (oldBrushColour.GetPixel() == m_currentColour.GetPixel()));
 
+    int stippleDepth = -1;
+
     if ((oldFill != m_brush.GetStyle ()) || !GetOptimization())
     {
         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);
@@ -1676,7 +1862,8 @@ 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);
         }
     }
 
@@ -1737,74 +1924,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)
     {
-        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);
-            }
-
-            // 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);
-        }
+        int pixel = CalculatePixel(m_brush.GetColour(), m_currentColour, TRUE);
+ 
         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());
@@ -1819,21 +1966,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 )
@@ -1915,23 +2055,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 )
@@ -1954,57 +2085,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( long x, long y, long width, long height )
+void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y,
+                                      wxCoord width, wxCoord height )
 {
-    wxDC::SetClippingRegion( x, y, width, 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
@@ -2015,7 +2143,8 @@ void wxWindowDC::DoSetClippingRegion( long x, long y, long width, long height )
         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);
     }
 }
 
@@ -2023,15 +2152,9 @@ void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion& region )
 {
     wxRect box = region.GetBox();
 
-    wxDC::SetClippingRegion( 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);
+    wxDC::DoSetClippingRegion( box.x, box.y, box.width, box.height );
 
-    SetDCClipping ();
+    SetDCClipping(region.GetX11Region());
 
     // Needs to work differently for Pixmap: without this,
     // there's a nasty (Display*) m_display bug. 8/12/94
@@ -2042,7 +2165,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);
     }
 }
 
@@ -2051,21 +2175,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);
 }
 
@@ -2075,175 +2194,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(), _T("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
 
 
 
@@ -2253,48 +2203,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);
-
-    // 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);
 }
 
 // ----------------------------------------------------------------------------