wxMotif compilation fixes after wxDC changes

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@50701 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/motif/dc.h

@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        wx/motif/dc.h
-// Purpose:     wxDC class
+// Purpose:     wxMotifDCImpl class
 // Author:      Julian Smart
 // Modified by:
 // Created:     17/09/98
@@ -12,48 +12,26 @@
 #ifndef _WX_DC_H_
 #define _WX_DC_H_
 
-#include "wx/pen.h"
+#include "wx/dc.h"
-#include "wx/brush.h"
-#include "wx/icon.h"
-#include "wx/font.h"
-#include "wx/gdicmn.h"
 
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
-// constants
+// wxMotifDCImpl
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
-#ifndef MM_TEXT
+class WXDLLEXPORT wxMotifDCImpl : public wxDCImpl
-#define MM_TEXT         0
-#define MM_ISOTROPIC    1
-#define MM_ANISOTROPIC  2
-#define MM_LOMETRIC     3
-#define MM_HIMETRIC     4
-#define MM_TWIPS        5
-#define MM_POINTS       6
-#define MM_METRIC       7
-#endif
-
-//-----------------------------------------------------------------------------
-// wxDC
-//-----------------------------------------------------------------------------
-
-class WXDLLEXPORT wxDC : public wxDCBase
 {
-    DECLARE_DYNAMIC_CLASS(wxDC)
-
 public:
-    wxDC();
+    wxMotifDCImpl(wxDC *owner);
-    virtual ~wxDC() { }
 
     virtual wxSize GetPPI() const;
 
 protected:
     virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y);
     virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
-        bool useMask = false);
+                              bool useMask = false);
 
     virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
-        wxCoord width, wxCoord height);
+                                     wxCoord width, wxCoord height);
     virtual void DoGetSize(int *width, int *height) const;
     virtual void DoGetSizeMM(int* width, int* height) const;
 
@@ -67,7 +45,7 @@ public:
     wxCoord XLOG2DEVREL(wxCoord x) const    { return LogicalToDeviceXRel(x); }
     wxCoord YLOG2DEV(wxCoord y) const       { return LogicalToDeviceY(y); }
     wxCoord YLOG2DEVREL(wxCoord y) const    { return LogicalToDeviceYRel(y); }
-    
+
     // Without device translation, for backing pixmap purposes
     wxCoord XLOG2DEV_2(wxCoord x) const
     {
@@ -78,7 +56,7 @@ public:
         return wxRound((double)(y - m_logicalOriginY) * m_scaleY) * m_signY;
     }
 
+    DECLARE_DYNAMIC_CLASS(wxMotifDCImpl)
 };
 
-#endif
+#endif // _WX_DC_H_
-// _WX_DC_H_

include/wx/motif/dcclient.h

@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        wx/motif/dcclient.h
-// Purpose:     wxClientDC, wxPaintDC and wxWindowDC classes
+// Purpose:     wxClientDCImpl, wxPaintDCImpl and wxWindowDCImpl classes
 // Author:      Julian Smart
 // Modified by:
 // Created:     17/09/98
@@ -12,31 +12,21 @@
 #ifndef _WX_DCCLIENT_H_
 #define _WX_DCCLIENT_H_
 
-#include "wx/dc.h"
+#include "wx/motif/dc.h"
 
-// ----------------------------------------------------------------------------
-// fwd declarations
-// ----------------------------------------------------------------------------
-
-class WXDLLIMPEXP_FWD_CORE wxWindowDC;
 class WXDLLIMPEXP_FWD_CORE wxWindow;
 
-// Under Windows, wxClientDC, wxPaintDC and wxWindowDC are implemented
-// differently. On many platforms, however, they will be the same.
-
 //-----------------------------------------------------------------------------
-// wxWindowDC
+// wxWindowDCImpl
 //-----------------------------------------------------------------------------
 
-class WXDLLEXPORT wxWindowDC : public wxDC
+class WXDLLEXPORT wxWindowDCImpl : public wxMotifDCImpl
 {
-    DECLARE_DYNAMIC_CLASS(wxWindowDC)
-
 public:
-    wxWindowDC();
+    wxWindowDCImpl(wxDC *owner);
-    wxWindowDC( wxWindow *win );
+    wxWindowDCImpl(wxDC *owner, wxWindow *win);
 
-    virtual ~wxWindowDC();
+    virtual ~wxWindowDCImpl();
 
     // TODO this function is Motif-only for now - should it go into base class?
     void Clear(const wxRect& rect);
@@ -164,26 +154,29 @@ protected:
     int          m_currentStyle ;
     int          m_currentFill ;
     int          m_autoSetting ; // See comment in dcclient.cpp
+
+    DECLARE_DYNAMIC_CLASS(wxWindowDCImpl)
 };
 
-class WXDLLEXPORT wxPaintDC: public wxWindowDC
+class WXDLLEXPORT wxPaintDCImpl: public wxWindowDCImpl
 {
-    DECLARE_DYNAMIC_CLASS(wxPaintDC)
-
 public:
-    wxPaintDC() { }
+    wxPaintDCImpl(wxDC *owner) : wxWindowDCImpl(owner) { }
-    wxPaintDC(wxWindow* win);
+    wxPaintDCImpl(wxDC *owner, wxWindow* win);
 
-    virtual ~wxPaintDC();
+    virtual ~wxPaintDCImpl();
+
+    DECLARE_DYNAMIC_CLASS(wxPaintDCImpl)
 };
 
-class WXDLLEXPORT wxClientDC: public wxWindowDC
+class WXDLLEXPORT wxClientDCImpl: public wxWindowDCImpl
 {
-    DECLARE_DYNAMIC_CLASS(wxClientDC)
-
 public:
-    wxClientDC() { }
+    wxClientDCImpl(wxDC *owner) : wxWindowDCImpl(owner) { }
-    wxClientDC(wxWindow* win) : wxWindowDC(win) { }
+    wxClientDCImpl(wxDC *owner, wxWindow* win)
+        : wxWindowDCImpl(owner, win) { }
+
+    DECLARE_DYNAMIC_CLASS(wxClientDCImpl)
 };
 
 #endif // _WX_DCCLIENT_H_

include/wx/motif/dcmemory.h

@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        wx/motif/dcmemory.h
-// Purpose:     wxMemoryDC class
+// Purpose:     wxMemoryDCImpl class
 // Author:      Julian Smart
 // Modified by:
 // Created:     17/09/98
@@ -12,23 +12,23 @@
 #ifndef _WX_DCMEMORY_H_
 #define _WX_DCMEMORY_H_
 
-#include "wx/dcclient.h"
+#include "wx/motif/dcclient.h"
 
-class WXDLLIMPEXP_CORE wxMemoryDC : public wxWindowDC, public wxMemoryDCBase
+class WXDLLIMPEXP_CORE wxMemoryDCImpl : public wxWindowDCImpl
 {
-    DECLARE_DYNAMIC_CLASS(wxMemoryDC)
-
 public:
-    wxMemoryDC() { Init(); }
+    wxMemoryDCImpl(wxMemoryDC *owner) : wxWindowDCImpl(owner) { Init(); }
-    wxMemoryDC(wxBitmap& bitmap) { Init(); SelectObject(bitmap); }
+    wxMemoryDCImpl(wxMemoryDC *owner, wxBitmap& bitmap)
-    wxMemoryDC( wxDC *dc ); // Create compatible DC
+        : wxWindowDCImpl(owner)
-    virtual ~wxMemoryDC();
+    {
+        Init();
+        DoSelect(bitmap);
+    }
 
-    void DoGetSize( int *width, int *height ) const;
+    wxMemoryDCImpl(wxMemoryDC *owner, wxDC *dc);
+    virtual ~wxMemoryDCImpl();
 
-    wxBitmap& GetBitmap() const { return (wxBitmap&) m_bitmap; }
+    virtual void DoGetSize( int *width, int *height ) const;
-
-protected:
     virtual void DoSelect(const wxBitmap& bitmap);
 
 private:
@@ -36,7 +36,9 @@ private:
 
     void Init();
 
-    wxBitmap  m_bitmap;
+    wxBitmap m_bitmap;
+
+    DECLARE_DYNAMIC_CLASS(wxMemoryDCImpl)
 };
 
 #endif

include/wx/motif/dcprint.h

@@ -12,20 +12,21 @@
 #ifndef _WX_DCPRINT_H_
 #define _WX_DCPRINT_H_
 
-#include "wx/dc.h"
+#include "wx/motif/dc.h"
 
-class WXDLLEXPORT wxPrinterDC: public wxDC
+class WXDLLEXPORT wxPrinterDC : public wxMotifDCImpl
 {
 public:
-    DECLARE_CLASS(wxPrinterDC)
-
     // Create a printer DC
-    wxPrinterDC(const wxString& driver, const wxString& device, const wxString& output, bool interactive = true, int orientation = wxPORTRAIT);
+    wxPrinterDCImpl(const wxString& driver, const wxString& device,
+                    const wxString& output,
+                    bool interactive = true,
+                    int orientation = wxPORTRAIT);
+    virtual ~wxPrinterDC();
 
     wxRect GetPaperRect();
 
-    virtual ~wxPrinterDC();
+    DECLARE_CLASS(wxPrinterDCImpl)
 };
 
-#endif
+#endif // _WX_DCPRINT_H_
-// _WX_DCPRINT_H_

include/wx/motif/dcscreen.h

@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        wx/motif/dcscreen.h
-// Purpose:     wxScreenDC class
+// Purpose:     wxScreenDCImpl class
 // Author:      Julian Smart
 // Modified by:
 // Created:     17/09/98
@@ -12,16 +12,14 @@
 #ifndef _WX_DCSCREEN_H_
 #define _WX_DCSCREEN_H_
 
-#include "wx/dcclient.h"
+#include "wx/motif/dcclient.h"
 
-class WXDLLEXPORT wxScreenDC: public wxWindowDC
+class WXDLLEXPORT wxScreenDCImpl : public wxWindowDCImpl
 {
-    DECLARE_DYNAMIC_CLASS(wxScreenDC)
-
 public:
     // Create a DC representing the whole screen
-    wxScreenDC();
+    wxScreenDCImpl(wxScreenDC *owner);
-    virtual ~wxScreenDC();
+    virtual ~wxScreenDCImpl();
 
     // Compatibility with X's requirements for
     // drawing on top of all windows
@@ -37,7 +35,8 @@ private:
     // constructor.
     static int sm_overlayWindowX;
     static int sm_overlayWindowY;
+
+    DECLARE_DYNAMIC_CLASS(wxScreenDCImpl)
 };
 
-#endif
+#endif // _WX_DCSCREEN_H_
-// _WX_DCSCREEN_H_

src/common/dcbase.cpp

@@ -60,6 +60,12 @@
     #include "wx/cocoa/dcscreen.h"
 #endif
 
+#ifdef __WXMOTIF__
+    #include "wx/motif/dcclient.h"
+    #include "wx/motif/dcmemory.h"
+    #include "wx/motif/dcscreen.h"
+#endif
+
 #ifdef __WXX11__
     #include "wx/x11/dcclient.h"
     #include "wx/x11/dcmemory.h"

src/common/prntbase.cpp

@@ -209,7 +209,7 @@ wxDialog *wxNativePrintFactory::CreatePrintSetupDialog( wxWindow *parent,
 
 wxDCImpl* wxNativePrintFactory::CreatePrinterDCImpl( wxPrinterDC *owner, const wxPrintData& data )
 {
-#if defined(__WXGTK__) || defined(__WXUNIVERSAL__)
+#if defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXUNIVERSAL__)
     return new wxPostScriptDCImpl( owner, data );
 #else
     return new wxPrinterDCImpl( owner, data );

src/motif/dc.cpp

@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        src/motif/dc.cpp
-// Purpose:     wxDC class
+// Purpose:     wxMotifDCImpl class
 // Author:      Julian Smart
 // Modified by:
 // Created:     01/02/97
@@ -12,36 +12,35 @@
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
-#include "wx/dc.h"
-
 #ifndef WX_PRECOMP
     #include "wx/dcmemory.h"
 #endif
 
-IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
+#include "wx/motif/dc.h"
+
+IMPLEMENT_ABSTRACT_CLASS(wxMotifDCImpl, wxDCImpl)
 
 //-----------------------------------------------------------------------------
-// wxDC
+// wxMotifDCImpl
 //-----------------------------------------------------------------------------
 
-wxDC::wxDC()
+wxMotifDCImpl::wxMotifDCImpl(wxDC *owner)
+             : wxDCImpl(owner)
 {
     m_ok = false;
 
     m_backgroundMode = wxTRANSPARENT;
-
-    m_isInteractive = false;
 }
 
-void wxDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y)
+void wxMotifDCImpl::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y)
 {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
     wxCHECK_RET( icon.Ok(), "invalid icon" );
 
     DoDrawBitmap(icon, x, y, true);
 }
 
-void wxDC::DoDrawBitmap( const wxBitmap& bitmap, wxCoord x, wxCoord y, bool useMask )
+void wxMotifDCImpl::DoDrawBitmap( const wxBitmap& bitmap, wxCoord x, wxCoord y, bool useMask )
 {
     wxCHECK_RET( bitmap.Ok(), "invalid bitmap" );
 
@@ -60,12 +59,12 @@ void wxDC::DoDrawBitmap( const wxBitmap& bitmap, wxCoord x, wxCoord y, bool useM
     }
 #endif // 0
 
-    Blit(x, y, bitmap.GetWidth(), bitmap.GetHeight(), &memDC, 0, 0, wxCOPY, useMask);
+    DoBlit(x, y, bitmap.GetWidth(), bitmap.GetHeight(), &memDC, 0, 0, wxCOPY, useMask);
 
     memDC.SelectObject(wxNullBitmap);
 }
 
-void wxDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
+void wxMotifDCImpl::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 {
     m_clipping = true;
     m_clipX1 = x;
@@ -74,7 +73,7 @@ void wxDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
     m_clipY2 = y + height;
 }
 
-void wxDC::DoGetSize( int* width, int* height ) const
+void wxMotifDCImpl::DoGetSize( int* width, int* height ) const
 {
     if ( width )
         *width = m_maxX - m_minX;
@@ -82,7 +81,7 @@ void wxDC::DoGetSize( int* width, int* height ) const
         *height = m_maxY - m_minY;
 }
 
-void wxDC::DoGetSizeMM( int* width, int* height ) const
+void wxMotifDCImpl::DoGetSizeMM( int* width, int* height ) const
 {
     int w, h;
     GetSize( &w, &h );
@@ -94,7 +93,7 @@ void wxDC::DoGetSizeMM( int* width, int* height ) const
 }
 
 // Resolution in pixels per logical inch
-wxSize wxDC::GetPPI() const
+wxSize wxMotifDCImpl::GetPPI() const
 {
     // TODO (should probably be pure virtual)
     return wxSize(0, 0);

src/motif/dcclient.cpp

@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        src/motif/dcclient.cpp
-// Purpose:     wxClientDC class
+// Purpose:     wxClientDCImpl class
 // Author:      Julian Smart
 // Modified by:
 // Created:     01/02/97
@@ -39,8 +39,6 @@
 // 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"
@@ -59,6 +57,7 @@
 #endif
 
 #include "wx/motif/private.h"
+#include "wx/motif/dcclient.h"
 
 #ifdef __EMX__
     #include <float.h>          // for M_PI
@@ -84,9 +83,9 @@ static Pixmap bdiag, cdiag, fdiag, cross, horiz, verti;
 // macros
 // ----------------------------------------------------------------------------
 
-IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
+IMPLEMENT_ABSTRACT_CLASS(wxClientDCImpl, wxWindowDCImpl)
-IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxWindowDC)
+IMPLEMENT_ABSTRACT_CLASS(wxPaintDCImpl, wxWindowDCImpl)
-IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
+IMPLEMENT_ABSTRACT_CLASS(wxWindowDCImpl, wxMotifDCImpl)
 
 #define IS_HATCH(s)    ((s)>=wxFIRST_HATCH && (s)<=wxLAST_HATCH)
 
@@ -129,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;
@@ -152,14 +151,16 @@ void wxWindowDC::Init()
     m_clipRegion = (WXRegion) 0;
 }
 
-wxWindowDC::wxWindowDC()
+wxWindowDCImpl::wxWindowDCImpl(wxDC *owner)
+              : wxMotifDCImpl(owner)
 {
     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 != (wxWindow*) NULL), "You must pass a valid wxWindow to wxWindowDCImpl/wxClientDCImpl/wxPaintDCImpl constructor." );
 
     Init();
 
@@ -204,7 +205,7 @@ wxWindowDC::wxWindowDC( wxWindow *window )
     SetBackground(wxBrush(m_window->GetBackgroundColour(), wxSOLID));
 }
 
-wxWindowDC::~wxWindowDC()
+wxWindowDCImpl::~wxWindowDCImpl()
 {
     if (m_gc)
         XFreeGC ((Display*) m_display, (GC) m_gc);
@@ -222,13 +223,13 @@ wxWindowDC::~wxWindowDC()
 extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
                           const wxColour & col, int style);
 
-bool wxWindowDC::DoFloodFill(wxCoord x, wxCoord y,
+bool wxWindowDCImpl::DoFloodFill(wxCoord x, wxCoord y,
                              const wxColour& col, int 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.
@@ -242,9 +243,9 @@ bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
     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;
 
@@ -267,9 +268,9 @@ void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord 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);
@@ -296,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);
@@ -350,7 +351,7 @@ void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCo
     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,
@@ -362,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);
@@ -377,9 +378,9 @@ void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCo
     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;
 
@@ -397,7 +398,7 @@ void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord
     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
 
@@ -409,7 +410,7 @@ void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord
             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);
@@ -422,11 +423,11 @@ void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord
     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));
@@ -436,11 +437,11 @@ void wxWindowDC::DoDrawPoint( wxCoord x, wxCoord y )
     CalcBoundingBox (x, y);
 }
 
-void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset )
+void wxWindowDCImpl::DoDrawLines( int n, 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);
@@ -468,10 +469,10 @@ void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord
     }
 }
 
-void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
+void wxWindowDCImpl::DoDrawPolygon( int n, wxPoint points[],
                                 wxCoord xoffset, wxCoord yoffset, int fillStyle )
 {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
 
     XPoint *xpoints1 = new XPoint[n + 1];
     XPoint *xpoints2 = new XPoint[n + 1];
@@ -491,7 +492,7 @@ void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
     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);
@@ -506,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);
@@ -520,9 +521,9 @@ void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
     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;
 
@@ -537,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 (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);
@@ -548,7 +549,7 @@ void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord h
             wfd, hfd);
     }
 
-    if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
     {
         if (m_autoSetting)
             SetPen (m_pen);
@@ -563,9 +564,9 @@ void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord h
     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.
 
@@ -584,7 +585,7 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
     // X drawing errors with small radii
     if (rd == 0)
     {
-        DrawRectangle( x, y, width, height );
+        DoDrawRectangle( x, y, width, height );
         return;
     }
 
@@ -615,7 +616,7 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
     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);
 
@@ -665,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,
@@ -723,9 +724,9 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
     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)
@@ -749,7 +750,7 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
     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);
@@ -760,7 +761,7 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
             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);
@@ -776,26 +777,31 @@ 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
-bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
+bool wxWindowDCImpl::DoBlit( wxCoord xdest, wxCoord ydest,
                          wxCoord width, wxCoord height,
                          wxDC *source, wxCoord xsrc, wxCoord ysrc,
                          int rop, bool useMask,
                          wxCoord xsrcMask, wxCoord ysrcMask )
 {
-    wxCHECK_MSG( Ok(), false, "invalid dc" );
+    wxCHECK_MSG( IsOk(), false, "invalid dc" );
 
-    wxWindowDC* sourceDC = wxDynamicCast(source, wxWindowDC);
+    wxWindowDC const * sourceDC = wxDynamicCast(source, wxWindowDC);
+    wxCHECK_MSG( sourceDC, false, "Blit source DC must be wxWindowDCImpl or derived class." );
+
+    // cast is safe in virtue of the above wxCHECK_MSG()
+    const wxWindowDCImpl * const
+        srcImpl = static_cast<const wxWindowDCImpl *>(sourceDC->GetImpl());
+    WXDisplay * const srcDpy = srcImpl->m_display;
 
-    wxASSERT_MSG( sourceDC, "Blit source DC must be wxWindowDC or derived class." );
 
     // Be sure that foreground pixels (1) of the Icon will be painted with
     // foreground colour. [m_textForegroundColour] Background pixels (0)
@@ -804,7 +810,7 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
     WXPixel oldBackgroundPixel = -1;
     WXPixel oldForegroundPixel = -1;
 
-    if (m_textBackgroundColour.Ok())
+    if (m_textBackgroundColour.IsOk())
     {
         oldBackgroundPixel = m_backgroundPixel;
         WXPixel pixel = m_textBackgroundColour.AllocColour(m_display);
@@ -814,7 +820,7 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
             XSetBackground ((Display*) m_display,(GC) m_gcBacking,
                             pixel);
     }
-    if (m_textForegroundColour.Ok())
+    if (m_textForegroundColour.IsOk())
     {
         oldForegroundPixel = m_currentColour.GetPixel();
 
@@ -845,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;
-        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();
-        if (!image.Ok())
+        if (!image.IsOk())
         {
             sourcePixmap = (Pixmap) bitmap.GetDrawable();
         }
@@ -865,7 +871,9 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
         }
     }
     else
-        sourcePixmap = (Pixmap) sourceDC->m_pixmap;
+    {
+        sourcePixmap = (Pixmap) srcImpl->m_pixmap;
+    }
 
     if (m_pixmap && sourcePixmap)
     {
@@ -874,12 +882,12 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
 
         SetLogicalFunction (rop);
 
-        if (m_display != sourceDC->m_display)
+        if (m_display != srcDpy)
         {
             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),
@@ -892,15 +900,15 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
             if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
             {
                 wxMemoryDC *memDC = (wxMemoryDC *)source;
-                wxBitmap& sel = memDC->GetBitmap();
+                wxBitmap& sel = memDC->GetSelectedBitmap();
-                if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetBitmap() )
+                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));
                 }
             }
 
-            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),
@@ -926,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 (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),
@@ -948,8 +956,8 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
             if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
             {
                 wxMemoryDC *memDC = (wxMemoryDC *)source;
-                wxBitmap& sel = memDC->GetBitmap();
+                wxBitmap& sel = memDC->GetSelectedBitmap();
-                if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetBitmap() )
+                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));
@@ -958,7 +966,8 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
 
             // 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),
@@ -1016,9 +1025,9 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
   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;
@@ -1038,17 +1047,17 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
         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
-    if (m_textBackgroundColour.Ok () && (m_backgroundMode != wxTRANSPARENT))
+    if (m_textBackgroundColour.IsOk () && (m_backgroundMode != wxTRANSPARENT))
     {
         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 ()));
@@ -1081,11 +1090,11 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
     }
 
     // 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;
-        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 ()) &&
@@ -1149,33 +1158,33 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
                        gcBackingV.fill_style);
 
     wxCoord w, h;
-    GetTextExtent (text, &w, &h);
+    DoGetTextExtent (text, &w, &h);
     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)
     {
-        DrawText(text, x, y);
+        DoDrawText(text, x, y);
         return;
     }
 
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
 
     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);
     }
-    if (m_textForegroundColour.Ok())
+    if (m_textForegroundColour.IsOk())
     {
         oldForegroundPixel = m_currentColour.GetPixel();
 
@@ -1191,7 +1200,7 @@ void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y,
     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);
 
@@ -1290,20 +1299,20 @@ void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y,
     CalcBoundingBox (maxx, maxy);
 }
 
-bool wxWindowDC::CanGetTextExtent() const
+bool wxWindowDCImpl::CanGetTextExtent() const
 {
     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,
                                 const wxFont *font ) const
 {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
 
     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!");
@@ -1322,10 +1331,10 @@ void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoor
         *externalLeading = 0;
 }
 
-wxCoord wxWindowDC::GetCharWidth() const
+wxCoord wxWindowDCImpl::GetCharWidth() const
 {
-    wxCHECK_MSG( Ok(), 0, "invalid dc" );
+    wxCHECK_MSG( IsOk(), 0, "invalid dc" );
-    wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
+    wxCHECK_MSG( m_font.IsOk(), 0, "invalid font" );
 
     int width;
 
@@ -1335,10 +1344,10 @@ wxCoord wxWindowDC::GetCharWidth() const
     return XDEV2LOGREL(width);
 }
 
-wxCoord wxWindowDC::GetCharHeight() const
+wxCoord wxWindowDCImpl::GetCharHeight() const
 {
-    wxCHECK_MSG( Ok(), 0, "invalid dc" );
+    wxCHECK_MSG( IsOk(), 0, "invalid dc" );
-    wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
+    wxCHECK_MSG( m_font.IsOk(), 0, "invalid font" );
 
     int height;
 
@@ -1348,7 +1357,7 @@ wxCoord wxWindowDC::GetCharHeight() const
     return XDEV2LOGREL(height);
 }
 
-void wxWindowDC::DoGetSize( int *width, int *height ) const
+void wxWindowDCImpl::DoGetSize( int *width, int *height ) const
 {
     int w = 0, h = 0;
 
@@ -1367,17 +1376,17 @@ void wxWindowDC::DoGetSize( int *width, int *height ) const
     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 );
 }
 
-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;
@@ -1396,13 +1405,13 @@ void wxWindowDC::Clear(const wxRect& rect)
     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;
 
-    if (!m_font.Ok())
+    if (!m_font.IsOk())
     {
         return;
     }
@@ -1418,7 +1427,7 @@ void wxWindowDC::SetFont( const wxFont &font )
 #endif
 }
 
-void wxWindowDC::SetForegroundPixelWithLogicalFunction(WXPixel pixel)
+void wxWindowDCImpl::SetForegroundPixelWithLogicalFunction(WXPixel pixel)
 {
     if (m_logicalFunction == wxXOR)
     {
@@ -1438,7 +1447,7 @@ void wxWindowDC::SetForegroundPixelWithLogicalFunction(WXPixel pixel)
     }
 }
 
-WXPixel wxWindowDC::CalculatePixel(wxColour& colour, wxColour& curCol,
+WXPixel wxWindowDCImpl::CalculatePixel(wxColour& colour, wxColour& curCol,
                                bool roundToWhite) const
 {
     const unsigned char wp = (unsigned char)255;
@@ -1479,12 +1488,12 @@ WXPixel wxWindowDC::CalculatePixel(wxColour& colour, wxColour& curCol,
     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;
-    if (!m_pen.Ok())
+    if (!m_pen.IsOk())
         return;
 
     wxBitmap oldStipple = m_currentStipple;
@@ -1517,7 +1526,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
         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 ()) &&
@@ -1693,7 +1702,7 @@ void wxWindowDC::SetPen( const wxPen &pen )
         if (m_window && m_window->GetBackingPixmap())
             XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
     }
-    else if (m_currentStyle == wxSTIPPLE && m_currentStipple.Ok()
+    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());
@@ -1739,13 +1748,13 @@ void wxWindowDC::SetPen( const wxPen &pen )
     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;
 
-    if (!m_brush.Ok() || m_brush.GetStyle () == wxTRANSPARENT)
+    if (!m_brush.IsOk() || m_brush.GetStyle () == wxTRANSPARENT)
         return;
 
     int oldFill = m_currentFill;
@@ -1760,7 +1769,7 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
     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 ()) &&
@@ -1865,7 +1874,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 &&
-             m_currentStipple.Ok()) // && m_currentStipple != oldStipple)
+             m_currentStipple.IsOk()) // && m_currentStipple != oldStipple)
     {
         if (m_currentStipple.GetDepth() == 1)
         {
@@ -1897,13 +1906,13 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
         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;
 
-    if (!m_backgroundBrush.Ok())
+    if (!m_backgroundBrush.IsOk())
         return;
 
     m_backgroundPixel = m_backgroundBrush.GetColour().AllocColour(m_display);
@@ -1916,9 +1925,9 @@ void wxWindowDC::SetBackground( const wxBrush &brush )
                         m_backgroundPixel);
 }
 
-void wxWindowDC::SetLogicalFunction( int function )
+void wxWindowDCImpl::SetLogicalFunction( int function )
 {
-    wxCHECK_RET( Ok(), "invalid dc" );
+    wxCHECK_RET( IsOk(), "invalid dc" );
 
     int x_function;
 
@@ -1991,30 +2000,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;
 }
 
-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;
 }
 
-void wxWindowDC::SetBackgroundMode( int mode )
+void wxWindowDCImpl::SetBackgroundMode( int mode )
 {
     m_backgroundMode = mode;
 }
 
-void wxWindowDC::SetPalette( const wxPalette& palette )
+void wxWindowDCImpl::SetPalette( const wxPalette& palette )
 {
     if (m_window)
     {
-        if (palette.Ok())
+        if (palette.IsOk())
             /* Use GetXColormap */
             XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
             (Colormap) palette.GetXColormap());
@@ -2033,9 +2042,9 @@ static void wxCopyRegion( WXRegion src, WXRegion& dst )
 }
 
 // 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 )
@@ -2065,10 +2074,10 @@ void wxWindowDC::SetDCClipping( WXRegion userRegion )
         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 )
 {
-    wxDC::DoSetClippingRegion( x, y, width, height );
+    wxMotifDCImpl::DoSetClippingRegion( x, y, width, height );
 
     wxRegion temp(XLOG2DEV(x), YLOG2DEV(y),
                   XLOG2DEVREL(width), YLOG2DEVREL(height));
@@ -2089,7 +2098,7 @@ void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y,
     }
 }
 
-void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion& region )
+void wxWindowDCImpl::DoSetClippingRegionAsRegion( const wxRegion& region )
 {
     SetDCClipping(region.GetX11Region());
 
@@ -2110,9 +2119,9 @@ void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion& region )
 }
 
 
-void wxWindowDC::DestroyClippingRegion()
+void wxWindowDCImpl::DestroyClippingRegion()
 {
-    wxDC::DestroyClippingRegion();
+    wxMotifDCImpl::DestroyClippingRegion();
 
     SetDCClipping(NULL);
 
@@ -2121,13 +2130,13 @@ void wxWindowDC::DestroyClippingRegion()
 }
 
 // Resolution in pixels per logical inch
-wxSize wxWindowDC::GetPPI() const
+wxSize wxWindowDCImpl::GetPPI() const
 {
     // TODO
     return wxSize(100, 100);
 }
 
-int wxWindowDC::GetDepth() const
+int wxWindowDCImpl::GetDepth() const
 {
     // TODO
     return 24;
@@ -2137,16 +2146,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);
 }
 
-wxPaintDC::~wxPaintDC()
+wxPaintDCImpl::~wxPaintDCImpl()
 {
     if (m_window)
         m_window->ClearUpdateRegion();
@@ -2233,19 +2243,3 @@ install:
             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

src/motif/dcmemory.cpp

@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        src/motif/dcmemory.cpp
-// Purpose:     wxMemoryDC class
+// Purpose:     wxMemoryDCImpl class
 // Author:      Julian Smart
 // Modified by:
 // Created:     01/02/97
@@ -12,8 +12,6 @@
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
-#include "wx/dcmemory.h"
-
 #ifndef WX_PRECOMP
     #include "wx/utils.h"
     #include "wx/settings.h"
@@ -28,14 +26,15 @@
 #endif
 
 #include "wx/motif/private.h"
+#include "wx/motif/dcmemory.h"
 
 //-----------------------------------------------------------------------------
-// wxMemoryDC
+// wxMemoryDCImpl
 //-----------------------------------------------------------------------------
 
-IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxWindowDC)
+IMPLEMENT_ABSTRACT_CLASS(wxMemoryDCImpl, wxWindowDCImpl)
 
-void wxMemoryDC::Init()
+void wxMemoryDCImpl::Init()
 {
     m_ok = true;
     m_display = wxGetDisplay();
@@ -59,11 +58,12 @@ void wxMemoryDC::Init()
     SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 }
 
-wxMemoryDC::wxMemoryDC( wxDC* dc )
+wxMemoryDCImpl::wxMemoryDCImpl(wxMemoryDC *owner, wxDC* dc)
+              : wxWindowDCImpl(owner)
 {
     m_ok = true;
     if (dc && dc->IsKindOf(CLASSINFO(wxWindowDC)))
-        m_display = ((wxWindowDC*)dc)->GetDisplay();
+        m_display = ((wxWindowDCImpl *)dc->GetImpl())->GetDisplay();
     else
         m_display = wxGetDisplay();
 
@@ -85,11 +85,11 @@ wxMemoryDC::wxMemoryDC( wxDC* dc )
     SetPen (* wxBLACK_PEN);
 }
 
-wxMemoryDC::~wxMemoryDC(void)
+wxMemoryDCImpl::~wxMemoryDCImpl(void)
 {
 }
 
-void wxMemoryDC::DoSelect( const wxBitmap& bitmap )
+void wxMemoryDCImpl::DoSelect( const wxBitmap& bitmap )
 {
     m_bitmap = bitmap;
 
@@ -125,7 +125,7 @@ void wxMemoryDC::DoSelect( const wxBitmap& bitmap )
     };
 }
 
-void wxMemoryDC::DoGetSize( int *width, int *height ) const
+void wxMemoryDCImpl::DoGetSize( int *width, int *height ) const
 {
     if (m_bitmap.Ok())
     {

src/motif/dcscreen.cpp

@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        src/motif/dcscreen.cpp
-// Purpose:     wxScreenDC class
+// Purpose:     wxScreenDCImpl class
 // Author:      Julian Smart
 // Modified by:
 // Created:     17/09/98
@@ -12,8 +12,6 @@
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
-#include "wx/dcscreen.h"
-
 #ifndef WX_PRECOMP
     #include "wx/utils.h"
     #include "wx/window.h"
@@ -29,15 +27,17 @@
 #endif
 
 #include "wx/motif/private.h"
+#include "wx/motif/dcscreen.h"
 
-IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxWindowDC)
+IMPLEMENT_ABSTRACT_CLASS(wxScreenDCImpl, wxWindowDCImpl)
 
-WXWindow wxScreenDC::sm_overlayWindow = 0;
+WXWindow wxScreenDCImpl::sm_overlayWindow = 0;
-int wxScreenDC::sm_overlayWindowX = 0;
+int wxScreenDCImpl::sm_overlayWindowX = 0;
-int wxScreenDC::sm_overlayWindowY = 0;
+int wxScreenDCImpl::sm_overlayWindowY = 0;
 
 // Create a DC representing the whole screen
-wxScreenDC::wxScreenDC()
+wxScreenDCImpl::wxScreenDCImpl(wxScreenDC *owner)
+              : wxWindowDCImpl(owner)
 {
     m_display = wxGetDisplay();
     Display* display = (Display*) m_display;
@@ -65,12 +65,12 @@ wxScreenDC::wxScreenDC()
     m_ok = true;
 }
 
-wxScreenDC::~wxScreenDC()
+wxScreenDCImpl::~wxScreenDCImpl()
 {
     EndDrawingOnTop();
 }
 
-bool wxScreenDC::StartDrawingOnTop(wxWindow* window)
+bool wxScreenDCImpl::StartDrawingOnTop(wxWindow* window)
 {
     wxRect rect;
     int x, y, width, height;
@@ -84,7 +84,7 @@ bool wxScreenDC::StartDrawingOnTop(wxWindow* window)
     return StartDrawingOnTop(& rect);
 }
 
-bool wxScreenDC::StartDrawingOnTop(wxRect* rect)
+bool wxScreenDCImpl::StartDrawingOnTop(wxRect* rect)
 {
     if (sm_overlayWindow)
         return false;
@@ -123,7 +123,7 @@ bool wxScreenDC::StartDrawingOnTop(wxRect* rect)
         return false;
 }
 
-bool wxScreenDC::EndDrawingOnTop()
+bool wxScreenDCImpl::EndDrawingOnTop()
 {
     if (sm_overlayWindow)
     {

src/motif/window.cpp

@@ -80,6 +80,7 @@
 #endif
 
 #include "wx/motif/private.h"
+#include "wx/motif/dcclient.h"
 
 #include <string.h>
 
@@ -880,6 +881,9 @@ void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
     int y2 = (dy >= 0) ? y + dy : y;
 
     wxClientDC dc(this);
+    wxClientDCImpl * const
+        dcimpl = static_cast<wxClientDCImpl *>(dc.GetImpl());
+    GC const gc = (GC) dcimpl->GetGC();
 
     dc.SetLogicalFunction (wxCOPY);
 
@@ -887,10 +891,9 @@ void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
     Window window = XtWindow(widget);
     Display* display = XtDisplay(widget);
 
-    XCopyArea(display, window, window, (GC) dc.GetGC(),
+    XCopyArea(display, window, window, gc, x1, y1, w1, h1, x2, y2);
-              x1, y1, w1, h1, x2, y2);
 
-    dc.SetAutoSetting(true);
+    dcimpl->SetAutoSetting(true);
     wxBrush brush(GetBackgroundColour(), wxSOLID);
     dc.SetBrush(brush); // FIXME: needed?
 
@@ -918,8 +921,7 @@ void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
         rect->width = dx;
         rect->height = h;
 
-        XFillRectangle(display, window,
+        XFillRectangle(display, window, gc, rect->x, rect->y, rect->width, rect->height);
-            (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
 
         rect->x = rect->x;
         rect->y = rect->y;
@@ -937,9 +939,7 @@ void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
         rect->width = -dx;
         rect->height = h;
 
-        XFillRectangle(display, window,
+        XFillRectangle(display, window, gc, rect->x, rect->y, rect->width, rect->height);
-            (GC) dc.GetGC(), rect->x, rect->y, rect->width,
-            rect->height);
 
         rect->x = rect->x;
         rect->y = rect->y;
@@ -957,8 +957,7 @@ void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
         rect->width = w;
         rect->height = dy;
 
-        XFillRectangle(display, window,
+        XFillRectangle(display, window, gc, rect->x, rect->y, rect->width, rect->height);
-            (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
 
         rect->x = rect->x;
         rect->y = rect->y;
@@ -976,8 +975,7 @@ void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
         rect->width = w;
         rect->height = -dy;
 
-        XFillRectangle(display, window,
+        XFillRectangle(display, window, gc, rect->x, rect->y, rect->width, rect->height);
-            (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
 
         rect->x = rect->x;
         rect->y = rect->y;
@@ -1549,10 +1547,13 @@ void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
         wxClientDC dc(this);
         wxBrush backgroundBrush(GetBackgroundColour(), wxSOLID);
         dc.SetBackground(backgroundBrush);
+
+        wxClientDCImpl * const
+            dcimpl = static_cast<wxClientDCImpl *>(dc.GetImpl());
         if (rect)
-            dc.Clear(*rect);
+            dcimpl->Clear(*rect);
         else
-            dc.Clear();
+            dcimpl->Clear();
     }
 
     XSendEvent(display, thisWindow, False, ExposureMask, (XEvent *)&dummyEvent);
@@ -1565,7 +1566,10 @@ void wxWindow::DoPaint()
     {
       wxPaintDC dc(this);
 
-      GC tempGC = (GC) dc.GetBackingGC();
+      wxPaintDCImpl * const
+          dcimpl = static_cast<wxPaintDCImpl *>(dc.GetImpl());
+
+      GC tempGC = (GC) dcimpl->GetBackingGC();
 
       Widget widget = (Widget) GetMainWidget();