Add virtual ~wxAnyScrollHelperBase() to fix compiler warning.

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

diff --git a/src/motif/dcclient.cpp b/src/motif/dcclient.cpp
index eef4a0aa7dba678110fe1e6775e9b992621daee8..820fe963583a9aee5dab6efcc050ef8f8c772af7 100644 (file)
--- a/src/motif/dcclient.cpp
+++ b/src/motif/dcclient.cpp
@@ -1,10 +1,9 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        src/motif/dcclient.cpp
 /////////////////////////////////////////////////////////////////////////////
 // Name:        src/motif/dcclient.cpp

-// Purpose:     wxClientDC class
+// Purpose:     wxClientDCImpl class

 // Author:      Julian Smart
 // Modified by:
 // Created:     01/02/97
 // Author:      Julian Smart
 // Modified by:
 // Created:     01/02/97

-// RCS-ID:      $Id$

 // Copyright:   (c) Julian Smart
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 // Copyright:   (c) Julian Smart
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////


@@ -39,18 +38,16 @@
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 

-#include "wx/dcclient.h"
-

 #ifndef WX_PRECOMP
     #include "wx/log.h"
     #include "wx/app.h"
     #include "wx/window.h"
 #ifndef WX_PRECOMP
     #include "wx/log.h"
     #include "wx/app.h"
     #include "wx/window.h"

+    #include "wx/dcmemory.h"
+    #include "wx/math.h"
+    #include "wx/image.h"
+    #include "wx/dcclient.h"

 #endif
 
 #endif
 

-#include "wx/dcmemory.h"
-#include "wx/image.h"
-#include "wx/math.h"
-

 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif
 #ifdef __VMS__
 #pragma message disable nosimpint
 #endif


@@ -60,6 +57,7 @@
 #endif
 
 #include "wx/motif/private.h"
 #endif
 
 #include "wx/motif/private.h"

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

 
 #ifdef __EMX__
     #include <float.h>          // for M_PI
 
 #ifdef __EMX__
     #include <float.h>          // for M_PI


@@ -85,15 +83,11 @@ static Pixmap bdiag, cdiag, fdiag, cross, horiz, verti;
 // macros
 // ----------------------------------------------------------------------------
 
 // macros
 // ----------------------------------------------------------------------------
 

-IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
-IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxWindowDC)
-IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
+IMPLEMENT_ABSTRACT_CLASS(wxClientDCImpl, wxWindowDCImpl)
+IMPLEMENT_ABSTRACT_CLASS(wxPaintDCImpl, wxWindowDCImpl)
+IMPLEMENT_ABSTRACT_CLASS(wxWindowDCImpl, wxMotifDCImpl)

 
 

-#ifndef IS_HATCH
-    // IS_HATCH exists for WXWIN_COMPATIBILITY_2_4 only
-    // but wxMotif needs it for its internals here
-    #define IS_HATCH(s)    ((s)>=wxFIRST_HATCH && (s)<=wxLAST_HATCH)
-#endif
+#define IS_HATCH(s)    ((s)>=wxFIRST_HATCH && (s)<=wxLAST_HATCH)

 
 // FIXME: left over after removal of wxDC::GetOptimization()
 #define GET_OPTIMIZATION false
 
 // FIXME: left over after removal of wxDC::GetOptimization()
 #define GET_OPTIMIZATION false


@@ -134,10 +128,10 @@ static int roundmin(double a, double b)
 
 
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------

-// wxWindowDC
+// wxWindowDCImpl

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

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

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


@@ -146,25 +140,27 @@ void wxWindowDC::Init()
     m_currentPenWidth = 1;
     m_currentPenJoin = -1;
     m_currentPenDashCount = -1;
     m_currentPenWidth = 1;
     m_currentPenJoin = -1;
     m_currentPenDashCount = -1;

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

     m_currentStyle = -1;
     m_currentFill = -1;
     m_colour = wxColourDisplay();
     m_currentStyle = -1;
     m_currentFill = -1;
     m_colour = wxColourDisplay();

-    m_display = (WXDisplay*) NULL;
+    m_display = NULL;

     m_pixmap = (WXPixmap) 0;
     m_autoSetting = 0;
     m_ok = false;
     m_clipRegion = (WXRegion) 0;
 }
 
     m_pixmap = (WXPixmap) 0;
     m_autoSetting = 0;
     m_ok = false;
     m_clipRegion = (WXRegion) 0;
 }
 

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

 {
     Init();
 }
 
 {
     Init();
 }
 

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

 {
 {

-    wxASSERT_MSG( (window != (wxWindow*) NULL), "You must pass a valid wxWindow to wxWindowDC/wxClientDC/wxPaintDC constructor." );
+    wxASSERT_MSG( (window != NULL), "You must pass a valid wxWindow to wxWindowDCImpl/wxClientDCImpl/wxPaintDCImpl constructor." );

 
     Init();
 
 
     Init();
 


@@ -184,8 +180,16 @@ wxWindowDC::wxWindowDC( wxWindow *window )
     gcvalues.graphics_exposures = False;
     gcvalues.subwindow_mode = IncludeInferiors;
     gcvalues.line_width = 1;
     gcvalues.graphics_exposures = False;
     gcvalues.subwindow_mode = IncludeInferiors;
     gcvalues.line_width = 1;

+#if !wxMOTIF_NEW_FONT_HANDLING
+    WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
+    gcvalues.font = ((XFontStruct*)pFontStruct)->fid;
+#endif

     m_gc = (WXGC) XCreateGC (display, RootWindow (display, DefaultScreen (display)),
     m_gc = (WXGC) XCreateGC (display, RootWindow (display, DefaultScreen (display)),

-        GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth | GCSubwindowMode,
+        GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth | GCSubwindowMode
+#if !wxMOTIF_NEW_FONT_HANDLING
+        | GCFont
+#endif
+                             ,

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


@@ -196,12 +200,12 @@ wxWindowDC::wxWindowDC( wxWindow *window )
             &gcvalues);
     }
 
             &gcvalues);
     }
 

-    m_backgroundPixel = (int) gcvalues.background;
+    m_backgroundPixel = gcvalues.background;

 
     SetBackground(wxBrush(m_window->GetBackgroundColour(), wxSOLID));
 }
 
 
     SetBackground(wxBrush(m_window->GetBackgroundColour(), wxSOLID));
 }
 

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

 {
     if (m_gc)
         XFreeGC ((Display*) m_display, (GC) m_gc);
 {
     if (m_gc)
         XFreeGC ((Display*) m_display, (GC) m_gc);


@@ -217,31 +221,31 @@ wxWindowDC::~wxWindowDC()
 }
 
 extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
 }
 
 extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,

-                          const wxColour & col, int style);
+                          const wxColour & col, wxFloodFillStyle style);

 
 

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

 {
 {

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

 }
 
 }
 

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

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

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

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

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

 {
 {

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

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


@@ -264,9 +268,9 @@ void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
     CalcBoundingBox(x2, y2);
 }
 
     CalcBoundingBox(x2, y2);
 }
 

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

 {
 {

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

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


@@ -293,9 +297,9 @@ void wxWindowDC::DoCrossHair( wxCoord x, wxCoord y )
     }
 }
 
     }
 }
 

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

 {
 {

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

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


@@ -347,7 +351,7 @@ void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCo
     while (alpha2 > 360 * 64)
         alpha2 -= 360 * 64;
 
     while (alpha2 > 360 * 64)
         alpha2 -= 360 * 64;
 

-    if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)

     {
         SetBrush (m_brush);
         XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) (GC) m_gc,
     {
         SetBrush (m_brush);
         XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) (GC) m_gc,


@@ -359,7 +363,7 @@ void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCo
 
     }
 
 
     }
 

-    if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)

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


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

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

 {
 {

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

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


@@ -394,7 +398,7 @@ void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord
     if (end>start) end-=start;
     else end+=360*64-start;
 
     if (end>start) end-=start;
     else end+=360*64-start;
 

-    if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)

     {
         m_autoSetting = true;    // must be reset
 
     {
         m_autoSetting = true;    // must be reset
 


@@ -406,7 +410,7 @@ void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord
             XLOG2DEV_2 (x), YLOG2DEV_2 (y),wd,hd,start,end);
     }
 
             XLOG2DEV_2 (x), YLOG2DEV_2 (y),wd,hd,start,end);
     }
 

-    if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)

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


@@ -419,11 +423,11 @@ void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord
     CalcBoundingBox (x + width, y + height);
 }
 
     CalcBoundingBox (x + width, y + height);
 }
 

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

 {
 {

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

 
 

-    if (m_pen.Ok() && m_autoSetting)
+    if (m_pen.IsOk() && m_autoSetting)

         SetPen (m_pen);
 
     XDrawPoint ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y));
         SetPen (m_pen);
 
     XDrawPoint ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y));


@@ -433,11 +437,11 @@ void wxWindowDC::DoDrawPoint( wxCoord x, wxCoord y )
     CalcBoundingBox (x, y);
 }
 
     CalcBoundingBox (x, y);
 }
 

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

 {
 {

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

 
 

-    if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)

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


@@ -465,10 +469,10 @@ void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord
     }
 }
 
     }
 }
 

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

 {
 {

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

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


@@ -488,7 +492,7 @@ void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
     xpoints2[i].x = xpoints2[0].x;
     xpoints2[i].y = xpoints2[0].y;
 
     xpoints2[i].x = xpoints2[0].x;
     xpoints2[i].y = xpoints2[0].y;
 

-    if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)

     {
         SetBrush (m_brush);
         XSetFillRule ((Display*) m_display, (GC) m_gc, fillStyle == wxODDEVEN_RULE ? EvenOddRule : WindingRule);
     {
         SetBrush (m_brush);
         XSetFillRule ((Display*) m_display, (GC) m_gc, fillStyle == wxODDEVEN_RULE ? EvenOddRule : WindingRule);


@@ -503,7 +507,7 @@ void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
         }
     }
 
         }
     }
 

-    if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)

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


@@ -517,9 +521,9 @@ void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
     delete[]xpoints2;
 }
 
     delete[]xpoints2;
 }
 

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

 {
 {

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

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


@@ -534,7 +538,7 @@ void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord h
     if (wd < 0) { wd = - wd; xd = xd - wd; }
     if (hd < 0) { hd = - hd; yd = yd - hd; }
 
     if (wd < 0) { wd = - wd; xd = xd - wd; }
     if (hd < 0) { hd = - hd; yd = yd - hd; }
 

-    if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)

     {
         SetBrush (m_brush);
         XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wfd, hfd);
     {
         SetBrush (m_brush);
         XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wfd, hfd);


@@ -545,7 +549,7 @@ void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord h
             wfd, hfd);
     }
 
             wfd, hfd);
     }
 

-    if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)

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


@@ -560,9 +564,9 @@ void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord h
     CalcBoundingBox (x + width, y + height);
 }
 
     CalcBoundingBox (x + width, y + height);
 }
 

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

 {
 {

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

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


@@ -581,7 +585,7 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
     // X drawing errors with small radii
     if (rd == 0)
     {
     // X drawing errors with small radii
     if (rd == 0)
     {

-        DrawRectangle( x, y, width, height );
+        DoDrawRectangle( x, y, width, height );

         return;
     }
 
         return;
     }
 


@@ -612,7 +616,7 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
     int rw_d2 = rd2 * 2;
     int rh_d2 = rw_d2;
 
     int rw_d2 = rd2 * 2;
     int rh_d2 = rw_d2;
 

-    if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)

     {
         SetBrush (m_brush);
 
     {
         SetBrush (m_brush);
 


@@ -662,7 +666,7 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
         }
     }
 
         }
     }
 

-    if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)

     {
         SetPen (m_pen);
         XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd,
     {
         SetPen (m_pen);
         XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd,


@@ -720,9 +724,9 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
     CalcBoundingBox (x + width, y + height);
 }
 
     CalcBoundingBox (x + width, y + height);
 }
 

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

 {
 {

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

 
     // Check for negative width and height
     if (height < 0)
 
     // Check for negative width and height
     if (height < 0)


@@ -746,7 +750,7 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
     wd = XLOG2DEVREL(width) ;
     hd = YLOG2DEVREL(height) ;
 
     wd = XLOG2DEVREL(width) ;
     hd = YLOG2DEVREL(height) ;
 

-    if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)

     {
         SetBrush (m_brush);
         XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, 0, angle);
     {
         SetBrush (m_brush);
         XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, 0, angle);


@@ -757,7 +761,7 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
             YLOG2DEVREL (height) - WX_GC_CF, 0, angle);
     }
 
             YLOG2DEVREL (height) - WX_GC_CF, 0, angle);
     }
 

-    if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)

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


@@ -773,45 +777,50 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
 
 }
 
 
 }
 

-bool wxWindowDC::CanDrawBitmap() const
+bool wxWindowDCImpl::CanDrawBitmap() const

 {
 {

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

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

-bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
+bool wxWindowDCImpl::DoBlit( wxCoord xdest, wxCoord ydest,

                          wxCoord width, wxCoord height,
                          wxDC *source, wxCoord xsrc, wxCoord ysrc,
                          wxCoord width, wxCoord height,
                          wxDC *source, wxCoord xsrc, wxCoord ysrc,

-                         int rop, bool useMask,
+                         wxRasterOperationMode rop, bool useMask,

                          wxCoord xsrcMask, wxCoord ysrcMask )
 {
                          wxCoord xsrcMask, wxCoord ysrcMask )
 {

-    wxCHECK_MSG( Ok(), false, "invalid dc" );
+    wxCHECK_MSG( IsOk(), false, "invalid dc" );
+
+    wxWindowDC const * sourceDC = wxDynamicCast(source, wxWindowDC);
+    wxCHECK_MSG( sourceDC, false, "Blit source DC must be wxWindowDCImpl or derived class." );

 
 

-    wxWindowDC* sourceDC = wxDynamicCast(source, wxWindowDC);
+    // cast is safe in virtue of the above wxCHECK_MSG()
+    const wxWindowDCImpl * const
+        srcImpl = static_cast<const wxWindowDCImpl *>(sourceDC->GetImpl());
+    WXDisplay * const srcDpy = srcImpl->m_display;

 
 

-    wxASSERT_MSG( sourceDC, "Blit source DC must be wxWindowDC or derived class." );

 
     // Be sure that foreground pixels (1) of the Icon will be painted with
     // foreground colour. [m_textForegroundColour] Background pixels (0)
     // will be painted with backgound colour (m_textBackgroundColour)
     // Using ::SetPen is horribly slow, so avoid doing it
 
     // Be sure that foreground pixels (1) of the Icon will be painted with
     // foreground colour. [m_textForegroundColour] Background pixels (0)
     // will be painted with backgound colour (m_textBackgroundColour)
     // Using ::SetPen is horribly slow, so avoid doing it

-    int oldBackgroundPixel = -1;
-    int oldForegroundPixel = -1;
+    WXPixel oldBackgroundPixel = -1;
+    WXPixel oldForegroundPixel = -1;

 
 

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

     {
         oldBackgroundPixel = m_backgroundPixel;
     {
         oldBackgroundPixel = m_backgroundPixel;

-        int pixel = m_textBackgroundColour.AllocColour(m_display);
+        WXPixel pixel = m_textBackgroundColour.AllocColour(m_display);

 
         XSetBackground ((Display*) m_display, (GC) m_gc, pixel);
         if (m_window && m_window->GetBackingPixmap())
             XSetBackground ((Display*) m_display,(GC) m_gcBacking,
                             pixel);
     }
 
         XSetBackground ((Display*) m_display, (GC) m_gc, pixel);
         if (m_window && m_window->GetBackingPixmap())
             XSetBackground ((Display*) m_display,(GC) m_gcBacking,
                             pixel);
     }

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

     {
         oldForegroundPixel = m_currentColour.GetPixel();
 
     {
         oldForegroundPixel = m_currentColour.GetPixel();
 


@@ -819,14 +828,14 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
             CalculatePixel( m_textForegroundColour,
                             m_textForegroundColour, true);
 
             CalculatePixel( m_textForegroundColour,
                             m_textForegroundColour, true);
 

-        int pixel = m_textForegroundColour.GetPixel();
+        WXPixel pixel = m_textForegroundColour.GetPixel();

         if (pixel > -1)
             SetForegroundPixelWithLogicalFunction(pixel);
     }
 
     // Do bitmap scaling if necessary
 
         if (pixel > -1)
             SetForegroundPixelWithLogicalFunction(pixel);
     }
 
     // Do bitmap scaling if necessary
 

-    wxBitmap *scaledBitmap = (wxBitmap*) NULL;
+    wxBitmap *scaledBitmap = NULL;

     Pixmap sourcePixmap = (Pixmap) NULL;
     double scaleX, scaleY;
     GetUserScale(& scaleX, & scaleY);
     Pixmap sourcePixmap = (Pixmap) NULL;
     double scaleX, scaleY;
     GetUserScale(& scaleX, & scaleY);


@@ -842,12 +851,12 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
     if (!useMask && (scaleX != 1.0 || scaleY != 1.0) && sourceDC->IsKindOf(CLASSINFO(wxMemoryDC)))
     {
         wxMemoryDC* memDC = (wxMemoryDC*) sourceDC;
     if (!useMask && (scaleX != 1.0 || scaleY != 1.0) && sourceDC->IsKindOf(CLASSINFO(wxMemoryDC)))
     {
         wxMemoryDC* memDC = (wxMemoryDC*) sourceDC;

-        wxBitmap& bitmap = memDC->GetBitmap();
+        wxBitmap& bitmap = memDC->GetSelectedBitmap();

 
 

-        wxASSERT_MSG( (bitmap.Ok()), "Bad source bitmap in wxWindowDC::Blit");
+        wxASSERT_MSG( (bitmap.IsOk()), "Bad source bitmap in wxWindowDCImpl::Blit");

 
         wxImage image = bitmap.ConvertToImage();
 
         wxImage image = bitmap.ConvertToImage();

-        if (!image.Ok())
+        if (!image.IsOk())

         {
             sourcePixmap = (Pixmap) bitmap.GetDrawable();
         }
         {
             sourcePixmap = (Pixmap) bitmap.GetDrawable();
         }


@@ -862,21 +871,23 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
         }
     }
     else
         }
     }
     else

-        sourcePixmap = (Pixmap) sourceDC->m_pixmap;
+    {
+        sourcePixmap = (Pixmap) srcImpl->m_pixmap;
+    }

 
     if (m_pixmap && sourcePixmap)
     {
         /* MATTHEW: [9] */
 
     if (m_pixmap && sourcePixmap)
     {
         /* MATTHEW: [9] */

-        int orig = m_logicalFunction;
+        wxRasterOperationMode orig = m_logicalFunction;

 
         SetLogicalFunction (rop);
 
 
         SetLogicalFunction (rop);
 

-        if (m_display != sourceDC->m_display)
+        if (m_display != srcDpy)

         {
             XImage *cache = NULL;
 
             if (m_window && m_window->GetBackingPixmap())
         {
             XImage *cache = NULL;
 
             if (m_window && m_window->GetBackingPixmap())

-                XCopyRemote((Display*) sourceDC->m_display, (Display*) m_display,
+                XCopyRemote((Display*) srcDpy, (Display*) m_display,

                 (Pixmap) sourcePixmap, (Pixmap) m_window->GetBackingPixmap(),
                 (GC) m_gcBacking,
                 source->LogicalToDeviceX (xsrc),
                 (Pixmap) sourcePixmap, (Pixmap) m_window->GetBackingPixmap(),
                 (GC) m_gcBacking,
                 source->LogicalToDeviceX (xsrc),


@@ -889,15 +900,15 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
             if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
             {
                 wxMemoryDC *memDC = (wxMemoryDC *)source;
             if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
             {
                 wxMemoryDC *memDC = (wxMemoryDC *)source;

-                wxBitmap& sel = memDC->GetBitmap();
-                if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetBitmap() )
+                wxBitmap& sel = memDC->GetSelectedBitmap();
+                if ( sel.IsOk() && sel.GetMask() && sel.GetMask()->GetBitmap() )

                 {
                     XSetClipMask   ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetBitmap());
                     XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
                 }
             }
 
                 {
                     XSetClipMask   ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetBitmap());
                     XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
                 }
             }
 

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

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


@@ -923,7 +934,7 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
             if (m_window && m_window->GetBackingPixmap())
             {
                 // +++ MARKUS (mho@comnets.rwth-aachen): error on blitting bitmaps with depth 1
             if (m_window && m_window->GetBackingPixmap())
             {
                 // +++ MARKUS (mho@comnets.rwth-aachen): error on blitting bitmaps with depth 1

-                if (source->IsKindOf(CLASSINFO(wxMemoryDC)) && ((wxMemoryDC*) source)->GetBitmap().GetDepth() == 1)
+                if (source->IsKindOf(CLASSINFO(wxMemoryDC)) && ((wxMemoryDC*) source)->GetSelectedBitmap().GetDepth() == 1)

                 {
                     XCopyPlane ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
                         source->LogicalToDeviceX (xsrc),
                 {
                     XCopyPlane ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
                         source->LogicalToDeviceX (xsrc),


@@ -945,8 +956,8 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
             if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
             {
                 wxMemoryDC *memDC = (wxMemoryDC *)source;
             if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
             {
                 wxMemoryDC *memDC = (wxMemoryDC *)source;

-                wxBitmap& sel = memDC->GetBitmap();
-                if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetBitmap() )
+                wxBitmap& sel = memDC->GetSelectedBitmap();
+                if ( sel.IsOk() && sel.GetMask() && sel.GetMask()->GetBitmap() )

                 {
                     XSetClipMask   ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetBitmap());
                     XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
                 {
                     XSetClipMask   ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetBitmap());
                     XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));


@@ -955,7 +966,8 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
 
             // Check if we're copying from a mono bitmap
             if (source->IsKindOf(CLASSINFO(wxMemoryDC)) &&
 
             // Check if we're copying from a mono bitmap
             if (source->IsKindOf(CLASSINFO(wxMemoryDC)) &&

-                ((wxMemoryDC*)source)->GetBitmap().Ok() && (((wxMemoryDC*)source)->GetBitmap().GetDepth () == 1))
+                ((wxMemoryDC*)source)->GetSelectedBitmap().IsOk() &&
+                (((wxMemoryDC*)source)->GetSelectedBitmap().GetDepth () == 1))

             {
                 XCopyPlane ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_pixmap, (GC) m_gc,
                     source->LogicalToDeviceX (xsrc),
             {
                 XCopyPlane ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_pixmap, (GC) m_gc,
                     source->LogicalToDeviceX (xsrc),


@@ -1013,9 +1025,9 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
   return retVal;
 }
 
   return retVal;
 }
 

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

 {
 {

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

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


@@ -1035,17 +1047,17 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
         XSetFillStyle ((Display*) m_display, (GC) m_gcBacking, FillSolid);
     }
 
         XSetFillStyle ((Display*) m_display, (GC) m_gcBacking, FillSolid);
     }
 

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

         wxGetTextExtent (m_display, m_font, m_userScaleY * m_logicalScaleY,
                          text, &cx, &cy, &ascent, NULL);
 
     // First draw a rectangle representing the text background, if a text
     // background is specified
         wxGetTextExtent (m_display, m_font, m_userScaleY * m_logicalScaleY,
                          text, &cx, &cy, &ascent, NULL);
 
     // First draw a rectangle representing the text background, if a text
     // background is specified

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

     {
         wxColour oldPenColour = m_currentColour;
         m_currentColour = m_textBackgroundColour;
     {
         wxColour oldPenColour = m_currentColour;
         m_currentColour = m_textBackgroundColour;

-        bool sameColour = (oldPenColour.Ok () && m_textBackgroundColour.Ok () &&
+        bool sameColour = (oldPenColour.IsOk () && m_textBackgroundColour.IsOk () &&

             (oldPenColour.Red () == m_textBackgroundColour.Red ()) &&
             (oldPenColour.Blue () == m_textBackgroundColour.Blue ()) &&
             (oldPenColour.Green () == m_textBackgroundColour.Green ()));
             (oldPenColour.Red () == m_textBackgroundColour.Red ()) &&
             (oldPenColour.Blue () == m_textBackgroundColour.Blue ()) &&
             (oldPenColour.Green () == m_textBackgroundColour.Green ()));


@@ -1057,7 +1069,7 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
 
         if (!sameColour || !GET_OPTIMIZATION)
         {
 
         if (!sameColour || !GET_OPTIMIZATION)
         {

-            int pixel = m_textBackgroundColour.AllocColour(m_display);
+            WXPixel pixel = m_textBackgroundColour.AllocColour(m_display);

             m_currentColour = m_textBackgroundColour;
 
             // Set the GC to the required colour
             m_currentColour = m_textBackgroundColour;
 
             // Set the GC to the required colour


@@ -1078,11 +1090,11 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
     }
 
     // Now set the text foreground and draw the text
     }
 
     // Now set the text foreground and draw the text

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

     {
         wxColour oldPenColour = m_currentColour;
         m_currentColour = m_textForegroundColour;
     {
         wxColour oldPenColour = m_currentColour;
         m_currentColour = m_textForegroundColour;

-        bool sameColour = (oldPenColour.Ok () && m_currentColour.Ok () &&
+        bool sameColour = (oldPenColour.IsOk () && m_currentColour.IsOk () &&

             (oldPenColour.Red () == m_currentColour.Red ()) &&
             (oldPenColour.Blue () == m_currentColour.Blue ()) &&
             (oldPenColour.Green () == m_currentColour.Green ()) &&
             (oldPenColour.Red () == m_currentColour.Red ()) &&
             (oldPenColour.Blue () == m_currentColour.Blue ()) &&
             (oldPenColour.Green () == m_currentColour.Green ()) &&


@@ -1090,8 +1102,8 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
 
         if (!sameColour || !GET_OPTIMIZATION)
         {
 
         if (!sameColour || !GET_OPTIMIZATION)
         {

-            int pixel = CalculatePixel(m_textForegroundColour,
-                                       m_currentColour, false);
+            WXPixel pixel = CalculatePixel(m_textForegroundColour,
+                                           m_currentColour, false);

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


@@ -1131,11 +1143,11 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
 #if wxMOTIF_NEW_FONT_HANDLING
             XmbDrawString((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), fset, (GC) m_gcBacking,
             XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent,
 #if wxMOTIF_NEW_FONT_HANDLING
             XmbDrawString((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), fset, (GC) m_gcBacking,
             XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent,

-                        wxConstCast(text.c_str(), char), slen);
+                        text.mb_str(), slen);

 #else
             XDrawString((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
             XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent,
 #else
             XDrawString((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
             XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent,

-                        wxConstCast(text.c_str(), char), slen);
+                        text.mb_str(), slen);

 #endif
     }
 
 #endif
     }
 


@@ -1146,33 +1158,33 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
                        gcBackingV.fill_style);
 
     wxCoord w, h;
                        gcBackingV.fill_style);
 
     wxCoord w, h;

-    GetTextExtent (text, &w, &h);
+    DoGetTextExtent (text, &w, &h);

     CalcBoundingBox (x + w, y + h);
     CalcBoundingBox (x, y);
 }
 
     CalcBoundingBox (x + w, y + h);
     CalcBoundingBox (x, y);
 }
 

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

                                     double angle )
 {
     if (angle == 0.0)
     {
                                     double angle )
 {
     if (angle == 0.0)
     {

-        DrawText(text, x, y);
+        DoDrawText(text, x, y);

         return;
     }
 
         return;
     }
 

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

 
 

-    int oldBackgroundPixel = -1;
-    int oldForegroundPixel = -1;
-    int foregroundPixel = -1;
-    int backgroundPixel = -1;
+    WXPixel oldBackgroundPixel = -1;
+    WXPixel oldForegroundPixel = -1;
+    WXPixel foregroundPixel = -1;
+    WXPixel backgroundPixel = -1;

 
 

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

     {
         oldBackgroundPixel = m_backgroundPixel;
         backgroundPixel = m_textBackgroundColour.AllocColour(m_display);
     }
     {
         oldBackgroundPixel = m_backgroundPixel;
         backgroundPixel = m_textBackgroundColour.AllocColour(m_display);
     }

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

     {
         oldForegroundPixel = m_currentColour.GetPixel();
 
     {
         oldForegroundPixel = m_currentColour.GetPixel();
 


@@ -1188,7 +1200,7 @@ void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y,
     int cy = 0;
     int ascent = 0;
 
     int cy = 0;
     int ascent = 0;
 

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

         wxGetTextExtent (m_display, m_font, m_userScaleY * m_logicalScaleY,
                          text, &cx, &cy, &ascent, NULL);
 
         wxGetTextExtent (m_display, m_font, m_userScaleY * m_logicalScaleY,
                          text, &cx, &cy, &ascent, NULL);
 


@@ -1287,20 +1299,20 @@ void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y,
     CalcBoundingBox (maxx, maxy);
 }
 
     CalcBoundingBox (maxx, maxy);
 }
 

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

 {
     return true;
 }
 
 {
     return true;
 }
 

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

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

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

 {
 {

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

 
     const wxFont* theFont = font ? font : &m_font;
 
 
     const wxFont* theFont = font ? font : &m_font;
 

-    if (!theFont->Ok())
+    if (!theFont->IsOk())

     {
         // TODO: this should be an error log function
         wxFAIL_MSG("set a valid font before calling GetTextExtent!");
     {
         // TODO: this should be an error log function
         wxFAIL_MSG("set a valid font before calling GetTextExtent!");


@@ -1319,10 +1331,10 @@ void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoor
         *externalLeading = 0;
 }
 
         *externalLeading = 0;
 }
 

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

 {
 {

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

 
     int width;
 
 
     int width;
 


@@ -1332,10 +1344,10 @@ wxCoord wxWindowDC::GetCharWidth() const
     return XDEV2LOGREL(width);
 }
 
     return XDEV2LOGREL(width);
 }
 

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

 {
 {

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

 
     int height;
 
 
     int height;
 


@@ -1345,7 +1357,7 @@ wxCoord wxWindowDC::GetCharHeight() const
     return XDEV2LOGREL(height);
 }
 
     return XDEV2LOGREL(height);
 }
 

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

 {
     int w = 0, h = 0;
 
 {
     int w = 0, h = 0;
 


@@ -1364,17 +1376,17 @@ void wxWindowDC::DoGetSize( int *width, int *height ) const
     if( height ) *height = h;
 }
 
     if( height ) *height = h;
 }
 

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

 {
 {

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

 
     wxRect rect( GetSize() );
     Clear( rect );
 }
 
 
     wxRect rect( GetSize() );
     Clear( rect );
 }
 

-void wxWindowDC::Clear(const wxRect& rect)
+void wxWindowDCImpl::Clear(const wxRect& rect)

 {
 {

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

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


@@ -1393,13 +1405,13 @@ void wxWindowDC::Clear(const wxRect& rect)
     m_brush = saveBrush;
 }
 
     m_brush = saveBrush;
 }
 

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

 {
 {

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

 
     m_font = font;
 
 
     m_font = font;
 

-    if (!m_font.Ok())
+    if (!m_font.IsOk())

     {
         return;
     }
     {
         return;
     }


@@ -1415,7 +1427,7 @@ void wxWindowDC::SetFont( const wxFont &font )
 #endif
 }
 
 #endif
 }
 

-void wxWindowDC::SetForegroundPixelWithLogicalFunction(int pixel)
+void wxWindowDCImpl::SetForegroundPixelWithLogicalFunction(WXPixel pixel)

 {
     if (m_logicalFunction == wxXOR)
     {
 {
     if (m_logicalFunction == wxXOR)
     {


@@ -1435,12 +1447,12 @@ void wxWindowDC::SetForegroundPixelWithLogicalFunction(int pixel)
     }
 }
 
     }
 }
 

-int wxWindowDC::CalculatePixel(wxColour& colour, wxColour& curCol,
+WXPixel wxWindowDCImpl::CalculatePixel(wxColour& colour, wxColour& curCol,

                                bool roundToWhite) const
 {
     const unsigned char wp = (unsigned char)255;
 
                                bool roundToWhite) const
 {
     const unsigned char wp = (unsigned char)255;
 

-    int pixel = -1;
+    WXPixel pixel = -1;

     if(!m_colour) // Mono display
     {
         unsigned char red = colour.Red ();
     if(!m_colour) // Mono display
     {
         unsigned char red = colour.Red ();


@@ -1452,16 +1464,16 @@ int wxWindowDC::CalculatePixel(wxColour& colour, wxColour& curCol,
            ((red != 0 || blue != 0 || green != 0) && roundToWhite))
         {
             curCol = *wxWHITE;
            ((red != 0 || blue != 0 || green != 0) && roundToWhite))
         {
             curCol = *wxWHITE;

-            pixel = (int)WhitePixel((Display*) m_display,
-                                    DefaultScreen((Display*) m_display));
+            pixel = WhitePixel((Display*) m_display,
+                               DefaultScreen((Display*) m_display));

             curCol.SetPixel(pixel);
             colour.SetPixel(pixel);
         }
         else
         {
             curCol = *wxBLACK;
             curCol.SetPixel(pixel);
             colour.SetPixel(pixel);
         }
         else
         {
             curCol = *wxBLACK;

-            pixel = (int)BlackPixel((Display*) m_display,
-                                    DefaultScreen((Display*) m_display));
+            pixel = BlackPixel((Display*) m_display,
+                               DefaultScreen((Display*) m_display));

             curCol.SetPixel(pixel);
             colour.SetPixel(pixel);
         }
             curCol.SetPixel(pixel);
             colour.SetPixel(pixel);
         }


@@ -1476,12 +1488,12 @@ int wxWindowDC::CalculatePixel(wxColour& colour, wxColour& curCol,
     return pixel;
 }
 
     return pixel;
 }
 

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

 {
 {

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

 
     m_pen = pen;
 
     m_pen = pen;

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

         return;
 
     wxBitmap oldStipple = m_currentStipple;
         return;
 
     wxBitmap oldStipple = m_currentStipple;


@@ -1514,7 +1526,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
         old_pen_dash == m_currentPenDash &&
         old_pen_width == m_currentPenWidth);
 
         old_pen_dash == m_currentPenDash &&
         old_pen_width == m_currentPenWidth);
 

-    bool sameColour = (oldPenColour.Ok () &&
+    bool sameColour = (oldPenColour.IsOk () &&

         (oldPenColour.Red () == m_currentColour.Red ()) &&
         (oldPenColour.Blue () == m_currentColour.Blue ()) &&
         (oldPenColour.Green () == m_currentColour.Green ()) &&
         (oldPenColour.Red () == m_currentColour.Red ()) &&
         (oldPenColour.Blue () == m_currentColour.Blue ()) &&
         (oldPenColour.Green () == m_currentColour.Green ()) &&


@@ -1571,7 +1583,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
         case wxTRANSPARENT:
         default:
             style = LineSolid;
         case wxTRANSPARENT:
         default:
             style = LineSolid;

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

             req_nb_dash = 0;
         }
 
             req_nb_dash = 0;
         }
 


@@ -1690,8 +1702,8 @@ void wxWindowDC::SetPen( const wxPen &pen )
         if (m_window && m_window->GetBackingPixmap())
             XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
     }
         if (m_window && m_window->GetBackingPixmap())
             XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
     }

-    else if (m_currentStipple.Ok()
-        && ((m_currentStipple != oldStipple) || !GET_OPTIMIZATION))
+    else if (m_currentStyle == wxSTIPPLE && m_currentStipple.IsOk()
+        && ((!m_currentStipple.IsSameAs(oldStipple)) || !GET_OPTIMIZATION))

     {
         XSetStipple ((Display*) m_display, (GC) m_gc, (Pixmap) m_currentStipple.GetDrawable());
 
     {
         XSetStipple ((Display*) m_display, (GC) m_gc, (Pixmap) m_currentStipple.GetDrawable());
 


@@ -1718,12 +1730,14 @@ void wxWindowDC::SetPen( const wxPen &pen )
     if (!sameColour || !GET_OPTIMIZATION
         || ((m_logicalFunction == wxXOR) || (m_autoSetting & 0x2)))
     {
     if (!sameColour || !GET_OPTIMIZATION
         || ((m_logicalFunction == wxXOR) || (m_autoSetting & 0x2)))
     {

-        int pixel = -1;
+        WXPixel pixel = -1;

         if (m_pen.GetStyle () == wxTRANSPARENT)
             pixel = m_backgroundPixel;
         else
         {
         if (m_pen.GetStyle () == wxTRANSPARENT)
             pixel = m_backgroundPixel;
         else
         {

-            pixel = CalculatePixel(m_pen.GetColour(), m_currentColour, false);
+            wxColour penClr = m_pen.GetColour();
+            pixel = CalculatePixel( penClr, m_currentColour, false);
+            m_pen.SetColour(penClr);

         }
 
         // Finally, set the GC to the required colour
         }
 
         // Finally, set the GC to the required colour


@@ -1736,13 +1750,13 @@ void wxWindowDC::SetPen( const wxPen &pen )
     m_autoSetting = 0;
 }
 
     m_autoSetting = 0;
 }
 

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

 {
 {

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

 
     m_brush = brush;
 
 
     m_brush = brush;
 

-    if (!m_brush.Ok() || m_brush.GetStyle () == wxTRANSPARENT)
+    if (!m_brush.IsOk() || m_brush.GetStyle () == wxTRANSPARENT)

         return;
 
     int oldFill = m_currentFill;
         return;
 
     int oldFill = m_currentFill;


@@ -1757,7 +1771,7 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
     wxColour oldBrushColour(m_currentColour);
     m_currentColour = m_brush.GetColour ();
 
     wxColour oldBrushColour(m_currentColour);
     m_currentColour = m_brush.GetColour ();
 

-    bool sameColour = (oldBrushColour.Ok () &&
+    bool sameColour = (oldBrushColour.IsOk () &&

         (oldBrushColour.Red () == m_currentColour.Red ()) &&
         (oldBrushColour.Blue () == m_currentColour.Blue ()) &&
         (oldBrushColour.Green () == m_currentColour.Green ()) &&
         (oldBrushColour.Red () == m_currentColour.Red ()) &&
         (oldBrushColour.Blue () == m_currentColour.Blue ()) &&
         (oldBrushColour.Green () == m_currentColour.Green ()) &&


@@ -1862,7 +1876,7 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
     // X can forget the stipple value when resizing a window (apparently)
     // so always set the stipple.
     else if (m_currentFill != wxSOLID && m_currentFill != wxTRANSPARENT &&
     // X can forget the stipple value when resizing a window (apparently)
     // so always set the stipple.
     else if (m_currentFill != wxSOLID && m_currentFill != wxTRANSPARENT &&

-             m_currentStipple.Ok()) // && m_currentStipple != oldStipple)
+             m_currentStipple.IsOk()) // && m_currentStipple != oldStipple)

     {
         if (m_currentStipple.GetDepth() == 1)
         {
     {
         if (m_currentStipple.GetDepth() == 1)
         {


@@ -1885,7 +1899,9 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
     // must test m_logicalFunction, because it involves background!
     if (!sameColour || !GET_OPTIMIZATION || m_logicalFunction == wxXOR)
     {
     // must test m_logicalFunction, because it involves background!
     if (!sameColour || !GET_OPTIMIZATION || m_logicalFunction == wxXOR)
     {

-        int pixel = CalculatePixel(m_brush.GetColour(), m_currentColour, true);
+        wxColour brushClr = m_brush.GetColour();
+        WXPixel pixel = CalculatePixel( brushClr, m_currentColour, true);
+        m_brush.SetColour(brushClr);

 
         if (pixel > -1)
             SetForegroundPixelWithLogicalFunction(pixel);
 
         if (pixel > -1)
             SetForegroundPixelWithLogicalFunction(pixel);


@@ -1894,13 +1910,13 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
         m_brush.GetColour().SetPixel(oldBrushColour.GetPixel());
 }
 
         m_brush.GetColour().SetPixel(oldBrushColour.GetPixel());
 }
 

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

 {
 {

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

 
     m_backgroundBrush = brush;
 
 
     m_backgroundBrush = brush;
 

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

         return;
 
     m_backgroundPixel = m_backgroundBrush.GetColour().AllocColour(m_display);
         return;
 
     m_backgroundPixel = m_backgroundBrush.GetColour().AllocColour(m_display);


@@ -1913,9 +1929,9 @@ void wxWindowDC::SetBackground( const wxBrush &brush )
                         m_backgroundPixel);
 }
 
                         m_backgroundPixel);
 }
 

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

 {
 {

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

 
     int x_function;
 
 
     int x_function;
 


@@ -1988,30 +2004,30 @@ void wxWindowDC::SetLogicalFunction( int function )
 
 }
 
 
 }
 

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

 {
 {

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

 
     m_textForegroundColour = col;
 }
 
 
     m_textForegroundColour = col;
 }
 

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

 {
 {

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

 
     m_textBackgroundColour = col;
 }
 
 
     m_textBackgroundColour = col;
 }
 

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

 {
     m_backgroundMode = mode;
 }
 
 {
     m_backgroundMode = mode;
 }
 

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

 {
     if (m_window)
     {
 {
     if (m_window)
     {

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

             /* Use GetXColormap */
             XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
             (Colormap) palette.GetXColormap());
             /* Use GetXColormap */
             XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
             (Colormap) palette.GetXColormap());


@@ -2030,9 +2046,9 @@ static void wxCopyRegion( WXRegion src, WXRegion& dst )
 }
 
 // Helper function; userRegion is the region set by calling SetClippingRegion
 }
 
 // Helper function; userRegion is the region set by calling SetClippingRegion

-void wxWindowDC::SetDCClipping( WXRegion userRegion )
+void wxWindowDCImpl::SetDCClipping( WXRegion userRegion )

 {
 {

-    bool hasUpdateRegion = m_window && m_window->GetUpdateRegion().Ok();
+    bool hasUpdateRegion = m_window && m_window->GetUpdateRegion().IsOk();

     // this means that we should start the clip region from scratch,
     // or from the update region, if any
     if( !userRegion )
     // this means that we should start the clip region from scratch,
     // or from the update region, if any
     if( !userRegion )


@@ -2062,12 +2078,13 @@ void wxWindowDC::SetDCClipping( WXRegion userRegion )
         XSetClipMask( (Display*)m_display, (GC)m_gc, None );
 }
 
         XSetClipMask( (Display*)m_display, (GC)m_gc, None );
 }
 

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

                                       wxCoord width, wxCoord height )
 {
                                       wxCoord width, wxCoord height )
 {

-    wxDC::DoSetClippingRegion( x, y, width, height );
+    wxMotifDCImpl::DoSetClippingRegion( x, y, width, height );

 
 

-    wxRegion temp(x, y, width, height);
+    wxRegion temp(XLOG2DEV(x), YLOG2DEV(y),
+                  XLOG2DEVREL(width), YLOG2DEVREL(height));

 
     SetDCClipping(temp.GetX11Region());
 
 
     SetDCClipping(temp.GetX11Region());
 


@@ -2085,32 +2102,30 @@ void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y,
     }
 }
 
     }
 }
 

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

 {
 {

-    wxRect box = region.GetBox();
-
-    wxDC::DoSetClippingRegion( box.x, box.y, box.width, box.height );
-

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

+        wxRect box = region.GetBox();
+

         XRectangle rects[1];
         XRectangle rects[1];

-        rects[0].x = (short)XLOG2DEV_2(box.x);
-        rects[0].y = (short)YLOG2DEV_2(box.y);
-        rects[0].width = (unsigned short)XLOG2DEVREL(box.width);
-        rects[0].height = (unsigned short)YLOG2DEVREL(box.height);
+        rects[0].x = (short)box.x;
+        rects[0].y = (short)box.y;
+        rects[0].width = (unsigned short)box.width;
+        rects[0].height = (unsigned short)box.height;

         XSetClipRectangles((Display*) m_display, (GC) m_gcBacking,
                            0, 0, rects, 1, Unsorted);
     }
 }
 
 
         XSetClipRectangles((Display*) m_display, (GC) m_gcBacking,
                            0, 0, rects, 1, Unsorted);
     }
 }
 
 

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

 {
 {

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

 
     SetDCClipping(NULL);
 
 
     SetDCClipping(NULL);
 


@@ -2119,13 +2134,13 @@ void wxWindowDC::DestroyClippingRegion()
 }
 
 // Resolution in pixels per logical inch
 }
 
 // Resolution in pixels per logical inch

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

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

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

 {
     // TODO
     return 24;
 {
     // TODO
     return 24;


@@ -2135,16 +2150,17 @@ int wxWindowDC::GetDepth() const
 
 
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------

-// wxPaintDC
+// wxPaintDCImpl

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-wxPaintDC::wxPaintDC(wxWindow* win) : wxWindowDC(win)
+wxPaintDCImpl::wxPaintDCImpl(wxDC *owner, wxWindow* win)
+             : wxWindowDCImpl(owner, win)

 {
     // Set the clipping region.to the update region
     SetDCClipping((WXRegion)NULL);
 }
 
 {
     // Set the clipping region.to the update region
     SetDCClipping((WXRegion)NULL);
 }
 

-wxPaintDC::~wxPaintDC()
+wxPaintDCImpl::~wxPaintDCImpl()

 {
     if (m_window)
         m_window->ClearUpdateRegion();
 {
     if (m_window)
         m_window->ClearUpdateRegion();


@@ -2173,7 +2189,7 @@ static void XCopyRemote(Display *src_display, Display *dest_display,
     static const int CACHE_SIZE = 256;
 
     unsigned int i, j;
     static const int CACHE_SIZE = 256;
 
     unsigned int i, j;

-    unsigned long cachesrc[CACHE_SIZE], cachedest[CACHE_SIZE];
+    Pixel cachesrc[CACHE_SIZE], cachedest[CACHE_SIZE];

     int k, cache_pos, all_cache;
 
     if (!cache || !*cache)
     int k, cache_pos, all_cache;
 
     if (!cache || !*cache)


@@ -2191,7 +2207,7 @@ static void XCopyRemote(Display *src_display, Display *dest_display,
 
     for (i = 0; i < w; i++)
         for (j = 0; j < h; j++) {
 
     for (i = 0; i < w; i++)
         for (j = 0; j < h; j++) {

-            unsigned long pixel;
+            Pixel pixel;

             XColor xcol;
 
             pixel = XGetPixel(image, i, j);
             XColor xcol;
 
             pixel = XGetPixel(image, i, j);


@@ -2225,25 +2241,9 @@ install:
         XPutImage(dest_display, dest, destgc, destimage, 0, 0, destx, desty, w, h);
         XDestroyImage(destimage);
 
         XPutImage(dest_display, dest, destgc, destimage, 0, 0, destx, desty, w, h);
         XDestroyImage(destimage);
 

-        if (more)
+        if (more && cache)

             *cache = image;
         else
             XDestroyImage(image);
 }
 
             *cache = image;
         else
             XDestroyImage(image);
 }
 

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