VTK wrapper of vtkRenderWindow for wxPython. Tested on MSW so far.

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

diff --git a/src/motif/dcclient.cpp b/src/motif/dcclient.cpp
index d46aa227ff59b1ff904360fb4150593235e9a7ee..42ad9258d7681ebaefea5d2e1f35a581bc016fe6 100644 (file)
--- a/src/motif/dcclient.cpp
+++ b/src/motif/dcclient.cpp
@@ -6,37 +6,46 @@
 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart

-// Licence:       wxWindows licence
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 /*
 /////////////////////////////////////////////////////////////////////////////
 
 /*

-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.
-  
-    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 reinstall the current pen's parameters.
-    If autoSetting includes 0x2, then the pens color may need
-    to be set based on XOR.
-    
-      There is, unfortunately, some confusion between setting the
-      current pen/brush and actually installing the brush/pen parameters.
-      Both functionalies are perform by SetPen and SetBrush. C'est la vie.
+  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.
+
+  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
+  reinstall the current pen's parameters. If autoSetting includes 0x2, then the
+  pens color may need to be set based on XOR.
+
+  There is, unfortunately, some confusion between setting the current pen/brush
+  and actually installing the brush/pen parameters. Both functionalies are
+  perform by SetPen and SetBrush. C'est la vie.

 */
 
 */
 

+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+

 #ifdef __GNUG__
 #ifdef __GNUG__

-#pragma implementation "dcclient.h"
+    #pragma implementation "dcclient.h"

 #endif
 
 #include "wx/dcclient.h"
 #include "wx/dcmemory.h"
 #include "wx/window.h"
 #include "wx/app.h"
 #endif
 
 #include "wx/dcclient.h"
 #include "wx/dcmemory.h"
 #include "wx/window.h"
 #include "wx/app.h"

+#include "wx/image.h"
+

 #include <math.h>
 
 #include <Xm/Xm.h>
 #include <math.h>
 
 #include <Xm/Xm.h>


@@ -52,27 +61,46 @@ About pens, brushes, and the autoSetting flag:
 
 static Pixmap bdiag, cdiag, fdiag, cross, horiz, verti;
 
 
 static Pixmap bdiag, cdiag, fdiag, cross, horiz, verti;
 

-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------

 // constants
 // constants

-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------

 
 #define RAD2DEG 57.2957795131
 
 
 #define RAD2DEG 57.2957795131
 

-// Fudge factor. Obsolete?
-// No. Robert Roebling
+// Fudge factor (VZ: what??)

 #define WX_GC_CF 1
 
 #define WX_GC_CF 1
 

-//-----------------------------------------------------------------------------
-// wxWindowDC
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// macros
+// ----------------------------------------------------------------------------

 
 #if !USE_SHARED_LIBRARY
 
 #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)

 #endif
 
 #endif
 

-wxWindowDC::wxWindowDC(void)
+// ----------------------------------------------------------------------------
+// prototypes
+// ----------------------------------------------------------------------------
+
+static void XCopyRemote(Display *src_display, Display *dest_display,
+                        Drawable src, Drawable dest,
+                        GC destgc,
+                        int srcx, int srcy,
+                        unsigned int w, unsigned int h,
+                        int destx, int desty,
+                        bool more, XImage **cache);
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxWindowDC
+// ----------------------------------------------------------------------------
+
+wxWindowDC::wxWindowDC()

 {
     m_gc = (WXGC) 0;
     m_gcBacking = (WXGC) 0;
 {
     m_gc = (WXGC) 0;
     m_gcBacking = (WXGC) 0;


@@ -92,13 +120,14 @@ wxWindowDC::wxWindowDC(void)
     m_pixmap = (WXPixmap) 0;
     m_autoSetting = 0;
     m_oldFont = (WXFont) 0;
     m_pixmap = (WXPixmap) 0;
     m_autoSetting = 0;
     m_oldFont = (WXFont) 0;

-};
+}

 
 wxWindowDC::wxWindowDC( wxWindow *window )
 {
     wxASSERT_MSG( (window != (wxWindow*) NULL), "You must pass a valid wxWindow to wxWindowDC/wxClientDC/wxPaintDC constructor." );
 
 wxWindowDC::wxWindowDC( wxWindow *window )
 {
     wxASSERT_MSG( (window != (wxWindow*) NULL), "You must pass a valid wxWindow to wxWindowDC/wxClientDC/wxPaintDC constructor." );

-    
+

     m_window = window;
     m_window = window;

+    m_font = window->GetFont();

     m_gc = (WXGC) 0;
     m_gcBacking = (WXGC) 0;
     m_backgroundPixel = -1;
     m_gc = (WXGC) 0;
     m_gcBacking = (WXGC) 0;
     m_backgroundPixel = -1;


@@ -114,13 +143,13 @@ wxWindowDC::wxWindowDC( wxWindow *window )
     m_userRegion = (WXRegion) 0;
     m_ok = TRUE;
     m_autoSetting = 0;
     m_userRegion = (WXRegion) 0;
     m_ok = TRUE;
     m_autoSetting = 0;

-    
+

     m_display = window->GetXDisplay();
     m_pixmap = window->GetXWindow();
     Display* display = (Display*) m_display;
     m_display = window->GetXDisplay();
     m_pixmap = window->GetXWindow();
     Display* display = (Display*) m_display;

-    
+

     XSetWindowColormap (display, (Pixmap) m_pixmap, (Colormap) wxTheApp->GetMainColormap(m_display));
     XSetWindowColormap (display, (Pixmap) m_pixmap, (Colormap) wxTheApp->GetMainColormap(m_display));

-    
+

     XGCValues gcvalues;
     gcvalues.foreground = BlackPixel (display, DefaultScreen (display));
     gcvalues.background = WhitePixel (display, DefaultScreen (display));
     XGCValues gcvalues;
     gcvalues.foreground = BlackPixel (display, DefaultScreen (display));
     gcvalues.background = WhitePixel (display, DefaultScreen (display));


@@ -129,7 +158,7 @@ wxWindowDC::wxWindowDC( wxWindow *window )
     m_gc = (WXGC) XCreateGC (display, RootWindow (display, DefaultScreen (display)),
         GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth,
         &gcvalues);
     m_gc = (WXGC) XCreateGC (display, RootWindow (display, DefaultScreen (display)),
         GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth,
         &gcvalues);

-    
+

     if (m_window->GetBackingPixmap())
     {
         m_gcBacking = (WXGC) XCreateGC (display, RootWindow (display,
     if (m_window->GetBackingPixmap())
     {
         m_gcBacking = (WXGC) XCreateGC (display, RootWindow (display,


@@ -137,88 +166,91 @@ wxWindowDC::wxWindowDC( wxWindow *window )
             GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth,
             &gcvalues);
     }
             GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth,
             &gcvalues);
     }

-    
+

     m_backgroundPixel = (int) gcvalues.background;
     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;
     // 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;

-};

 
 

-wxWindowDC::~wxWindowDC(void)
+    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_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_window && m_window->GetBackingPixmap())
             XSetFont ((Display*) m_display,(GC) m_gcBacking, (Font) m_oldFont);
     }

-    
+

     if (m_gc)
         XFreeGC ((Display*) m_display, (GC) m_gc);
     m_gc = (WXGC) 0;
     if (m_gc)
         XFreeGC ((Display*) m_display, (GC) m_gc);
     m_gc = (WXGC) 0;

-    
+

     if (m_gcBacking)
         XFreeGC ((Display*) m_display, (GC) m_gcBacking);
     m_gcBacking = (WXGC) 0;
     if (m_gcBacking)
         XFreeGC ((Display*) m_display, (GC) m_gcBacking);
     m_gcBacking = (WXGC) 0;

-    
+

     if (m_currentRegion)
         XDestroyRegion ((Region) m_currentRegion);
     m_currentRegion = (WXRegion) 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_userRegion)
         XDestroyRegion ((Region) m_userRegion);
     m_userRegion = (WXRegion) 0;

-};
+}

 
 

-void wxWindowDC::FloodFill( long WXUNUSED(x1), long WXUNUSED(y1), 
+void wxWindowDC::DoFloodFill( wxCoord WXUNUSED(x1), wxCoord WXUNUSED(y1),

                            const wxColour& WXUNUSED(col), int WXUNUSED(style) )
 {
                            const wxColour& WXUNUSED(col), int WXUNUSED(style) )
 {

-    // TODO
-};
+    wxFAIL_MSG("not implemented");
+}

 
 

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

 {
 {

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

     return FALSE;
     return FALSE;

-};
+}

 
 

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

 {
 {

-    if (!Ok()) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+

     int x1d, y1d, x2d, y2d;
     int x1d, y1d, x2d, y2d;

-    
+

     //  FreeGetPixelCache();
     //  FreeGetPixelCache();

-    
+

     x1d = XLOG2DEV(x1);
     y1d = YLOG2DEV(y1);
     x2d = XLOG2DEV(x2);
     y2d = YLOG2DEV(y2);
     x1d = XLOG2DEV(x1);
     y1d = YLOG2DEV(y1);
     x2d = XLOG2DEV(x2);
     y2d = YLOG2DEV(y2);

-    
+

     if (m_autoSetting)
         SetPen (m_pen);
     if (m_autoSetting)
         SetPen (m_pen);

-    
+

     XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, x1d, y1d, x2d, y2d);
     XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, x1d, y1d, x2d, y2d);

-    
+

     if (m_window && m_window->GetBackingPixmap())
     if (m_window && m_window->GetBackingPixmap())

-        XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking, 
+        XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,

         XLOG2DEV_2(x1), YLOG2DEV_2(y1),
         XLOG2DEV_2(x2), YLOG2DEV_2(y2));
         XLOG2DEV_2(x1), YLOG2DEV_2(y1),
         XLOG2DEV_2(x2), YLOG2DEV_2(y2));

-    
+

     CalcBoundingBox(x1, y1);
     CalcBoundingBox(x2, y2);
     CalcBoundingBox(x1, y1);
     CalcBoundingBox(x2, y2);

-};
+}

 
 

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

 {
 {

-    if (!Ok()) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+

     if (m_autoSetting)
         SetPen (m_pen);
     if (m_autoSetting)
         SetPen (m_pen);

-    
+

     int xx = XLOG2DEV (x);
     int yy = YLOG2DEV (y);
     int ww, hh;
     int xx = XLOG2DEV (x);
     int yy = YLOG2DEV (y);
     int ww, hh;


@@ -227,7 +259,7 @@ void wxWindowDC::CrossHair( long x, long y )
         ww, yy);
     XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xx, 0,
         xx, hh);
         ww, yy);
     XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xx, 0,
         xx, hh);

-    
+

     if (m_window && m_window->GetBackingPixmap())
     {
         xx = XLOG2DEV_2 (x);
     if (m_window && m_window->GetBackingPixmap())
     {
         xx = XLOG2DEV_2 (x);


@@ -239,14 +271,14 @@ void wxWindowDC::CrossHair( long x, long y )
             xx, 0,
             xx, hh);
     }
             xx, 0,
             xx, hh);
     }

-};
+}

 
 

-void wxWindowDC::DrawArc( 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 )

 {
 {

-    if (!Ok()) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+

     //  FreeGetPixelCache();
     //  FreeGetPixelCache();

-    
+

     int xx1 = XLOG2DEV (x1);
     int yy1 = YLOG2DEV (y1);
     int xx2 = XLOG2DEV (x2);
     int xx1 = XLOG2DEV (x1);
     int yy1 = YLOG2DEV (y1);
     int xx2 = XLOG2DEV (x2);


@@ -255,14 +287,14 @@ void wxWindowDC::DrawArc( long x1, long y1, long x2, long y2, long xc, long yc )
     int yyc = YLOG2DEV (yc);
     int xxc_2 = XLOG2DEV_2 (xc);
     int yyc_2 = YLOG2DEV_2 (yc);
     int yyc = YLOG2DEV (yc);
     int xxc_2 = XLOG2DEV_2 (xc);
     int yyc_2 = YLOG2DEV_2 (yc);

-    
-    long dx = xx1 - xxc;
-    long dy = yy1 - yyc;
+
+    wxCoord dx = xx1 - xxc;
+    wxCoord dy = yy1 - yyc;

     double radius = sqrt (dx * dx + dy * dy);
     double radius = sqrt (dx * dx + dy * dy);

-    long r = (long) radius;
-    
+    wxCoord r = (wxCoord) radius;
+

     double radius1, radius2;
     double radius1, radius2;

-    
+

     if (xx1 == xx2 && yy1 == yy2)
     {
         radius1 = 0.0;
     if (xx1 == xx2 && yy1 == yy2)
     {
         radius1 = 0.0;


@@ -279,7 +311,7 @@ void wxWindowDC::DrawArc( long x1, long y1, long x2, long y2, long xc, long yc )
                 radius1 = -90.0;
             else
                 radius1 = -atan2 ((double) (yy1 - yyc), (double) (xx1 - xxc)) * 360.0 / (2 * M_PI);
                 radius1 = -90.0;
             else
                 radius1 = -atan2 ((double) (yy1 - yyc), (double) (xx1 - xxc)) * 360.0 / (2 * M_PI);

-            
+

             if (xx2 - xxc == 0)
                 if (yy2 - yyc < 0)
                     radius2 = 90.0;
             if (xx2 - xxc == 0)
                 if (yy2 - yyc < 0)
                     radius2 = 90.0;


@@ -296,45 +328,45 @@ void wxWindowDC::DrawArc( long x1, long y1, long x2, long y2, long xc, long yc )
         alpha2 += 360 * 64;
     while (alpha2 > 360 * 64)
         alpha2 -= 360 * 64;
         alpha2 += 360 * 64;
     while (alpha2 > 360 * 64)
         alpha2 -= 360 * 64;

-    
+

     if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
     {
         SetBrush (m_brush);
         XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) (GC) m_gc,
             xxc - r, yyc - r, 2 * r, 2 * r, alpha1, alpha2);
     if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
     {
         SetBrush (m_brush);
         XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) (GC) m_gc,
             xxc - r, yyc - r, 2 * r, 2 * r, alpha1, alpha2);

-        
+

         if (m_window && m_window->GetBackingPixmap())
             XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
             xxc_2 - r, yyc_2 - r, 2 * r, 2 * r, alpha1, alpha2);
         if (m_window && m_window->GetBackingPixmap())
             XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
             xxc_2 - r, yyc_2 - r, 2 * r, 2 * r, alpha1, alpha2);

-        
+

     }
     }

-    
+

     if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         if (m_autoSetting)
             SetPen (m_pen);
         XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc,
             xxc - r, yyc - r, 2 * r, 2 * r, alpha1, alpha2);
     if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         if (m_autoSetting)
             SetPen (m_pen);
         XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc,
             xxc - r, yyc - r, 2 * r, 2 * r, alpha1, alpha2);

-        
+

         if (m_window && m_window->GetBackingPixmap())
             XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
             xxc_2 - r, yyc_2 - r, 2 * r, 2 * r, alpha1, alpha2);
     }
     CalcBoundingBox (x1, y1);
     CalcBoundingBox (x2, y2);
         if (m_window && m_window->GetBackingPixmap())
             XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
             xxc_2 - r, yyc_2 - r, 2 * r, 2 * r, alpha1, alpha2);
     }
     CalcBoundingBox (x1, y1);
     CalcBoundingBox (x2, y2);

-};
+}

 
 

-void wxWindowDC::DrawEllipticArc( 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 )

 {
 {

-    if (!Ok()) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+

     int xd, yd, wd, hd;
     int xd, yd, wd, hd;

-    
+

     xd = XLOG2DEV(x);
     yd = YLOG2DEV(y);
     wd = XLOG2DEVREL(width);
     hd = YLOG2DEVREL(height);
     xd = XLOG2DEV(x);
     yd = YLOG2DEV(y);
     wd = XLOG2DEVREL(width);
     hd = YLOG2DEVREL(height);

-    
+

     if (sa>=360 || sa<=-360) sa=sa-int(sa/360)*360;
     if (ea>=360 || ea<=-360) ea=ea-int(ea/360)*360;
     int start = int(sa*64);
     if (sa>=360 || sa<=-360) sa=sa-int(sa/360)*360;
     if (ea>=360 || ea<=-360) ea=ea-int(ea/360)*360;
     int start = int(sa*64);


@@ -343,19 +375,19 @@ void wxWindowDC::DrawEllipticArc( long x, long y, long width, long height, doubl
     if (end  <0) end  +=360*64;
     if (end>start) end-=start;
     else end+=360*64-start;
     if (end  <0) end  +=360*64;
     if (end>start) end-=start;
     else end+=360*64-start;

-    
+

     if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
     {
         m_autoSetting = TRUE;    // must be reset
     if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
     {
         m_autoSetting = TRUE;    // must be reset

-        
+

         SetBrush (m_brush);
         XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, start, end);
         SetBrush (m_brush);
         XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, start, end);

-        
+

         if (m_window && m_window->GetBackingPixmap())
             XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
             XLOG2DEV_2 (x), YLOG2DEV_2 (y),wd,hd,start,end);
     }
         if (m_window && m_window->GetBackingPixmap())
             XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
             XLOG2DEV_2 (x), YLOG2DEV_2 (y),wd,hd,start,end);
     }

-    
+

     if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         if (m_autoSetting)
     if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         if (m_autoSetting)


@@ -367,45 +399,45 @@ void wxWindowDC::DrawEllipticArc( long x, long y, long width, long height, doubl
     }
     CalcBoundingBox (x, y);
     CalcBoundingBox (x + width, y + height);
     }
     CalcBoundingBox (x, y);
     CalcBoundingBox (x + width, y + height);

-};
+}

 
 

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

 {
 {

-    if (!Ok()) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+

     //  FreeGetPixelCache();
     //  FreeGetPixelCache();

-    
+

     if (m_pen.Ok() && m_autoSetting)
         SetPen (m_pen);
     if (m_pen.Ok() && m_autoSetting)
         SetPen (m_pen);

-    
+

     XDrawPoint ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y));
     if (m_window && m_window->GetBackingPixmap())
         XDrawPoint ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, XLOG2DEV_2 (x), YLOG2DEV_2 (y));
     XDrawPoint ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y));
     if (m_window && m_window->GetBackingPixmap())
         XDrawPoint ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, XLOG2DEV_2 (x), YLOG2DEV_2 (y));

-    
+

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

-};
+}

 
 

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

 {
 {

-    if (!Ok()) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+

     //  FreeGetPixelCache();
     //  FreeGetPixelCache();

-    
+

     if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         if (m_autoSetting)
             SetPen (m_pen);
     if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         if (m_autoSetting)
             SetPen (m_pen);

-        
+

         XPoint *xpoints = new XPoint[n];
         int i;
         XPoint *xpoints = new XPoint[n];
         int i;

-        
+

         for (i = 0; i < n; i++)
         {
             xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
             xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
         }
         XDrawLines ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints, n, 0);
         for (i = 0; i < n; i++)
         {
             xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
             xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
         }
         XDrawLines ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints, n, 0);

-        
+

         if (m_window && m_window->GetBackingPixmap())
         {
             for (i = 0; i < n; i++)
         if (m_window && m_window->GetBackingPixmap())
         {
             for (i = 0; i < n; i++)


@@ -417,32 +449,15 @@ void wxWindowDC::DrawLines( int n, wxPoint points[], long xoffset, long yoffset
         }
         delete[]xpoints;
     }
         }
         delete[]xpoints;
     }

-};
+}

 
 

-void wxWindowDC::DrawLines( wxList *list, long xoffset, long yoffset )
+void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
+                                wxCoord xoffset, wxCoord yoffset, int fillStyle )

 {
 {

-    if (!Ok()) return;
-    
-    if (m_pen.GetStyle() == wxTRANSPARENT) return;
-    
-    int n = list->Number();
-    wxPoint *points = new wxPoint[n];
-    
-    int i = 0;
-    for(wxNode *node = list->First(); node; node = node->Next()) {
-        wxPoint *point = (wxPoint *)node->Data();
-        points[i].x = point->x;
-        points[i++].y = point->y;
-    }
-    DrawLines(n, points, xoffset, yoffset);
-    delete []points;
-};
+    wxCHECK_RET( Ok(), "invalid dc" );

 
 

-void wxWindowDC::DrawPolygon( int n, wxPoint points[],
-                             long xoffset, long yoffset, int fillStyle )
-{

     //  FreeGetPixelCache();
     //  FreeGetPixelCache();

-    
+

     XPoint *xpoints1 = new XPoint[n + 1];
     XPoint *xpoints2 = new XPoint[n + 1];
     int i;
     XPoint *xpoints1 = new XPoint[n + 1];
     XPoint *xpoints2 = new XPoint[n + 1];
     int i;


@@ -454,13 +469,13 @@ void wxWindowDC::DrawPolygon( int n, wxPoint points[],
         xpoints2[i].y = YLOG2DEV_2 (points[i].y + yoffset);
         CalcBoundingBox (points[i].x + xoffset, points[i].y + yoffset);
     }
         xpoints2[i].y = YLOG2DEV_2 (points[i].y + yoffset);
         CalcBoundingBox (points[i].x + xoffset, points[i].y + yoffset);
     }

-    
+

     // Close figure for XDrawLines (not needed for XFillPolygon)
     xpoints1[i].x = xpoints1[0].x;
     xpoints1[i].y = xpoints1[0].y;
     xpoints2[i].x = xpoints2[0].x;
     xpoints2[i].y = xpoints2[0].y;
     // Close figure for XDrawLines (not needed for XFillPolygon)
     xpoints1[i].x = xpoints1[0].x;
     xpoints1[i].y = xpoints1[0].y;
     xpoints2[i].x = xpoints2[0].x;
     xpoints2[i].y = xpoints2[0].y;

-    
+

     if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
     {
         SetBrush (m_brush);
     if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
     {
         SetBrush (m_brush);


@@ -475,75 +490,57 @@ void wxWindowDC::DrawPolygon( int n, wxPoint points[],
             XSetFillRule ((Display*) m_display,(GC) m_gcBacking, EvenOddRule);    // default mode
         }
     }
             XSetFillRule ((Display*) m_display,(GC) m_gcBacking, EvenOddRule);    // default mode
         }
     }

-    
+

     if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         if (m_autoSetting)
             SetPen (m_pen);
         XDrawLines ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints1, n + 1, 0);
     if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         if (m_autoSetting)
             SetPen (m_pen);
         XDrawLines ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints1, n + 1, 0);

-        
+

         if (m_window && m_window->GetBackingPixmap())
             XDrawLines ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, xpoints2, n + 1, 0);
     }
         if (m_window && m_window->GetBackingPixmap())
             XDrawLines ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, xpoints2, n + 1, 0);
     }

-    
+

     delete[]xpoints1;
     delete[]xpoints2;
     delete[]xpoints1;
     delete[]xpoints2;

-};
+}

 
 

-void wxWindowDC::DrawPolygon( wxList *list, long xoffset,
-                             long yoffset, int fillStyle )
+void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height )

 {
 {

-    if (!Ok()) return;
-    
-    int n = list->Number();
-    wxPoint *points = new wxPoint[n];
-    
-    int i = 0;
-    for(wxNode *node = list->First(); node; node = node->Next()) {
-        wxPoint *point = (wxPoint *)node->Data();
-        points[i].x = point->x;
-        points[i++].y = point->y;
-    }
-    DrawPolygon(n, points, xoffset, yoffset,fillStyle);
-    delete[] points;
-};
+    wxCHECK_RET( Ok(), "invalid dc" );

 
 

-void wxWindowDC::DrawRectangle( long x, long y, long width, long height )
-{
-    if (!Ok()) return;
-    

     //  FreeGetPixelCache();
     //  FreeGetPixelCache();

-    
+

     int xd, yd, wfd, hfd, wd, hd;
     int xd, yd, wfd, hfd, wd, hd;

-    
+

     xd = XLOG2DEV(x);
     yd = YLOG2DEV(y);
     wfd = XLOG2DEVREL(width);
     wd = wfd - WX_GC_CF;
     hfd = YLOG2DEVREL(height);
     hd = hfd - WX_GC_CF;
     xd = XLOG2DEV(x);
     yd = YLOG2DEV(y);
     wfd = XLOG2DEVREL(width);
     wd = wfd - WX_GC_CF;
     hfd = YLOG2DEVREL(height);
     hd = hfd - WX_GC_CF;

-    
+

     if (wfd == 0 || hfd == 0) return;
     if (wd < 0) { wd = - wd; xd = xd - wd; }
     if (hd < 0) { hd = - hd; yd = yd - hd; }
     if (wfd == 0 || hfd == 0) return;
     if (wd < 0) { wd = - wd; xd = xd - wd; }
     if (hd < 0) { hd = - hd; yd = yd - hd; }

-    
+

     if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
     {
         SetBrush (m_brush);
         XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wfd, hfd);
     if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
     {
         SetBrush (m_brush);
         XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wfd, hfd);

-        
+

         if (m_window && m_window->GetBackingPixmap())
             XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
             XLOG2DEV_2 (x), YLOG2DEV_2 (y),
             wfd, hfd);
     }
         if (m_window && m_window->GetBackingPixmap())
             XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
             XLOG2DEV_2 (x), YLOG2DEV_2 (y),
             wfd, hfd);
     }

-    
+

     if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         if (m_autoSetting)
             SetPen (m_pen);
         XDrawRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd);
     if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         if (m_autoSetting)
             SetPen (m_pen);
         XDrawRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd);

-        
+

         if (m_window && m_window->GetBackingPixmap())
             XDrawRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
             XLOG2DEV_2 (x), YLOG2DEV_2 (y),
         if (m_window && m_window->GetBackingPixmap())
             XDrawRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
             XLOG2DEV_2 (x), YLOG2DEV_2 (y),


@@ -551,27 +548,27 @@ void wxWindowDC::DrawRectangle( long x, long y, long width, long height )
     }
     CalcBoundingBox (x, y);
     CalcBoundingBox (x + width, y + height);
     }
     CalcBoundingBox (x, y);
     CalcBoundingBox (x + width, y + height);

-};
+}

 
 

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

 {
 {

-    if (!Ok()) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+

     //  FreeGetPixelCache();
     //  FreeGetPixelCache();

-    
+

     // If radius is negative, it's a proportion of the smaller dimension.
     // If radius is negative, it's a proportion of the smaller dimension.

-    
+

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

-    
+

     int xd = XLOG2DEV (x);
     int yd = YLOG2DEV (y);
     int rd = XLOG2DEVREL ((long) radius);
     int wd = XLOG2DEVREL (width) - WX_GC_CF;
     int hd = YLOG2DEVREL (height) - WX_GC_CF;
     int xd = XLOG2DEV (x);
     int yd = YLOG2DEV (y);
     int rd = XLOG2DEVREL ((long) radius);
     int wd = XLOG2DEVREL (width) - WX_GC_CF;
     int hd = YLOG2DEVREL (height) - WX_GC_CF;

-    
+

     int rw_d = rd * 2;
     int rh_d = rw_d;
     int rw_d = rd * 2;
     int rh_d = rw_d;

-    
+

     // If radius is zero use DrawRectangle() instead to avoid
     // X drawing errors with small radii
     if (rd == 0)
     // If radius is zero use DrawRectangle() instead to avoid
     // X drawing errors with small radii
     if (rd == 0)


@@ -579,10 +576,10 @@ void wxWindowDC::DrawRoundedRectangle( long x, long y, long width, long height,
         DrawRectangle( x, y, width, height );
         return;
     }
         DrawRectangle( x, y, width, height );
         return;
     }

-    
+

     // Draw nothing if transformed w or h is 0
     if (wd == 0 || hd == 0) return;
     // Draw nothing if transformed w or h is 0
     if (wd == 0 || hd == 0) return;

-    
+

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


@@ -590,32 +587,32 @@ void wxWindowDC::DrawRoundedRectangle( long x, long y, long width, long height,
         wd--;
         hd--;
     }
         wd--;
         hd--;
     }

-    
+

     // CMB: ensure dd is not larger than rectangle otherwise we
     // get an hour glass shape
     if (rw_d > wd) rw_d = wd;
     if (rw_d > hd) rw_d = hd;
     rd = rw_d / 2;
     // CMB: ensure dd is not larger than rectangle otherwise we
     // get an hour glass shape
     if (rw_d > wd) rw_d = wd;
     if (rw_d > hd) rw_d = hd;
     rd = rw_d / 2;

-    
+

     // For backing pixmap
     int xd2 = XLOG2DEV_2 (x);
     int yd2 = YLOG2DEV_2 (y);
     int rd2 = XLOG2DEVREL ((long) radius);
     int wd2 = XLOG2DEVREL (width) ;
     int hd2 = YLOG2DEVREL (height) ;
     // For backing pixmap
     int xd2 = XLOG2DEV_2 (x);
     int yd2 = YLOG2DEV_2 (y);
     int rd2 = XLOG2DEVREL ((long) radius);
     int wd2 = XLOG2DEVREL (width) ;
     int hd2 = YLOG2DEVREL (height) ;

-    
+

     int rw_d2 = rd2 * 2;
     int rh_d2 = rw_d2;
     int rw_d2 = rd2 * 2;
     int rh_d2 = rw_d2;

-    
+

     if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
     {
         SetBrush (m_brush);
     if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
     {
         SetBrush (m_brush);

-        
+

         XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd,
             wd - rw_d, hd);
         XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + rd,
             wd, hd - rh_d);
         XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd,
             wd - rw_d, hd);
         XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + rd,
             wd, hd - rh_d);

-        
+

         // Arcs start from 3 o'clock, positive angles anticlockwise
         // Top-left
         XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd,
         // Arcs start from 3 o'clock, positive angles anticlockwise
         // Top-left
         XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd,


@@ -632,14 +629,14 @@ void wxWindowDC::DrawRoundedRectangle( long x, long y, long width, long height,
         // Bottom-left
         XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + hd - rh_d,
             rw_d, rh_d, 180 * 64, 90 * 64);
         // Bottom-left
         XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + hd - rh_d,
             rw_d, rh_d, 180 * 64, 90 * 64);

-        
+

         if (m_window && m_window->GetBackingPixmap())
         {
             XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
                 xd2 + rd2, yd2, wd2 - rw_d2, hd2);
             XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
                 xd2, yd2 + rd2, wd2, hd2 - rh_d2);
         if (m_window && m_window->GetBackingPixmap())
         {
             XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
                 xd2 + rd2, yd2, wd2 - rw_d2, hd2);
             XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
                 xd2, yd2 + rd2, wd2, hd2 - rh_d2);

-            
+

             XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
                 xd2, yd2, rw_d2, rh_d2, 90 * 64, 90 * 64);
             XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
             XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
                 xd2, yd2, rw_d2, rh_d2, 90 * 64, 90 * 64);
             XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,


@@ -656,7 +653,7 @@ void wxWindowDC::DrawRoundedRectangle( long x, long y, long width, long height,
                 rw_d2, rh_d2, 180 * 64, 90 * 64);
         }
     }
                 rw_d2, rh_d2, 180 * 64, 90 * 64);
         }
     }

-    
+

     if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         SetPen (m_pen);
     if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         SetPen (m_pen);


@@ -664,7 +661,7 @@ void wxWindowDC::DrawRoundedRectangle( long x, long y, long width, long height,
             xd + wd - rd + 1, yd);
         XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd + hd,
             xd + wd - rd, yd + hd);
             xd + wd - rd + 1, yd);
         XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd + hd,
             xd + wd - rd, yd + hd);

-        
+

         XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + rd,
             xd, yd + hd - rd);
         XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd, yd + rd,
         XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + rd,
             xd, yd + hd - rd);
         XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd, yd + rd,


@@ -679,7 +676,7 @@ void wxWindowDC::DrawRoundedRectangle( long x, long y, long width, long height,
             rw_d, rh_d, 269 * 64, 92 * 64);
         XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + hd - rh_d,
             rw_d, rh_d, 180 * 64, 90 * 64);
             rw_d, rh_d, 269 * 64, 92 * 64);
         XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + hd - rh_d,
             rw_d, rh_d, 180 * 64, 90 * 64);

-        
+

         if (m_window && m_window->GetBackingPixmap())
         {
             XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
         if (m_window && m_window->GetBackingPixmap())
         {
             XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,


@@ -688,7 +685,7 @@ void wxWindowDC::DrawRoundedRectangle( long x, long y, long width, long height,
             XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
                 xd2 + rd2, yd2 + hd2,
                 xd2 + wd2 - rd2, yd2 + hd2);
             XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
                 xd2 + rd2, yd2 + hd2,
                 xd2 + wd2 - rd2, yd2 + hd2);

-            
+

             XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
                 xd2, yd2 + rd2,
                 xd2, yd2 + hd2 - rd2);
             XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
                 xd2, yd2 + rd2,
                 xd2, yd2 + hd2 - rd2);


@@ -713,38 +710,38 @@ void wxWindowDC::DrawRoundedRectangle( long x, long y, long width, long height,
     }
     CalcBoundingBox (x, y);
     CalcBoundingBox (x + width, y + height);
     }
     CalcBoundingBox (x, y);
     CalcBoundingBox (x + width, y + height);

-    
-    
-};

 
 

-void wxWindowDC::DrawEllipse( long x, long y, long width, long height )
+
+}
+
+void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )

 {
 {

-    if (!Ok()) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+

     // Check for negative width and height
     if (height < 0)
     {
         y = y + height;
         height = - height ;
     }
     // Check for negative width and height
     if (height < 0)
     {
         y = y + height;
         height = - height ;
     }

-    
+

     if (width < 0)
     {
         x = x + width;
         width = - width ;
     }
     if (width < 0)
     {
         x = x + width;
         width = - width ;
     }

-    
+

     //  FreeGetPixelCache();
     //  FreeGetPixelCache();

-    
+

     static const int angle = 23040;
     static const int angle = 23040;

-    
+

     int xd, yd, wd, hd;
     int xd, yd, wd, hd;

-    
+

     xd = XLOG2DEV(x);
     yd = YLOG2DEV(y);
     wd = XLOG2DEVREL(width) ;
     hd = YLOG2DEVREL(height) ;
     xd = XLOG2DEV(x);
     yd = YLOG2DEV(y);
     wd = XLOG2DEVREL(width) ;
     hd = YLOG2DEVREL(height) ;

-    
+

     if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
     {
         SetBrush (m_brush);
     if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
     {
         SetBrush (m_brush);


@@ -755,7 +752,7 @@ void wxWindowDC::DrawEllipse( long x, long y, long width, long height )
             XLOG2DEVREL (width) - WX_GC_CF,
             YLOG2DEVREL (height) - WX_GC_CF, 0, angle);
     }
             XLOG2DEVREL (width) - WX_GC_CF,
             YLOG2DEVREL (height) - WX_GC_CF, 0, angle);
     }

-    
+

     if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         if (m_autoSetting)
     if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         if (m_autoSetting)


@@ -769,106 +766,28 @@ void wxWindowDC::DrawEllipse( long x, long y, long width, long height )
     }
     CalcBoundingBox (x, y);
     CalcBoundingBox (x + width, y + height);
     }
     CalcBoundingBox (x, y);
     CalcBoundingBox (x + width, y + height);

-    
-};
-
-bool wxWindowDC::CanDrawBitmap(void) const
-{
-    return TRUE;
-};

 
 

-/* Used when copying between drawables on different (Display*) m_displays.
-Not very fast, but better than giving up.
-*/
+}

 
 

-static void XCopyRemote(Display *src_display, Display *dest_display,
-                        Drawable src, Drawable dest,
-                        GC destgc,
-                        int srcx, int srcy,
-                        unsigned int w, unsigned int h,
-                        int destx, int desty,
-                        bool more, XImage **cache)
+bool wxWindowDC::CanDrawBitmap() const

 {
 {

-    XImage *image, *destimage;
-    Colormap destcm, srccm;
-#define CACHE_SIZE 256
-    unsigned int i, j;
-    unsigned long cachesrc[CACHE_SIZE], cachedest[CACHE_SIZE];
-    int k, cache_pos, all_cache;
-    
-    if (!cache || !*cache)
-        image = XGetImage(src_display, src, srcx, srcy, w, h, AllPlanes, ZPixmap);
-    else
-        image = *cache;
-    
-    destimage = XGetImage(dest_display, dest, destx, desty, w, h, AllPlanes, ZPixmap);
-    
-    srccm = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) src_display);
-    destcm = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dest_display);
-    
-    cache_pos = 0;
-    all_cache = FALSE;
-    
-    for (i = 0; i < w; i++)
-        for (j = 0; j < h; j++) {
-            unsigned long pixel;
-            XColor xcol;
-            
-            pixel = XGetPixel(image, i, j);
-            for (k = cache_pos; k--; )
-                if (cachesrc[k] == pixel) {
-                    pixel = cachedest[k];
-                    goto install;
-                }
-                if (all_cache)
-                    for (k = CACHE_SIZE; k-- > cache_pos; )
-                        if (cachesrc[k] == pixel) {
-                            pixel = cachedest[k];
-                            goto install;
-                        }
-                        
-                        cachesrc[cache_pos] = xcol.pixel = pixel;
-                        XQueryColor(src_display, srccm, &xcol);
-                        if (!XAllocColor(dest_display, destcm, &xcol))
-                            xcol.pixel = 0;
-                        cachedest[cache_pos] = pixel = xcol.pixel;
-                        
-                        if (++cache_pos >= CACHE_SIZE) {
-                            cache_pos = 0;
-                            all_cache = TRUE;
-                        }
-                        
-install:
-                        XPutPixel(destimage, i, j, pixel);
-        }
-        
-        XPutImage(dest_display, dest, destgc, destimage, 0, 0, destx, desty, w, h);
-        XDestroyImage(destimage);
-        
-        if (more)
-            *cache = image;
-        else
-            XDestroyImage(image);
+    wxCHECK_MSG( Ok(), FALSE, "invalid dc" );
+
+    return TRUE;

 }
 
 }
 

-void wxWindowDC::DrawIcon( const wxIcon &icon, long x, long y)
-{
-    if (!Ok()) return;
-    
-    if (!icon.Ok()) return;
-    
-    DrawBitmap(icon, x, y, TRUE);  
-    

 #if 0
 #if 0

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

     //  FreeGetPixelCache();
     //  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);
     // 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();
     int width, height;
     Pixmap iconPixmap = (Pixmap) icon.GetPixmap();
     width = icon.GetWidth();


@@ -887,8 +806,8 @@ void wxWindowDC::DrawIcon( const wxIcon &icon, long x, long y)
                 0, 0, width, height,
                 (int) XLOG2DEV (x), (int) YLOG2DEV (y));
         }
                 0, 0, width, height,
                 (int) XLOG2DEV (x), (int) YLOG2DEV (y));
         }

-        
-        
+
+

         if (m_window && m_window->GetBackingPixmap())
         {
             if (icon.GetDepth() <= 1)
         if (m_window && m_window->GetBackingPixmap())
         {
             if (icon.GetDepth() <= 1)


@@ -914,42 +833,74 @@ void wxWindowDC::DrawIcon( const wxIcon &icon, long x, long y)
             (int) XLOG2DEV (x), (int) YLOG2DEV (y), FALSE, &cache);
     }
     CalcBoundingBox (x, y);
             (int) XLOG2DEV (x), (int) YLOG2DEV (y), FALSE, &cache);
     }
     CalcBoundingBox (x, y);

-#endif
-};
+}
+#endif // 0

 
 // TODO: use scaled Blit e.g. as per John Price's implementation in Contrib/Utilities
 
 // TODO: use scaled Blit e.g. as per John Price's implementation in Contrib/Utilities

-bool wxWindowDC::Blit( long xdest, long ydest, long width, long height,
-                      wxDC *source, long xsrc, long ysrc, int rop, bool useMask )
+bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
+                         wxDC *source, wxCoord xsrc, wxCoord ysrc, int rop, bool useMask )

 {
 {

-    if (!Ok()) return FALSE;
-    
-    wxASSERT_MSG( (source->IsKindOf(CLASSINFO(wxWindowDC))), "Blit source DC must be wxWindowDC or derived class." );
-    
-    wxWindowDC* sourceDC = (wxWindowDC*) source;
-    
+    wxCHECK_MSG( Ok(), FALSE, "invalid dc" );
+
+    wxWindowDC* sourceDC = wxDynamicCast(source, wxWindowDC);
+
+    wxASSERT_MSG( sourceDC, "Blit source DC must be wxWindowDC or derived class." );
+

     //  FreeGetPixelCache();
     //  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
+
+    // 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);
     // last selected background color. [::SetBackground]
     if (m_pen.Ok() && m_autoSetting)
         SetPen (m_pen);

-    
-    if (m_pixmap && sourceDC->m_pixmap)
+
+    // Do bitmap scaling if necessary
+
+    wxBitmap *scaledBitmap = (wxBitmap*) NULL;
+    Pixmap sourcePixmap = (Pixmap) NULL;
+    double scaleX, scaleY;
+    GetUserScale(& scaleX, & scaleY);
+
+    // Sorry, can't scale masks just yet
+    if (!useMask && (scaleX != 1.0 || scaleY != 1.0) && sourceDC->IsKindOf(CLASSINFO(wxMemoryDC)))
+    {
+        wxMemoryDC* memDC = (wxMemoryDC*) sourceDC;
+        wxBitmap& bitmap = memDC->GetBitmap();
+
+        wxASSERT_MSG( (bitmap.Ok()), "Bad source bitmap in wxWindowDC::Blit");
+
+        wxImage image(bitmap);
+        if (!image.Ok())
+        {
+            sourcePixmap = (Pixmap) bitmap.GetPixmap();
+        }
+        else
+        {
+            int scaledW = (int) (bitmap.GetWidth() * scaleX);
+            int scaledH = (int) (bitmap.GetHeight() * scaleY);
+
+            image = image.Scale(scaledW, scaledH);
+            scaledBitmap = new wxBitmap(image.ConvertToBitmap());
+            sourcePixmap = (Pixmap) scaledBitmap->GetPixmap();
+        }
+    }
+    else
+        sourcePixmap = (Pixmap) sourceDC->m_pixmap;
+
+    if (m_pixmap && sourcePixmap)

     {
         /* MATTHEW: [9] */
         int orig = m_logicalFunction;
     {
         /* MATTHEW: [9] */
         int orig = m_logicalFunction;

-        
+

         SetLogicalFunction (rop);
         SetLogicalFunction (rop);

-        
+

         if (m_display != sourceDC->m_display)
         {
             XImage *cache = NULL;
         if (m_display != sourceDC->m_display)
         {
             XImage *cache = NULL;

-            
+

             if (m_window && m_window->GetBackingPixmap())
                 XCopyRemote((Display*) sourceDC->m_display, (Display*) m_display,
             if (m_window && m_window->GetBackingPixmap())
                 XCopyRemote((Display*) sourceDC->m_display, (Display*) m_display,

-                (Pixmap) sourceDC->m_pixmap, (Pixmap) m_window->GetBackingPixmap(),
+                (Pixmap) sourcePixmap, (Pixmap) m_window->GetBackingPixmap(),

                 (GC) m_gcBacking,
                 source->LogicalToDeviceX (xsrc),
                 source->LogicalToDeviceY (ysrc),
                 (GC) m_gcBacking,
                 source->LogicalToDeviceX (xsrc),
                 source->LogicalToDeviceY (ysrc),


@@ -957,7 +908,7 @@ bool wxWindowDC::Blit( long xdest, long ydest, long width, long height,
                 source->LogicalToDeviceYRel(height),
                 XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest),
                 TRUE, &cache);
                 source->LogicalToDeviceYRel(height),
                 XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest),
                 TRUE, &cache);

-            
+

             if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
             {
                 wxMemoryDC *memDC = (wxMemoryDC *)source;
             if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
             {
                 wxMemoryDC *memDC = (wxMemoryDC *)source;


@@ -968,21 +919,21 @@ bool wxWindowDC::Blit( long xdest, long ydest, long width, long height,
                     XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
                 }
             }
                     XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
                 }
             }

-            
-            XCopyRemote((Display*) sourceDC->m_display, (Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_pixmap, (GC) m_gc,
+
+            XCopyRemote((Display*) sourceDC->m_display, (Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_pixmap, (GC) m_gc,

                 source->LogicalToDeviceX (xsrc),
                 source->LogicalToDeviceY (ysrc),
                 source->LogicalToDeviceXRel(width),
                 source->LogicalToDeviceYRel(height),
                 XLOG2DEV (xdest), YLOG2DEV (ydest),
                 FALSE, &cache);
                 source->LogicalToDeviceX (xsrc),
                 source->LogicalToDeviceY (ysrc),
                 source->LogicalToDeviceXRel(width),
                 source->LogicalToDeviceYRel(height),
                 XLOG2DEV (xdest), YLOG2DEV (ydest),
                 FALSE, &cache);

-            
+

             if ( useMask )
             {
                 XSetClipMask   ((Display*) m_display, (GC) m_gc, None);
                 XSetClipOrigin ((Display*) m_display, (GC) m_gc, 0, 0);
             }
             if ( useMask )
             {
                 XSetClipMask   ((Display*) m_display, (GC) m_gc, None);
                 XSetClipOrigin ((Display*) m_display, (GC) m_gc, 0, 0);
             }

-            
+

         } else
         {
             if (m_window && m_window->GetBackingPixmap())
         } else
         {
             if (m_window && m_window->GetBackingPixmap())


@@ -990,7 +941,7 @@ bool wxWindowDC::Blit( long xdest, long ydest, long width, long height,
                 // +++ MARKUS (mho@comnets.rwth-aachen): error on blitting bitmaps with depth 1
                 if (source->IsKindOf(CLASSINFO(wxMemoryDC)) && ((wxMemoryDC*) source)->GetBitmap().GetDepth() == 1)
                 {
                 // +++ MARKUS (mho@comnets.rwth-aachen): error on blitting bitmaps with depth 1
                 if (source->IsKindOf(CLASSINFO(wxMemoryDC)) && ((wxMemoryDC*) source)->GetBitmap().GetDepth() == 1)
                 {

-                    XCopyPlane ((Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+                    XCopyPlane ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,

                         source->LogicalToDeviceX (xsrc),
                         source->LogicalToDeviceY (ysrc),
                         source->LogicalToDeviceXRel(width),
                         source->LogicalToDeviceX (xsrc),
                         source->LogicalToDeviceY (ysrc),
                         source->LogicalToDeviceXRel(width),


@@ -999,7 +950,7 @@ bool wxWindowDC::Blit( long xdest, long ydest, long width, long height,
                 }
                 else
                 {
                 }
                 else
                 {

-                    XCopyArea ((Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+                    XCopyArea ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,

                         source->LogicalToDeviceX (xsrc),
                         source->LogicalToDeviceY (ysrc),
                         source->LogicalToDeviceXRel(width),
                         source->LogicalToDeviceX (xsrc),
                         source->LogicalToDeviceY (ysrc),
                         source->LogicalToDeviceXRel(width),


@@ -1017,12 +968,12 @@ bool wxWindowDC::Blit( long xdest, long ydest, long width, long height,
                     XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
                 }
             }
                     XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
                 }
             }

-            
+

             // Check if we're copying from a mono bitmap
             if (source->IsKindOf(CLASSINFO(wxMemoryDC)) &&
                 ((wxMemoryDC*)source)->GetBitmap().Ok() && (((wxMemoryDC*)source)->GetBitmap().GetDepth () == 1))
             {
             // Check if we're copying from a mono bitmap
             if (source->IsKindOf(CLASSINFO(wxMemoryDC)) &&
                 ((wxMemoryDC*)source)->GetBitmap().Ok() && (((wxMemoryDC*)source)->GetBitmap().GetDepth () == 1))
             {

-                XCopyPlane ((Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_pixmap, (GC) m_gc,
+                XCopyPlane ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_pixmap, (GC) m_gc,

                     source->LogicalToDeviceX (xsrc),
                     source->LogicalToDeviceY (ysrc),
                     source->LogicalToDeviceXRel(width),
                     source->LogicalToDeviceX (xsrc),
                     source->LogicalToDeviceY (ysrc),
                     source->LogicalToDeviceXRel(width),


@@ -1031,77 +982,67 @@ bool wxWindowDC::Blit( long xdest, long ydest, long width, long height,
             }
             else
             {
             }
             else
             {

-                XCopyArea ((Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_pixmap, (GC) m_gc,
+                XCopyArea ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_pixmap, (GC) m_gc,

                     source->LogicalToDeviceX (xsrc),
                     source->LogicalToDeviceY (ysrc),
                     source->LogicalToDeviceXRel(width),
                     source->LogicalToDeviceYRel(height),
                     XLOG2DEV (xdest), YLOG2DEV (ydest));
                     source->LogicalToDeviceX (xsrc),
                     source->LogicalToDeviceY (ysrc),
                     source->LogicalToDeviceXRel(width),
                     source->LogicalToDeviceYRel(height),
                     XLOG2DEV (xdest), YLOG2DEV (ydest));

-                
+

             }
             if ( useMask )
             {
                 XSetClipMask   ((Display*) m_display, (GC) m_gc, None);
                 XSetClipOrigin ((Display*) m_display, (GC) m_gc, 0, 0);
             }
             }
             if ( useMask )
             {
                 XSetClipMask   ((Display*) m_display, (GC) m_gc, None);
                 XSetClipOrigin ((Display*) m_display, (GC) m_gc, 0, 0);
             }

-            
+

         } /* Remote/local (Display*) m_display */
         CalcBoundingBox (xdest, ydest);
         CalcBoundingBox (xdest + width, ydest + height);
         } /* Remote/local (Display*) m_display */
         CalcBoundingBox (xdest, ydest);
         CalcBoundingBox (xdest + width, ydest + height);

-        
+

         SetLogicalFunction(orig);
         SetLogicalFunction(orig);

-        
+
+        if (scaledBitmap) delete scaledBitmap;
+

         return TRUE;
   }
         return TRUE;
   }

-  return FALSE;
-};
+  if (scaledBitmap) delete scaledBitmap;

 
 

-/* Helper function for 16-bit fonts */
-static int str16len(const char *s)
-{
-    int count = 0;
-    
-    while (s[0] && s[1]) {
-        count++;
-        s += 2;
-    }
-    
-    return count;
+  return FALSE;

 }
 
 }
 

-void wxWindowDC::DrawText( const wxString &text, long x, long y, bool use16 )
+void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )

 {
 {

-    if (!Ok()) return;
-    
-    // Since X draws from the baseline of the text, must
-    // add the text height
+    wxCHECK_RET( Ok(), "invalid dc" );
+
+    // Since X draws from the baseline of the text, must add the text height

     int cx = 0;
     int cy = 0;
     int ascent = 0;
     int slen;
     int cx = 0;
     int cy = 0;
     int ascent = 0;
     int slen;

-    
-    if (use16)
-        slen = str16len(text);
-    else
-        slen = strlen(text);
-    
+
+    slen = strlen(text);
+

     if (m_font.Ok())
     {
         WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
         int direction, descent;
         XCharStruct overall_return;
     if (m_font.Ok())
     {
         WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
         int direction, descent;
         XCharStruct overall_return;

+#if 0

         if (use16)
             (void)XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *)(const char*) text, slen, &direction,
             &ascent, &descent, &overall_return);
         else
         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,
             (void)XTextExtents((XFontStruct*) pFontStruct, (char*) (const char*) text, slen, &direction,

-            &ascent, &descent, &overall_return);
+                               &ascent, &descent, &overall_return);
+

         cx = overall_return.width;
         cy = ascent + descent;
     }
         cx = overall_return.width;
         cy = ascent + descent;
     }

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

     if (m_textBackgroundColour.Ok () && (m_backgroundMode != wxTRANSPARENT))
     {
         wxColour oldPenColour = m_currentColour;
     if (m_textBackgroundColour.Ok () && (m_backgroundMode != wxTRANSPARENT))
     {
         wxColour oldPenColour = m_currentColour;


@@ -1110,17 +1051,17 @@ void wxWindowDC::DrawText( const wxString &text, long x, long y, bool use16 )
             (oldPenColour.Red () == m_textBackgroundColour.Red ()) &&
             (oldPenColour.Blue () == m_textBackgroundColour.Blue ()) &&
             (oldPenColour.Green () == m_textBackgroundColour.Green ()));
             (oldPenColour.Red () == m_textBackgroundColour.Red ()) &&
             (oldPenColour.Blue () == m_textBackgroundColour.Blue ()) &&
             (oldPenColour.Green () == m_textBackgroundColour.Green ()));

-        
+

         // 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()));
         // 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;
         if (!sameColour || !GetOptimization())
         {
             int pixel = m_textBackgroundColour.AllocColour(m_display);
             m_currentColour = m_textBackgroundColour;

-            
+

             // Set the GC to the required colour
             if (pixel > -1)
             {
             // Set the GC to the required colour
             if (pixel > -1)
             {


@@ -1131,13 +1072,13 @@ void wxWindowDC::DrawText( const wxString &text, long x, long y, bool use16 )
         }
         else
             m_textBackgroundColour = oldPenColour ;
         }
         else
             m_textBackgroundColour = oldPenColour ;

-        
+

         XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y), cx, cy);
         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);
     }
         XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y), cx, cy);
         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);
     }

-    
+

     // Now set the text foreground and draw the text
     if (m_textForegroundColour.Ok ())
     {
     // Now set the text foreground and draw the text
     if (m_textForegroundColour.Ok ())
     {


@@ -1148,7 +1089,7 @@ void wxWindowDC::DrawText( const wxString &text, long x, long y, bool use16 )
             (oldPenColour.Blue () == m_currentColour.Blue ()) &&
             (oldPenColour.Green () == m_currentColour.Green ()) &&
             (oldPenColour.GetPixel() == m_currentColour.GetPixel()));
             (oldPenColour.Blue () == m_currentColour.Blue ()) &&
             (oldPenColour.Green () == m_currentColour.Green ()) &&
             (oldPenColour.GetPixel() == m_currentColour.GetPixel()));

-        
+

         if (!sameColour || !GetOptimization())
         {
             int pixel = -1;
         if (!sameColour || !GetOptimization())
         {
             int pixel = -1;


@@ -1179,7 +1120,7 @@ void wxWindowDC::DrawText( const wxString &text, long x, long y, bool use16 )
                 pixel = m_textForegroundColour.AllocColour((Display*) m_display);
                 m_currentColour.SetPixel(pixel);
             }
                 pixel = m_textForegroundColour.AllocColour((Display*) m_display);
                 m_currentColour.SetPixel(pixel);
             }

-            
+

             // Set the GC to the required colour
             if (pixel > -1)
             {
             // Set the GC to the required colour
             if (pixel > -1)
             {


@@ -1191,122 +1132,128 @@ void wxWindowDC::DrawText( const wxString &text, long x, long y, bool use16 )
         else
             m_textForegroundColour = oldPenColour;
     }
         else
             m_textForegroundColour = oldPenColour;
     }

-    
-    // We need to add the ascent, not the whole height, since X draws
-    // at the point above the descender.
+
+    // We need to add the ascent, not the whole height, since X draws at the
+    // point above the descender.
+#if 0

     if (use16)
     if (use16)

-        XDrawString16((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y) + ascent, 
+        XDrawString16((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y) + ascent,

         (XChar2b *)(char*) (const char*) text, slen);
     else
         (XChar2b *)(char*) (const char*) text, slen);
     else

-        XDrawString((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y) + ascent, 
-        text, slen);
-    
+#endif // 0
+        XDrawString((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y) + ascent, text, slen);
+

     if (m_window && m_window->GetBackingPixmap()) {
     if (m_window && m_window->GetBackingPixmap()) {

+#if 0

         if (use16)
             XDrawString16((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
             XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent,
             (XChar2b *)(char*) (const char*) text, slen);
         else
         if (use16)
             XDrawString16((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
             XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent,
             (XChar2b *)(char*) (const char*) text, slen);
         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);
     }
             XDrawString((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
             XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent, (char*) (const char*) text, slen);
     }

-    
-    long w, h;
+
+    wxCoord w, h;

     GetTextExtent (text, &w, &h);
     CalcBoundingBox (x + w, y + h);
     CalcBoundingBox (x, y);
     GetTextExtent (text, &w, &h);
     CalcBoundingBox (x + w, y + h);
     CalcBoundingBox (x, y);

-};
+}

 
 

-bool wxWindowDC::CanGetTextExtent(void) const
+bool wxWindowDC::CanGetTextExtent() const

 {
     return TRUE;
 {
     return TRUE;

-};
+}

 
 

-void wxWindowDC::GetTextExtent( const wxString &string, long *width, long *height,
-                               long *descent, long *externalLeading,
-                               wxFont *font, bool use16 )
+void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoord *height,
+                                wxCoord *descent, wxCoord *externalLeading,
+                                wxFont *font ) const

 {
 {

-    if (!Ok()) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+

     wxFont* theFont = font;
     if (!theFont)
     wxFont* theFont = font;
     if (!theFont)

-        theFont = & m_font;
-    
+        theFont = (wxFont *)&m_font; // const_cast
+

     if (!theFont->Ok())
     {
         // TODO: this should be an error log function
         wxFAIL_MSG("set a valid font before calling GetTextExtent!");
     if (!theFont->Ok())
     {
         // 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;
     }
         return;
     }

-    
+

     WXFontStructPtr pFontStruct = theFont->GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
     WXFontStructPtr pFontStruct = theFont->GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);

-    
+

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

-    
-    if (use16) slen = str16len(string); else slen = strlen(string);
-    
+
+#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
     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);
         XTextExtents((XFontStruct*) pFontStruct, (char*) (const char*) string, 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;
     if (descent)
         *descent = descent2;
     if (externalLeading)
         *externalLeading = 0;

-};
+}

 
 

-long wxWindowDC::GetCharWidth(void)
+wxCoord wxWindowDC::GetCharWidth() const

 {
 {

-    if (!Ok()) return 0;
-    
-    if (!m_font.Ok())
-        return 0;
-    
+    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);
     WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY * m_logicalScaleY, m_display);

-    
+

     int direction, ascent, descent;
     XCharStruct overall;
     XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
         &descent, &overall);
     return XDEV2LOGREL(overall.width);
     int direction, ascent, descent;
     XCharStruct overall;
     XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
         &descent, &overall);
     return XDEV2LOGREL(overall.width);

-};
+}

 
 

-long wxWindowDC::GetCharHeight(void)
+wxCoord wxWindowDC::GetCharHeight() const

 {
 {

-    if (!Ok()) return 0;
-    
-    if (!m_font.Ok())
-        return 0;
-    
+    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);
     WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);

-    
+

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

-};
+}

 
 

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

 {
 {

-    if (!Ok()) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+

     int w, h;
     if (m_window)
     {
         m_window->GetSize(&w, &h);
     int w, h;
     if (m_window)
     {
         m_window->GetSize(&w, &h);

-        
+

         if (m_window && m_window->GetBackingPixmap())
         {
             w = m_window->GetPixmapWidth();
         if (m_window && m_window->GetBackingPixmap())
         {
             w = m_window->GetPixmapWidth();


@@ -1324,71 +1271,71 @@ void wxWindowDC::Clear(void)
         else
             return;
     }
         else
             return;
     }

-    
+

     wxBrush saveBrush = m_brush;
     SetBrush (m_backgroundBrush);
     wxBrush saveBrush = m_brush;
     SetBrush (m_backgroundBrush);

-    
+

     XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, 0, 0, w, h);
     XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, 0, 0, w, h);

-    
+

     if (m_window && m_window->GetBackingPixmap())
         XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, 0, 0, w, h);
     if (m_window && m_window->GetBackingPixmap())
         XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, 0, 0, w, h);

-    
+

     m_brush = saveBrush;
     m_brush = saveBrush;

-};
+}

 
 void wxWindowDC::Clear(const wxRect& rect)
 {
 
 void wxWindowDC::Clear(const wxRect& rect)
 {

-    if (!Ok()) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+

     int x = rect.x; int y = rect.y;
     int w = rect.width; int h = rect.height;
     int x = rect.x; int y = rect.y;
     int w = rect.width; int h = rect.height;

-    
+

     wxBrush saveBrush = m_brush;
     SetBrush (m_backgroundBrush);
     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);
     if (m_window && m_window->GetBackingPixmap())
         XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, x, y, w, h);

-    
+

     m_brush = saveBrush;
     m_brush = saveBrush;

-};
+}

 
 void wxWindowDC::SetFont( const wxFont &font )
 {
 
 void wxWindowDC::SetFont( const wxFont &font )
 {

-    if (!Ok()) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+

     m_font = font;
     m_font = font;

-    
+

     if (!m_font.Ok())
     {
     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);
         {
             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 (m_window && m_window->GetBackingPixmap())
                 XSetFont ((Display*) m_display,(GC) m_gcBacking, (Font) m_oldFont);
         }
         return;
     }

-    
+

     WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
     WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);

-    
+

     Font fontId = ((XFontStruct*)pFontStruct)->fid;
     XSetFont ((Display*) m_display, (GC) m_gc, fontId);
     Font fontId = ((XFontStruct*)pFontStruct)->fid;
     XSetFont ((Display*) m_display, (GC) m_gc, fontId);

-    
+

     if (m_window && m_window->GetBackingPixmap())
         XSetFont ((Display*) m_display,(GC) m_gcBacking, fontId);
     if (m_window && m_window->GetBackingPixmap())
         XSetFont ((Display*) m_display,(GC) m_gcBacking, fontId);

-};
+}

 
 void wxWindowDC::SetPen( const wxPen &pen )
 {
 
 void wxWindowDC::SetPen( const wxPen &pen )
 {

-    if (!Ok()) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+

     m_pen = pen;
     if (!m_pen.Ok())
         return;
     m_pen = pen;
     if (!m_pen.Ok())
         return;

-    
+

     wxBitmap oldStipple = m_currentStipple;
     int oldStyle = m_currentStyle;
     int oldFill = m_currentFill;
     wxBitmap oldStipple = m_currentStipple;
     int oldStyle = m_currentStyle;
     int oldFill = m_currentFill;


@@ -1397,7 +1344,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
     int old_pen_cap = m_currentPenCap;
     int old_pen_nb_dash = m_currentPenDashCount;
     char *old_pen_dash = m_currentPenDash;
     int old_pen_cap = m_currentPenCap;
     int old_pen_nb_dash = m_currentPenDashCount;
     char *old_pen_dash = m_currentPenDash;

-    
+

     wxColour oldPenColour = m_currentColour;
     m_currentColour = m_pen.GetColour ();
     m_currentStyle = m_pen.GetStyle ();
     wxColour oldPenColour = m_currentColour;
     m_currentColour = m_pen.GetColour ();
     m_currentStyle = m_pen.GetStyle ();


@@ -1407,10 +1354,10 @@ void wxWindowDC::SetPen( const wxPen &pen )
     m_currentPenCap = m_pen.GetCap ();
     m_currentPenDashCount = m_pen.GetDashCount();
     m_currentPenDash = m_pen.GetDash();
     m_currentPenCap = m_pen.GetCap ();
     m_currentPenDashCount = m_pen.GetDashCount();
     m_currentPenDash = m_pen.GetDash();

-    
+

     if (m_currentStyle == wxSTIPPLE)
         m_currentStipple = * m_pen.GetStipple ();
     if (m_currentStyle == wxSTIPPLE)
         m_currentStipple = * m_pen.GetStipple ();

-    
+

     bool sameStyle = (oldStyle == m_currentStyle &&
         oldFill == m_currentFill &&
         old_pen_join == m_currentPenJoin &&
     bool sameStyle = (oldStyle == m_currentStyle &&
         oldFill == m_currentFill &&
         old_pen_join == m_currentPenJoin &&


@@ -1418,36 +1365,32 @@ void wxWindowDC::SetPen( const wxPen &pen )
         old_pen_nb_dash == m_currentPenDashCount &&
         old_pen_dash == m_currentPenDash &&
         old_pen_width == m_currentPenWidth);
         old_pen_nb_dash == m_currentPenDashCount &&
         old_pen_dash == m_currentPenDash &&
         old_pen_width == m_currentPenWidth);

-    
+

     bool sameColour = (oldPenColour.Ok () &&
         (oldPenColour.Red () == m_currentColour.Red ()) &&
         (oldPenColour.Blue () == m_currentColour.Blue ()) &&
         (oldPenColour.Green () == m_currentColour.Green ()) &&
         (oldPenColour.GetPixel() == m_currentColour.GetPixel()));
     bool sameColour = (oldPenColour.Ok () &&
         (oldPenColour.Red () == m_currentColour.Red ()) &&
         (oldPenColour.Blue () == m_currentColour.Blue ()) &&
         (oldPenColour.Green () == m_currentColour.Green ()) &&
         (oldPenColour.GetPixel() == m_currentColour.GetPixel()));

-    
+

     if (!sameStyle || !GetOptimization())
     {
         int scaled_width = (int) XLOG2DEVREL (m_pen.GetWidth ());
         if (scaled_width < 0)
             scaled_width = 0;
     if (!sameStyle || !GetOptimization())
     {
         int scaled_width = (int) XLOG2DEVREL (m_pen.GetWidth ());
         if (scaled_width < 0)
             scaled_width = 0;

-        
+

         int style;
         int join;
         int cap;
         int style;
         int join;
         int cap;

-        static char dotted[] =
-        {2, 5};
-        static char short_dashed[] =
-        {4, 4};
-        static char long_dashed[] =
-        {4, 8};
-        static char dotted_dashed[] =
-        {6, 6, 2, 6};
-        
+        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};
+

         // We express dash pattern in pen width unit, so we are
         // independent of zoom factor and so on...
         int req_nb_dash;
         // We express dash pattern in pen width unit, so we are
         // independent of zoom factor and so on...
         int req_nb_dash;

-        char *req_dash;
-        
+        const char *req_dash;
+

         switch (m_pen.GetStyle ())
         {
         case wxUSER_DASH:
         switch (m_pen.GetStyle ())
         {
         case wxUSER_DASH:


@@ -1483,7 +1426,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
             req_dash = NULL;
             req_nb_dash = 0;
         }
             req_dash = NULL;
             req_nb_dash = 0;
         }

-        
+

         if (req_dash && req_nb_dash)
         {
             char *real_req_dash = new char[req_nb_dash];
         if (req_dash && req_nb_dash)
         {
             char *real_req_dash = new char[req_nb_dash];


@@ -1493,7 +1436,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
                 for (int i = 0; i < req_nb_dash; i++)
                     real_req_dash[i] = req_dash[i] * factor;
                 XSetDashes ((Display*) m_display, (GC) m_gc, 0, real_req_dash, req_nb_dash);
                 for (int i = 0; i < req_nb_dash; i++)
                     real_req_dash[i] = req_dash[i] * factor;
                 XSetDashes ((Display*) m_display, (GC) m_gc, 0, real_req_dash, req_nb_dash);

-                
+

                 if (m_window && m_window->GetBackingPixmap())
                     XSetDashes ((Display*) m_display,(GC) m_gcBacking, 0, real_req_dash, req_nb_dash);
                 delete[]real_req_dash;
                 if (m_window && m_window->GetBackingPixmap())
                     XSetDashes ((Display*) m_display,(GC) m_gcBacking, 0, real_req_dash, req_nb_dash);
                 delete[]real_req_dash;


@@ -1502,12 +1445,12 @@ void wxWindowDC::SetPen( const wxPen &pen )
             {
                 // No Memory. We use non-scaled dash pattern...
                 XSetDashes ((Display*) m_display, (GC) m_gc, 0, req_dash, req_nb_dash);
             {
                 // No Memory. We use non-scaled dash pattern...
                 XSetDashes ((Display*) m_display, (GC) m_gc, 0, req_dash, req_nb_dash);

-                
+

                 if (m_window && m_window->GetBackingPixmap())
                     XSetDashes ((Display*) m_display,(GC) m_gcBacking, 0, req_dash, req_nb_dash);
             }
         }
                 if (m_window && m_window->GetBackingPixmap())
                     XSetDashes ((Display*) m_display,(GC) m_gcBacking, 0, req_dash, req_nb_dash);
             }
         }

-        
+

         switch (m_pen.GetCap ())
         {
         case wxCAP_PROJECTING:
         switch (m_pen.GetCap ())
         {
         case wxCAP_PROJECTING:


@@ -1521,7 +1464,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
             cap = (scaled_width <= 1) ? CapNotLast : CapRound;
             break;
         }
             cap = (scaled_width <= 1) ? CapNotLast : CapRound;
             break;
         }

-        
+

         switch (m_pen.GetJoin ())
         {
         case wxJOIN_BEVEL:
         switch (m_pen.GetJoin ())
         {
         case wxJOIN_BEVEL:


@@ -1535,19 +1478,19 @@ void wxWindowDC::SetPen( const wxPen &pen )
             join = JoinRound;
             break;
         }
             join = JoinRound;
             break;
         }

-        
+

         XSetLineAttributes ((Display*) m_display, (GC) m_gc, scaled_width, style, cap, join);
         XSetLineAttributes ((Display*) m_display, (GC) m_gc, scaled_width, style, cap, join);

-        
+

         if (m_window && m_window->GetBackingPixmap())
             XSetLineAttributes ((Display*) m_display,(GC) m_gcBacking, scaled_width, style, cap, join);
     }
         if (m_window && m_window->GetBackingPixmap())
             XSetLineAttributes ((Display*) m_display,(GC) m_gcBacking, scaled_width, style, cap, join);
     }

-    
+

     if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GetOptimization()))
     {
         Pixmap myStipple;
     if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GetOptimization()))
     {
         Pixmap myStipple;

-        
+

         oldStipple = wxNullBitmap;    // For later reset!!
         oldStipple = wxNullBitmap;    // For later reset!!

-        
+

         switch (m_currentFill)
         {
         case wxBDIAGONAL_HATCH:
         switch (m_currentFill)
         {
         case wxBDIAGONAL_HATCH:


@@ -1595,7 +1538,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
             break;
         }
         XSetStipple ((Display*) m_display, (GC) m_gc, myStipple);
             break;
         }
         XSetStipple ((Display*) m_display, (GC) m_gc, myStipple);

-        
+

         if (m_window && m_window->GetBackingPixmap())
             XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
     }
         if (m_window && m_window->GetBackingPixmap())
             XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
     }


@@ -1603,15 +1546,15 @@ void wxWindowDC::SetPen( const wxPen &pen )
         && ((m_currentStipple != oldStipple) || !GetOptimization()))
     {
         XSetStipple ((Display*) m_display, (GC) m_gc, (Pixmap) m_currentStipple.GetPixmap());
         && ((m_currentStipple != oldStipple) || !GetOptimization()))
     {
         XSetStipple ((Display*) m_display, (GC) m_gc, (Pixmap) m_currentStipple.GetPixmap());

-        
+

         if (m_window && m_window->GetBackingPixmap())
             XSetStipple ((Display*) m_display,(GC) m_gcBacking, (Pixmap) m_currentStipple.GetPixmap());
     }
         if (m_window && m_window->GetBackingPixmap())
             XSetStipple ((Display*) m_display,(GC) m_gcBacking, (Pixmap) m_currentStipple.GetPixmap());
     }

-    
+

     if ((m_currentFill != oldFill) || !GetOptimization())
     {
         int fill_style;
     if ((m_currentFill != oldFill) || !GetOptimization())
     {
         int fill_style;

-        
+

         if (m_currentFill == wxSTIPPLE)
             fill_style = FillStippled;
         else if (IS_HATCH (m_currentFill))
         if (m_currentFill == wxSTIPPLE)
             fill_style = FillStippled;
         else if (IS_HATCH (m_currentFill))


@@ -1622,7 +1565,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
         if (m_window && m_window->GetBackingPixmap())
             XSetFillStyle ((Display*) m_display,(GC) m_gcBacking, fill_style);
     }
         if (m_window && m_window->GetBackingPixmap())
             XSetFillStyle ((Display*) m_display,(GC) m_gcBacking, fill_style);
     }

-    
+

     // must test m_logicalFunction, because it involves background!
     if (!sameColour || !GetOptimization()
         || ((m_logicalFunction == wxXOR) || (m_autoSetting & 0x2)))
     // must test m_logicalFunction, because it involves background!
     if (!sameColour || !GetOptimization()
         || ((m_logicalFunction == wxXOR) || (m_autoSetting & 0x2)))


@@ -1655,7 +1598,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
             pixel = m_pen.GetColour ().AllocColour(m_display);
             m_currentColour.SetPixel(pixel);
         }
             pixel = m_pen.GetColour ().AllocColour(m_display);
             m_currentColour.SetPixel(pixel);
         }

-        
+

         // Finally, set the GC to the required colour
         if (pixel > -1)
         {
         // Finally, set the GC to the required colour
         if (pixel > -1)
         {


@@ -1677,37 +1620,37 @@ void wxWindowDC::SetPen( const wxPen &pen )
     }
     else
         m_pen.GetColour().SetPixel(oldPenColour.GetPixel());
     }
     else
         m_pen.GetColour().SetPixel(oldPenColour.GetPixel());

-    
+

     m_autoSetting = 0;
     m_autoSetting = 0;

-};
+}

 
 void wxWindowDC::SetBrush( const wxBrush &brush )
 {
 
 void wxWindowDC::SetBrush( const wxBrush &brush )
 {

-    if (!Ok()) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+

     m_brush = brush;
     m_brush = brush;

-    
+

     if (!m_brush.Ok() || m_brush.GetStyle () == wxTRANSPARENT)
         return;
     if (!m_brush.Ok() || m_brush.GetStyle () == wxTRANSPARENT)
         return;

-    
+

     int oldFill = m_currentFill;
     wxBitmap oldStipple = m_currentStipple;
     int oldFill = m_currentFill;
     wxBitmap oldStipple = m_currentStipple;

-    
+

     m_autoSetting |= 0x1;
     m_autoSetting |= 0x1;

-    
+

     m_currentFill = m_brush.GetStyle ();
     if (m_currentFill == wxSTIPPLE)
         m_currentStipple = * m_brush.GetStipple ();
     m_currentFill = m_brush.GetStyle ();
     if (m_currentFill == wxSTIPPLE)
         m_currentStipple = * m_brush.GetStipple ();

-    
+

     wxColour oldBrushColour(m_currentColour);
     m_currentColour = m_brush.GetColour ();
     wxColour oldBrushColour(m_currentColour);
     m_currentColour = m_brush.GetColour ();

-    
+

     bool sameColour = (oldBrushColour.Ok () &&
         (oldBrushColour.Red () == m_currentColour.Red ()) &&
         (oldBrushColour.Blue () == m_currentColour.Blue ()) &&
         (oldBrushColour.Green () == m_currentColour.Green ()) &&
         (oldBrushColour.GetPixel() == m_currentColour.GetPixel()));
     bool sameColour = (oldBrushColour.Ok () &&
         (oldBrushColour.Red () == m_currentColour.Red ()) &&
         (oldBrushColour.Blue () == m_currentColour.Blue ()) &&
         (oldBrushColour.Green () == m_currentColour.Green ()) &&
         (oldBrushColour.GetPixel() == m_currentColour.GetPixel()));

-    
+

     if ((oldFill != m_brush.GetStyle ()) || !GetOptimization())
     {
         switch (brush.GetStyle ())
     if ((oldFill != m_brush.GetStyle ()) || !GetOptimization())
     {
         switch (brush.GetStyle ())


@@ -1737,11 +1680,11 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
                 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()))
     {
         Pixmap myStipple;
     if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GetOptimization()))
     {
         Pixmap myStipple;

-        
+

         switch (m_currentFill)
         {
         case wxBDIAGONAL_HATCH:
         switch (m_currentFill)
         {
         case wxBDIAGONAL_HATCH:


@@ -1789,7 +1732,7 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
             break;
         }
         XSetStipple ((Display*) m_display, (GC) m_gc, myStipple);
             break;
         }
         XSetStipple ((Display*) m_display, (GC) m_gc, myStipple);

-        
+

         if (m_window && m_window->GetBackingPixmap())
             XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
     }
         if (m_window && m_window->GetBackingPixmap())
             XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
     }


@@ -1801,7 +1744,7 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
         if (m_window && m_window->GetBackingPixmap())
             XSetStipple ((Display*) m_display,(GC) m_gcBacking, (Pixmap) m_currentStipple.GetPixmap());
     }
         if (m_window && m_window->GetBackingPixmap())
             XSetStipple ((Display*) m_display,(GC) m_gcBacking, (Pixmap) m_currentStipple.GetPixmap());
     }

-    
+

     // must test m_logicalFunction, because it involves background!
     if (!sameColour || !GetOptimization() || m_logicalFunction == wxXOR)
     {
     // must test m_logicalFunction, because it involves background!
     if (!sameColour || !GetOptimization() || m_logicalFunction == wxXOR)
     {


@@ -1813,7 +1756,7 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
             unsigned char red = m_brush.GetColour ().Red ();
             unsigned char blue = m_brush.GetColour ().Blue ();
             unsigned char green = m_brush.GetColour ().Green ();
             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)
             {
             if (red == (unsigned char) 0 && blue == (unsigned char) 0
                 && green == (unsigned char) 0)
             {


@@ -1829,7 +1772,7 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
                 m_brush.GetColour().SetPixel(pixel);
                 m_currentColour.SetPixel(pixel);
             }
                 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.
             /*
             // 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.
             /*


@@ -1866,38 +1809,44 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
     }
     else
         m_brush.GetColour().SetPixel(oldBrushColour.GetPixel());
     }
     else
         m_brush.GetColour().SetPixel(oldBrushColour.GetPixel());

-};
+}

 
 void wxWindowDC::SetBackground( const wxBrush &brush )
 {
 
 void wxWindowDC::SetBackground( const wxBrush &brush )
 {

-    if (!Ok()) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+

     m_backgroundBrush = brush;
     m_backgroundBrush = brush;

-    
+

     if (!m_backgroundBrush.Ok())
         return;
     if (!m_backgroundBrush.Ok())
         return;

-    
+

     int pixel = m_backgroundBrush.GetColour().AllocColour(m_display);
     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);
     // XSetWindowBackground doesn't work for non-Window pixmaps
     if (!this->IsKindOf(CLASSINFO(wxMemoryDC)))
         XSetWindowBackground ((Display*) m_display, (Pixmap) m_pixmap, pixel);

-    
+*/
+

     // 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);
     if (m_window && m_window->GetBackingPixmap())
         XSetBackground ((Display*) m_display,(GC) m_gcBacking, pixel);
     // 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);
     if (m_window && m_window->GetBackingPixmap())
         XSetBackground ((Display*) m_display,(GC) m_gcBacking, pixel);

-};
+}

 
 void wxWindowDC::SetLogicalFunction( int function )
 {
 
 void wxWindowDC::SetLogicalFunction( int function )
 {

+    wxCHECK_RET( Ok(), "invalid dc" );
+

     int x_function;
     int x_function;

-    
+

     /* MATTHEW: [9] */
     if (m_logicalFunction == function)
         return;
     /* MATTHEW: [9] */
     if (m_logicalFunction == function)
         return;

-    
+

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


@@ -1950,44 +1899,46 @@ void wxWindowDC::SetLogicalFunction( int function )
         x_function = GXcopy;
         break;
     }
         x_function = GXcopy;
         break;
     }

-    
+

     XSetFunction((Display*) m_display, (GC) m_gc, x_function);
     if (m_window && m_window->GetBackingPixmap())
         XSetFunction((Display*) m_display, (GC) m_gcBacking, x_function);
     XSetFunction((Display*) m_display, (GC) m_gc, x_function);
     if (m_window && m_window->GetBackingPixmap())
         XSetFunction((Display*) m_display, (GC) m_gcBacking, x_function);

-    
+

     if ((m_logicalFunction == wxXOR) != (function == wxXOR))
         /* MATTHEW: [9] Need to redo pen simply */
         m_autoSetting |= 0x2;
     if ((m_logicalFunction == wxXOR) != (function == wxXOR))
         /* MATTHEW: [9] Need to redo pen simply */
         m_autoSetting |= 0x2;

-    
+

     m_logicalFunction = function;
     m_logicalFunction = function;

-    
-};
+
+}

 
 void wxWindowDC::SetTextForeground( const wxColour &col )
 {
 
 void wxWindowDC::SetTextForeground( const wxColour &col )
 {

-    if (!Ok()) return;
-    
-    if (m_textForegroundColour == col) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+
+    if (m_textForegroundColour == col)
+        return;
+

     m_textForegroundColour = col;
     m_textForegroundColour = col;

-    
-};
+
+}

 
 void wxWindowDC::SetTextBackground( const wxColour &col )
 {
 
 void wxWindowDC::SetTextBackground( const wxColour &col )
 {

-    if (!Ok()) return;
-    
-    if (m_textBackgroundColour == col) return;
-    
+    wxCHECK_RET( Ok(), "invalid dc" );
+
+    if (m_textBackgroundColour == col)
+        return;
+

     m_textBackgroundColour = col;
     m_textBackgroundColour = col;

-    if (!m_textBackgroundColour.Ok()) return;
-};
+    if (!m_textBackgroundColour.Ok())
+        return;
+}

 
 void wxWindowDC::SetBackgroundMode( int mode )
 {
     m_backgroundMode = mode;
 
 void wxWindowDC::SetBackgroundMode( int mode )
 {
     m_backgroundMode = mode;

-    
-};
+}

 
 void wxWindowDC::SetPalette( const wxPalette& palette )
 {
 
 void wxWindowDC::SetPalette( const wxPalette& palette )
 {


@@ -2002,16 +1953,16 @@ void wxWindowDC::SetPalette( const wxPalette& palette )
             XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
             (Colormap) wxTheApp->GetMainColormap(m_display));
     }
             XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
             (Colormap) wxTheApp->GetMainColormap(m_display));
     }

-};
+}

 
 // Helper function
 
 // Helper function

-void wxWindowDC:: SetDCClipping ()
+void wxWindowDC::SetDCClipping()

 {
     // m_userRegion is the region set by calling SetClippingRegion
 {
     // m_userRegion is the region set by calling SetClippingRegion

-    
+

     if (m_currentRegion)
         XDestroyRegion ((Region) m_currentRegion);
     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,
     // 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,


@@ -2020,15 +1971,15 @@ void wxWindowDC:: SetDCClipping ()
         m_currentRegion = (WXRegion) XCreateRegion ();
     else
         m_currentRegion = (WXRegion) NULL;
         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())
     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(), 
+        XIntersectRegion ((Region) m_window->GetUpdateRegion().GetXRegion(), (Region) m_window->GetUpdateRegion().GetXRegion(),

         (Region) m_currentRegion);
         (Region) m_currentRegion);

-    
+

     if (m_currentRegion)
     {
         XSetRegion ((Display*) m_display, (GC) m_gc, (Region) m_currentRegion);
     if (m_currentRegion)
     {
         XSetRegion ((Display*) m_display, (GC) m_gc, (Region) m_currentRegion);


@@ -2037,13 +1988,13 @@ void wxWindowDC:: SetDCClipping ()
     {
         XSetClipMask ((Display*) m_display, (GC) m_gc, None);
     }
     {
         XSetClipMask ((Display*) m_display, (GC) m_gc, None);
     }

-    
+

 }
 
 }
 

-void wxWindowDC::SetClippingRegion( 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 ();
     if (m_userRegion)
         XDestroyRegion ((Region) m_userRegion);
     m_userRegion = (WXRegion) XCreateRegion ();


@@ -2053,36 +2004,36 @@ void wxWindowDC::SetClippingRegion( long x, long y, long width, long height )
     r.width = XLOG2DEVREL(width);
     r.height = YLOG2DEVREL(height);
     XUnionRectWithRegion (&r, (Region) m_userRegion, (Region) m_userRegion);
     r.width = XLOG2DEVREL(width);
     r.height = YLOG2DEVREL(height);
     XUnionRectWithRegion (&r, (Region) m_userRegion, (Region) m_userRegion);

-    
+

     SetDCClipping ();
     SetDCClipping ();

-    
+

     // Needs to work differently for Pixmap: without this,
     // there's a nasty (Display*) m_display bug. 8/12/94
     if (m_window && m_window->GetBackingPixmap())
     {
         XRectangle rects[1];
     // Needs to work differently for Pixmap: without this,
     // there's a nasty (Display*) m_display bug. 8/12/94
     if (m_window && m_window->GetBackingPixmap())
     {
         XRectangle rects[1];

-        rects[0].x = XLOG2DEV_2(x); 
+        rects[0].x = XLOG2DEV_2(x);

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

-};
+}

 
 

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

 {
     wxRect box = region.GetBox();
 {
     wxRect box = region.GetBox();

-    
-    wxDC::SetClippingRegion( box.x, box.y, box.width, box.height );
-    
+
+    wxDC::DoSetClippingRegion( box.x, box.y, box.width, box.height );
+

     if (m_userRegion)
         XDestroyRegion ((Region) m_userRegion);
     m_userRegion = (WXRegion) XCreateRegion ();
     if (m_userRegion)
         XDestroyRegion ((Region) m_userRegion);
     m_userRegion = (WXRegion) XCreateRegion ();

-    
+

     XUnionRegion((Region) m_userRegion, (Region) region.GetXRegion(), (Region) m_userRegion);
     XUnionRegion((Region) m_userRegion, (Region) region.GetXRegion(), (Region) m_userRegion);

-    
+

     SetDCClipping ();
     SetDCClipping ();

-    
+

     // Needs to work differently for Pixmap: without this,
     // there's a nasty (Display*) m_display bug. 8/12/94
     if (m_window && m_window->GetBackingPixmap())
     // Needs to work differently for Pixmap: without this,
     // there's a nasty (Display*) m_display bug. 8/12/94
     if (m_window && m_window->GetBackingPixmap())


@@ -2094,53 +2045,66 @@ void wxWindowDC::SetClippingRegion( const wxRegion& region )
         rects[0].height = YLOG2DEVREL(box.height);
         XSetClipRectangles((Display*) m_display, (GC) m_gcBacking, 0, 0, rects, 1, Unsorted);
     }
         rects[0].height = YLOG2DEVREL(box.height);
         XSetClipRectangles((Display*) m_display, (GC) m_gcBacking, 0, 0, rects, 1, Unsorted);
     }

-};
+}

 
 
 
 

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

 {
     wxDC::DestroyClippingRegion();
 {
     wxDC::DestroyClippingRegion();

-    
+

     if (m_userRegion)
         XDestroyRegion ((Region) m_userRegion);
     m_userRegion = NULL;
     if (m_userRegion)
         XDestroyRegion ((Region) m_userRegion);
     m_userRegion = NULL;

-    
+

     SetDCClipping ();
     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);
     XGCValues gc_val;
     gc_val.clip_mask = None;
     if (m_window && m_window->GetBackingPixmap())
         XChangeGC((Display*) m_display, (GC) m_gcBacking, GCClipMask, &gc_val);

-};
+}
+
+// Resolution in pixels per logical inch
+wxSize wxWindowDC::GetPPI() const
+{
+    return wxSize(100, 100);
+}
+
+int wxWindowDC::GetDepth() const
+{
+    // TODO
+    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);
 // ----------------------------------- 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(void);
+void wx_clear_stack();

 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,

-                  double *y3, double *x4, double *y4);
+        double *y3, double *x4, double *y4);

 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,

-                    double x4, double y4);
+          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;
 
 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
+#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,
 
 /* iterative version */
 
 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,

-                         double b4)
+                 double b4)

 {
     register double  xmid, ymid;
     double           x1, y1, x2, y2, x3, y3, x4, y4;
 {
     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);
     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);
     while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
         xmid = (double)half(x2, x3);
         ymid = (double)half(y2, y3);


@@ -2150,9 +2114,9 @@ void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3,
             wx_spline_add_point( xmid, ymid );
         } else {
             wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
             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);
+                 (double)half(x3, x4), (double)half(y3, y4), x4, y4);

             wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
             wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),

-                (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
+                 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);

         }
     }
 }
         }
     }
 }


@@ -2168,7 +2132,7 @@ static Stack    wx_spline_stack[SPLINE_STACK_DEPTH];
 static Stack   *wx_stack_top;
 static int      wx_stack_count;
 
 static Stack   *wx_stack_top;
 static int      wx_stack_count;
 

-void wx_clear_stack(void)
+void wx_clear_stack()

 {
     wx_stack_top = wx_spline_stack;
     wx_stack_count = 0;
 {
     wx_stack_top = wx_spline_stack;
     wx_stack_count = 0;


@@ -2208,50 +2172,52 @@ int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
 
 static bool wx_spline_add_point(double x, double y)
 {
 
 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;
+  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)
 {
 }
 
 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();
-    }
+  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::DrawSpline( wxList *points )
+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;
     wxPoint *p;
     double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
     double           x1, y1, x2, y2;

-    
+

     wxNode *node = points->First();
     p = (wxPoint *)node->Data();
     wxNode *node = points->First();
     p = (wxPoint *)node->Data();

-    
+

     x1 = p->x;
     y1 = p->y;
     x1 = p->x;
     y1 = p->y;

-    
+

     node = node->Next();
     p = (wxPoint *)node->Data();
     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);
     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);
     wx_spline_add_point(x1, y1);

-    
+

     while ((node = node->Next()) != NULL)
     {
         p = (wxPoint *)node->Data();
     while ((node = node->Next()) != NULL)
     {
         p = (wxPoint *)node->Data();


@@ -2263,41 +2229,43 @@ void wxWindowDC::DrawSpline( wxList *points )
         cy4 = (double)(y1 + y2) / 2;
         cx3 = (double)(x1 + cx4) / 2;
         cy3 = (double)(y1 + cy4) / 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);
         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;
     }
         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_add_point( cx1, cy1 );
     wx_spline_add_point( x2, y2 );

-    
+

     wx_spline_draw_point_array( this );
     wx_spline_draw_point_array( this );

-};
+}

 
 

-/*
-* wxPaintDC
-*/
+#endif // wxUSE_SPLINE

 
 

-wxPaintDC::wxPaintDC(wxWindow* win): wxWindowDC(win)
+
+
+// ----------------------------------------------------------------------------
+// wxPaintDC
+// ----------------------------------------------------------------------------
+
+wxPaintDC::wxPaintDC(wxWindow* win) : wxWindowDC(win)

 {
     wxRegion* region = NULL;
 {
     wxRegion* region = NULL;

-    
+

     // Combine all the update rects into a region
     // Combine all the update rects into a region

-    if (win->m_updateRects.Number() > 0)
+    const wxRectList& updateRects(win->GetUpdateRects());
+    if ( updateRects.GetCount() != 0 )

     {
     {

-        int i = 0;
-        for (i = 0; i < win->m_updateRects.Number(); i++)
+        for ( wxRectList::Node *node = updateRects.GetFirst();
+              node;
+              node = node->GetNext() )

         {
         {

-            wxRect* rect = (wxRect*) win->m_updateRects.Nth(i)->Data();
-            /*
-            cout << "wxPaintDC. wxRect: " << rect->x << ", " << rect->y << ", ";
-            cout << rect->width << ", " << rect->height << "\n\n";
-            */
-            
+            wxRect* rect = node->GetData();
+

             if (!region)
                 region = new wxRegion(*rect);
             else
             if (!region)
                 region = new wxRegion(*rect);
             else


@@ -2313,13 +2281,16 @@ wxPaintDC::wxPaintDC(wxWindow* win): wxWindowDC(win)
         win->GetClientSize(&cw, &ch);
         region = new wxRegion(wxRect(0, 0, cw, ch));
     }
         win->GetClientSize(&cw, &ch);
         region = new wxRegion(wxRect(0, 0, cw, ch));
     }

-    
-    win->m_updateRegion = *region;
-    
+
+    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());
     // 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;
 }
 
     delete region;
 }
 


@@ -2327,6 +2298,102 @@ wxPaintDC::~wxPaintDC()
 {
     XSetClipMask ((Display*) m_display, (GC) m_gc, None);
     if (m_window)
 {
     XSetClipMask ((Display*) m_display, (GC) m_gc, None);
     if (m_window)

-        m_window->m_updateRegion.Clear();
+        m_window->ClearUpdateRegion();
+}
+
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
+
+/*
+   Used when copying between drawables on different (Display*) m_displays. Not
+   very fast, but better than giving up.
+*/
+
+static void XCopyRemote(Display *src_display, Display *dest_display,
+                        Drawable src, Drawable dest,
+                        GC destgc,
+                        int srcx, int srcy,
+                        unsigned int w, unsigned int h,
+                        int destx, int desty,
+                        bool more, XImage **cache)
+{
+    XImage *image, *destimage;
+    Colormap destcm, srccm;
+    static const int CACHE_SIZE = 256;
+
+    unsigned int i, j;
+    unsigned long cachesrc[CACHE_SIZE], cachedest[CACHE_SIZE];
+    int k, cache_pos, all_cache;
+
+    if (!cache || !*cache)
+        image = XGetImage(src_display, src, srcx, srcy, w, h, AllPlanes, ZPixmap);
+    else
+        image = *cache;
+
+    destimage = XGetImage(dest_display, dest, destx, desty, w, h, AllPlanes, ZPixmap);
+
+    srccm = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) src_display);
+    destcm = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dest_display);
+
+    cache_pos = 0;
+    all_cache = FALSE;
+
+    for (i = 0; i < w; i++)
+        for (j = 0; j < h; j++) {
+            unsigned long pixel;
+            XColor xcol;
+
+            pixel = XGetPixel(image, i, j);
+            for (k = cache_pos; k--; )
+                if (cachesrc[k] == pixel) {
+                    pixel = cachedest[k];
+                    goto install;
+                }
+                if (all_cache)
+                    for (k = CACHE_SIZE; k-- > cache_pos; )
+                        if (cachesrc[k] == pixel) {
+                            pixel = cachedest[k];
+                            goto install;
+                        }
+
+                        cachesrc[cache_pos] = xcol.pixel = pixel;
+                        XQueryColor(src_display, srccm, &xcol);
+                        if (!XAllocColor(dest_display, destcm, &xcol))
+                            xcol.pixel = 0;
+                        cachedest[cache_pos] = pixel = xcol.pixel;
+
+                        if (++cache_pos >= CACHE_SIZE) {
+                            cache_pos = 0;
+                            all_cache = TRUE;
+                        }
+
+install:
+                        XPutPixel(destimage, i, j, pixel);
+        }
+
+        XPutImage(dest_display, dest, destgc, destimage, 0, 0, destx, desty, w, h);
+        XDestroyImage(destimage);
+
+        if (more)
+            *cache = image;
+        else
+            XDestroyImage(image);
+}
+
+#if 0
+
+/* Helper function for 16-bit fonts */
+static int str16len(const char *s)
+{
+    int count = 0;
+
+    while (s[0] && s[1]) {
+        count++;
+        s += 2;
+    }
+
+    return count;

 }
 
 }
 

+#endif // 0