Define wxLongLong_t for Intel compiler.

[wxWidgets.git] / src / common / dcbase.cpp

diff --git a/src/common/dcbase.cpp b/src/common/dcbase.cpp
index d659598d0e068d8b719fc5fa23e187cdeb047cbd..7f712f5b97d43988271679e53b8709ea0b721d86 100644 (file)
--- a/src/common/dcbase.cpp
+++ b/src/common/dcbase.cpp
@@ -25,25 +25,308 @@
 #endif
 
 #include "wx/dc.h"
 #endif
 
 #include "wx/dc.h"

-#include "wx/dcbuffer.h" // for IMPLEMENT_DYNAMIC_CLASS
+#include "wx/dcclient.h"
+#include "wx/dcmemory.h"
+#include "wx/dcscreen.h"
+#include "wx/dcprint.h"
+#include "wx/prntbase.h"
+#include "wx/scopeguard.h"

 
 #ifndef WX_PRECOMP
     #include "wx/math.h"
 
 #ifndef WX_PRECOMP
     #include "wx/math.h"

+    #include "wx/module.h"
+    #include "wx/window.h"

 #endif
 
 #endif
 

-// bool wxDCBase::sm_cacheing = false;
+#include "wx/private/textmeasure.h"

 
 

-IMPLEMENT_ABSTRACT_CLASS(wxDCBase, wxObject)
+#ifdef __WXMSW__
+    #include "wx/msw/dcclient.h"
+    #include "wx/msw/dcmemory.h"
+    #include "wx/msw/dcscreen.h"
+#endif

 
 

-// ============================================================================
-// implementation
-// ============================================================================
+#ifdef __WXGTK3__
+    #include "wx/gtk/dc.h"
+#elif defined __WXGTK20__
+    #include "wx/gtk/dcclient.h"
+    #include "wx/gtk/dcmemory.h"
+    #include "wx/gtk/dcscreen.h"
+#elif defined(__WXGTK__)
+    #include "wx/gtk1/dcclient.h"
+    #include "wx/gtk1/dcmemory.h"
+    #include "wx/gtk1/dcscreen.h"
+#endif
+
+#ifdef __WXMAC__
+    #include "wx/osx/dcclient.h"
+    #include "wx/osx/dcmemory.h"
+    #include "wx/osx/dcscreen.h"
+#endif
+
+#ifdef __WXPM__
+    #include "wx/os2/dcclient.h"
+    #include "wx/os2/dcmemory.h"
+    #include "wx/os2/dcscreen.h"
+#endif
+
+#ifdef __WXCOCOA__
+    #include "wx/cocoa/dcclient.h"
+    #include "wx/cocoa/dcmemory.h"
+    #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"
+    #include "wx/x11/dcscreen.h"
+#endif
+
+#ifdef __WXDFB__
+    #include "wx/dfb/dcclient.h"
+    #include "wx/dfb/dcmemory.h"
+    #include "wx/dfb/dcscreen.h"
+#endif
+
+//----------------------------------------------------------------------------
+// wxDCFactory
+//----------------------------------------------------------------------------
+
+wxDCFactory *wxDCFactory::m_factory = NULL;
+
+void wxDCFactory::Set(wxDCFactory *factory)
+{
+    delete m_factory;
+
+    m_factory = factory;
+}
+
+wxDCFactory *wxDCFactory::Get()
+{
+    if ( !m_factory )
+        m_factory = new wxNativeDCFactory;
+
+    return m_factory;
+}
+
+class wxDCFactoryCleanupModule : public wxModule
+{
+public:
+    virtual bool OnInit() { return true; }
+    virtual void OnExit() { wxDCFactory::Set(NULL); }
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxDCFactoryCleanupModule)
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxDCFactoryCleanupModule, wxModule)
+
+//-----------------------------------------------------------------------------
+// wxNativeDCFactory
+//-----------------------------------------------------------------------------
+
+wxDCImpl* wxNativeDCFactory::CreateWindowDC( wxWindowDC *owner, wxWindow *window )
+{
+    wxDCImpl * const impl = new wxWindowDCImpl( owner, window );
+    impl->InheritAttributes(window);
+    return impl;
+}
+
+wxDCImpl* wxNativeDCFactory::CreateClientDC( wxClientDC *owner, wxWindow *window )
+{
+    wxDCImpl * const impl = new wxClientDCImpl( owner, window );
+    impl->InheritAttributes(window);
+    return impl;
+}
+
+wxDCImpl* wxNativeDCFactory::CreatePaintDC( wxPaintDC *owner, wxWindow *window )
+{
+    wxDCImpl * const impl = new wxPaintDCImpl( owner, window );
+    impl->InheritAttributes(window);
+    return impl;
+}
+
+wxDCImpl* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner )
+{
+    return new wxMemoryDCImpl( owner );
+}
+
+wxDCImpl* wxNativeDCFactory::CreateMemoryDC(wxMemoryDC *owner, wxBitmap& bitmap)
+{
+    // the bitmap may be modified when it's selected into a memory DC so make
+    // sure changing this bitmap doesn't affect any other shallow copies of it
+    // (see wxMemoryDC::SelectObject())
+    //
+    // notice that we don't provide any ctor equivalent to SelectObjectAsSource
+    // method because this should be rarely needed and easy to work around by
+    // using the default ctor and calling SelectObjectAsSource itself
+    if ( bitmap.IsOk() )
+        bitmap.UnShare();
+
+    return new wxMemoryDCImpl(owner, bitmap);
+}
+
+wxDCImpl* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner, wxDC *dc )
+{
+    return new wxMemoryDCImpl( owner, dc );
+}
+
+wxDCImpl* wxNativeDCFactory::CreateScreenDC( wxScreenDC *owner )
+{
+    return new wxScreenDCImpl( owner );
+}
+
+#if wxUSE_PRINTING_ARCHITECTURE
+wxDCImpl *wxNativeDCFactory::CreatePrinterDC( wxPrinterDC *owner, const wxPrintData &data )
+{
+    wxPrintFactory *factory = wxPrintFactory::GetFactory();
+    return factory->CreatePrinterDCImpl( owner, data );
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// wxWindowDC
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxWindowDC, wxDC)
+
+wxWindowDC::wxWindowDC(wxWindow *win)
+          : wxDC(wxDCFactory::Get()->CreateWindowDC(this, win))
+{
+}
+
+//-----------------------------------------------------------------------------
+// wxClientDC
+//-----------------------------------------------------------------------------

 
 

-IMPLEMENT_DYNAMIC_CLASS(wxBufferedDC, wxMemoryDC)
-IMPLEMENT_ABSTRACT_CLASS(wxBufferedPaintDC, wxBufferedDC)
+IMPLEMENT_ABSTRACT_CLASS(wxClientDC, wxWindowDC)

 
 

-wxDCBase::wxDCBase()
-        : m_colour(wxColourDisplay())
+wxClientDC::wxClientDC(wxWindow *win)
+          : wxWindowDC(wxDCFactory::Get()->CreateClientDC(this, win))
+{
+}
+
+//-----------------------------------------------------------------------------
+// wxMemoryDC
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxDC)
+
+wxMemoryDC::wxMemoryDC()
+          : wxDC(wxDCFactory::Get()->CreateMemoryDC(this))
+{
+}
+
+wxMemoryDC::wxMemoryDC(wxBitmap& bitmap)
+          : wxDC(wxDCFactory::Get()->CreateMemoryDC(this, bitmap))
+{
+}
+
+wxMemoryDC::wxMemoryDC(wxDC *dc)
+          : wxDC(wxDCFactory::Get()->CreateMemoryDC(this, dc))
+{
+}
+
+void wxMemoryDC::SelectObject(wxBitmap& bmp)
+{
+    if ( bmp.IsSameAs(GetSelectedBitmap()) )
+    {
+        // Nothing to do, this bitmap is already selected.
+        return;
+    }
+
+    // make sure that the given wxBitmap is not sharing its data with other
+    // wxBitmap instances as its contents will be modified by any drawing
+    // operation done on this DC
+    if (bmp.IsOk())
+        bmp.UnShare();
+
+    GetImpl()->DoSelect(bmp);
+}
+
+void wxMemoryDC::SelectObjectAsSource(const wxBitmap& bmp)
+{
+    GetImpl()->DoSelect(bmp);
+}
+
+const wxBitmap& wxMemoryDC::GetSelectedBitmap() const
+{
+    return GetImpl()->GetSelectedBitmap();
+}
+
+wxBitmap& wxMemoryDC::GetSelectedBitmap()
+{
+    return GetImpl()->GetSelectedBitmap();
+}
+
+
+//-----------------------------------------------------------------------------
+// wxPaintDC
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxPaintDC, wxClientDC)
+
+wxPaintDC::wxPaintDC(wxWindow *win)
+         : wxClientDC(wxDCFactory::Get()->CreatePaintDC(this, win))
+{
+}
+
+//-----------------------------------------------------------------------------
+// wxScreenDC
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxWindowDC)
+
+wxScreenDC::wxScreenDC()
+          : wxDC(wxDCFactory::Get()->CreateScreenDC(this))
+{
+}
+
+//-----------------------------------------------------------------------------
+// wxPrinterDC
+//-----------------------------------------------------------------------------
+
+#if wxUSE_PRINTING_ARCHITECTURE
+
+IMPLEMENT_DYNAMIC_CLASS(wxPrinterDC, wxDC)
+
+wxPrinterDC::wxPrinterDC()
+           : wxDC(wxDCFactory::Get()->CreatePrinterDC(this, wxPrintData()))
+{
+}
+
+wxPrinterDC::wxPrinterDC(const wxPrintData& data)
+           : wxDC(wxDCFactory::Get()->CreatePrinterDC(this, data))
+{
+}
+
+wxRect wxPrinterDC::GetPaperRect() const
+{
+    return GetImpl()->GetPaperRect();
+}
+
+int wxPrinterDC::GetResolution() const
+{
+    return GetImpl()->GetResolution();
+}
+
+#endif // wxUSE_PRINTING_ARCHITECTURE
+
+//-----------------------------------------------------------------------------
+// wxDCImpl
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxDCImpl, wxObject)
+
+wxDCImpl::wxDCImpl( wxDC *owner )
+        : m_window(NULL)
+        , m_colour(wxColourDisplay())

         , m_ok(true)
         , m_clipping(false)
         , m_isInteractive(0)
         , m_ok(true)
         , m_clipping(false)
         , m_isInteractive(0)


@@ -55,14 +338,15 @@ wxDCBase::wxDCBase()
         , m_userScaleX(1.0), m_userScaleY(1.0)
         , m_scaleX(1.0), m_scaleY(1.0)
         , m_signX(1), m_signY(1)
         , m_userScaleX(1.0), m_userScaleY(1.0)
         , m_scaleX(1.0), m_scaleY(1.0)
         , m_signX(1), m_signY(1)

+        , m_contentScaleFactor(1)

         , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
         , m_clipX1(0), m_clipY1(0), m_clipX2(0), m_clipY2(0)
         , m_logicalFunction(wxCOPY)
         , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
         , m_clipX1(0), m_clipY1(0), m_clipX2(0), m_clipY2(0)
         , m_logicalFunction(wxCOPY)

-        , m_backgroundMode(wxTRANSPARENT)
+        , m_backgroundMode(wxBRUSHSTYLE_TRANSPARENT)

         , m_mappingMode(wxMM_TEXT)
         , m_pen()
         , m_brush()
         , m_mappingMode(wxMM_TEXT)
         , m_pen()
         , m_brush()

-        , m_backgroundBrush(*wxTRANSPARENT_BRUSH)
+        , m_backgroundBrush()

         , m_textForegroundColour(*wxBLACK)
         , m_textBackgroundColour(*wxWHITE)
         , m_font()
         , m_textForegroundColour(*wxBLACK)
         , m_textBackgroundColour(*wxWHITE)
         , m_font()


@@ -71,135 +355,96 @@ wxDCBase::wxDCBase()
         , m_hasCustomPalette(false)
 #endif // wxUSE_PALETTE
 {
         , m_hasCustomPalette(false)
 #endif // wxUSE_PALETTE
 {

+    m_owner = owner;
+

     m_mm_to_pix_x = (double)wxGetDisplaySize().GetWidth() /
                     (double)wxGetDisplaySizeMM().GetWidth();
     m_mm_to_pix_y = (double)wxGetDisplaySize().GetHeight() /
                     (double)wxGetDisplaySizeMM().GetHeight();
     m_mm_to_pix_x = (double)wxGetDisplaySize().GetWidth() /
                     (double)wxGetDisplaySizeMM().GetWidth();
     m_mm_to_pix_y = (double)wxGetDisplaySize().GetHeight() /
                     (double)wxGetDisplaySizeMM().GetHeight();

-                    
+

     ResetBoundingBox();
     ResetClipping();
 }
 
     ResetBoundingBox();
     ResetClipping();
 }
 

-wxDCBase::~wxDCBase()
+wxDCImpl::~wxDCImpl()

 {
 }
 
 {
 }
 

-#if WXWIN_COMPATIBILITY_2_6
-void wxDCBase::BeginDrawing()
-{
-}
+// ----------------------------------------------------------------------------
+// clipping
+// ----------------------------------------------------------------------------

 
 

-void wxDCBase::EndDrawing()
+void wxDCImpl::DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h)

 {
 {

-}
-#endif // WXWIN_COMPATIBILITY_2_6
-
-#if WXWIN_COMPATIBILITY_2_8
-    // for compatibility with the old code when wxCoord was long everywhere
-void wxDCBase::GetTextExtent(const wxString& string,
-                       long *x, long *y,
-                       long *descent = NULL,
-                       long *externalLeading = NULL,
-                       const wxFont *theFont = NULL) const
-    {
-        wxCoord x2, y2, descent2, externalLeading2;
-        DoGetTextExtent(string, &x2, &y2,
-                        &descent2, &externalLeading2,
-                        theFont);
-        if ( x )
-            *x = x2;
-        if ( y )
-            *y = y2;
-        if ( descent )
-            *descent = descent2;
-        if ( externalLeading )
-            *externalLeading = externalLeading2;
-    }
-
-void wxDCBase::GetLogicalOrigin(long *x, long *y) const 
+    if ( m_clipping )

     {
     {

-        wxCoord x2, y2;
-        DoGetLogicalOrigin(&x2, &y2);
-        if ( x )
-            *x = x2;
-        if ( y )
-            *y = y2;
+        m_clipX1 = wxMax( m_clipX1, x );
+        m_clipY1 = wxMax( m_clipY1, y );
+        m_clipX2 = wxMin( m_clipX2, (x + w) );
+        m_clipY2 = wxMin( m_clipY2, (y + h) );

     }
     }

-
-void wxDCBase::GetDeviceOrigin(long *x, long *y) const 
-    {
-        wxCoord x2, y2;
-        DoGetDeviceOrigin(&x2, &y2);
-        if ( x )
-            *x = x2;
-        if ( y )
-            *y = y2;
-    } 
-    
-void wxDCBase::GetClippingBox(long *x, long *y, long *w, long *h) const 
+    else

     {
     {

-        wxCoord xx,yy,ww,hh;
-        DoGetClippingBox(&xx, &yy, &ww, &hh);
-        if (x) *x = xx;
-        if (y) *y = yy;
-        if (w) *w = ww;
-        if (h) *h = hh;
-    } 
-#endif  // WXWIN_COMPATIBILITY_2_8
-
+        m_clipping = true;

 
 

+        m_clipX1 = x;
+        m_clipY1 = y;
+        m_clipX2 = x + w;
+        m_clipY2 = y + h;
+    }
+}

 
 // ----------------------------------------------------------------------------
 // coordinate conversions and transforms
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // coordinate conversions and transforms
 // ----------------------------------------------------------------------------
 

-wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
+wxCoord wxDCImpl::DeviceToLogicalX(wxCoord x) const

 {
 {

-    return wxRound((double)(x - m_deviceOriginX - m_deviceLocalOriginX) / m_scaleX) * m_signX + m_logicalOriginX;
+    return wxRound( (double)((x - m_deviceOriginX - m_deviceLocalOriginX) * m_signX) / m_scaleX ) + m_logicalOriginX ;

 }
 
 }
 

-wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
+wxCoord wxDCImpl::DeviceToLogicalY(wxCoord y) const

 {
 {

-    return wxRound((double)(y - m_deviceOriginY - m_deviceLocalOriginY) / m_scaleY) * m_signY + m_logicalOriginY;
+    return wxRound( (double)((y - m_deviceOriginY - m_deviceLocalOriginY) * m_signY) / m_scaleY ) + m_logicalOriginY ;

 }
 
 }
 

-wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
+wxCoord wxDCImpl::DeviceToLogicalXRel(wxCoord x) const

 {
     return wxRound((double)(x) / m_scaleX);
 }
 
 {
     return wxRound((double)(x) / m_scaleX);
 }
 

-wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
+wxCoord wxDCImpl::DeviceToLogicalYRel(wxCoord y) const

 {
     return wxRound((double)(y) / m_scaleY);
 }
 
 {
     return wxRound((double)(y) / m_scaleY);
 }
 

-wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
+wxCoord wxDCImpl::LogicalToDeviceX(wxCoord x) const

 {
 {

-    return wxRound((double)(x - m_logicalOriginX) * m_scaleX) * m_signX + m_deviceOriginX + m_deviceLocalOriginX;
+    return wxRound( (double)((x - m_logicalOriginX) * m_signX) * m_scaleX) + m_deviceOriginX + m_deviceLocalOriginX;

 }
 
 }
 

-wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
+wxCoord wxDCImpl::LogicalToDeviceY(wxCoord y) const

 {
 {

-    return wxRound((double)(y - m_logicalOriginY) * m_scaleY) * m_signY + m_deviceOriginY + m_deviceLocalOriginY;
+    return wxRound( (double)((y - m_logicalOriginY) * m_signY) * m_scaleY) + m_deviceOriginY + m_deviceLocalOriginY;

 }
 
 }
 

-wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
+wxCoord wxDCImpl::LogicalToDeviceXRel(wxCoord x) const

 {
     return wxRound((double)(x) * m_scaleX);
 }
 
 {
     return wxRound((double)(x) * m_scaleX);
 }
 

-wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
+wxCoord wxDCImpl::LogicalToDeviceYRel(wxCoord y) const

 {
     return wxRound((double)(y) * m_scaleY);
 }
 
 {
     return wxRound((double)(y) * m_scaleY);
 }
 

-void wxDCBase::ComputeScaleAndOrigin()
+void wxDCImpl::ComputeScaleAndOrigin()

 {
     m_scaleX = m_logicalScaleX * m_userScaleX;
     m_scaleY = m_logicalScaleY * m_userScaleY;
 }
 
 {
     m_scaleX = m_logicalScaleX * m_userScaleX;
     m_scaleY = m_logicalScaleY * m_userScaleY;
 }
 

-void wxDCBase::SetMapMode( int mode )
+void wxDCImpl::SetMapMode( wxMappingMode mode )

 {
     switch (mode)
     {
 {
     switch (mode)
     {


@@ -223,7 +468,7 @@ void wxDCBase::SetMapMode( int mode )
     m_mappingMode = mode;
 }
 
     m_mappingMode = mode;
 }
 

-void wxDCBase::SetUserScale( double x, double y )
+void wxDCImpl::SetUserScale( double x, double y )

 {
     // allow negative ? -> no
     m_userScaleX = x;
 {
     // allow negative ? -> no
     m_userScaleX = x;


@@ -231,7 +476,7 @@ void wxDCBase::SetUserScale( double x, double y )
     ComputeScaleAndOrigin();
 }
 
     ComputeScaleAndOrigin();
 }
 

-void wxDCBase::SetLogicalScale( double x, double y )
+void wxDCImpl::SetLogicalScale( double x, double y )

 {
     // allow negative ?
     m_logicalScaleX = x;
 {
     // allow negative ?
     m_logicalScaleX = x;


@@ -239,50 +484,62 @@ void wxDCBase::SetLogicalScale( double x, double y )
     ComputeScaleAndOrigin();
 }
 
     ComputeScaleAndOrigin();
 }
 

-void wxDCBase::SetLogicalOrigin( wxCoord x, wxCoord y )
+void wxDCImpl::SetLogicalOrigin( wxCoord x, wxCoord y )

 {
     m_logicalOriginX = x * m_signX;
     m_logicalOriginY = y * m_signY;
     ComputeScaleAndOrigin();
 }
 
 {
     m_logicalOriginX = x * m_signX;
     m_logicalOriginY = y * m_signY;
     ComputeScaleAndOrigin();
 }
 

-void wxDCBase::SetDeviceOrigin( wxCoord x, wxCoord y )
+void wxDCImpl::SetDeviceOrigin( wxCoord x, wxCoord y )

 {
     m_deviceOriginX = x;
     m_deviceOriginY = y;
     ComputeScaleAndOrigin();
 }
 
 {
     m_deviceOriginX = x;
     m_deviceOriginY = y;
     ComputeScaleAndOrigin();
 }
 

-void wxDCBase::SetDeviceLocalOrigin( wxCoord x, wxCoord y )
+void wxDCImpl::SetDeviceLocalOrigin( wxCoord x, wxCoord y )

 {
     m_deviceLocalOriginX = x;
     m_deviceLocalOriginY = y;
     ComputeScaleAndOrigin();
 }
 
 {
     m_deviceLocalOriginX = x;
     m_deviceLocalOriginY = y;
     ComputeScaleAndOrigin();
 }
 

-void wxDCBase::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
+void wxDCImpl::SetAxisOrientation( bool xLeftRight, bool yBottomUp )

 {
     // only wxPostScripDC has m_signX = -1, we override SetAxisOrientation there
 {
     // only wxPostScripDC has m_signX = -1, we override SetAxisOrientation there

+    // wxWidgets 2.9: no longer override it

     m_signX = (xLeftRight ?  1 : -1);
     m_signY = (yBottomUp  ? -1 :  1);
     ComputeScaleAndOrigin();
 }
 
     m_signX = (xLeftRight ?  1 : -1);
     m_signY = (yBottomUp  ? -1 :  1);
     ComputeScaleAndOrigin();
 }
 

-// ----------------------------------------------------------------------------
-// special symbols
-// ----------------------------------------------------------------------------
+bool wxDCImpl::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
+{
+    wxTextMeasure tm(GetOwner(), &m_font);
+    return tm.GetPartialTextExtents(text, widths, m_scaleX);
+}

 
 

-void wxDCBase::DoDrawCheckMark(wxCoord x1, wxCoord y1,
+void wxDCImpl::GetMultiLineTextExtent(const wxString& text,
+                                      wxCoord *x,
+                                      wxCoord *y,
+                                      wxCoord *h,
+                                      const wxFont *font) const
+{
+    wxTextMeasure tm(GetOwner(), font && font->IsOk() ? font : &m_font);
+    tm.GetMultiLineTextExtent(text, x, y, h);
+}
+
+void wxDCImpl::DoDrawCheckMark(wxCoord x1, wxCoord y1,

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

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

 
     wxCoord x2 = x1 + width,
             y2 = y1 + height;
 
     // the pen width is calibrated to give 3 for width == height == 10
 
     wxCoord x2 = x1 + width,
             y2 = y1 + height;
 
     // the pen width is calibrated to give 3 for width == height == 10

-    wxDCPenChanger pen((wxDC&)*this,
-                        wxPen(GetTextForeground(), (width + height + 1)/7));
+    wxDCPenChanger pen( *m_owner, wxPen(GetTextForeground(), (width + height + 1)/7));

 
     // we're drawing a scaled version of wx/generic/tick.xpm here
     wxCoord x3 = x1 + (4*width) / 10,   // x of the tick bottom
 
     // we're drawing a scaled version of wx/generic/tick.xpm here
     wxCoord x3 = x1 + (4*width) / 10,   // x of the tick bottom


@@ -294,23 +551,19 @@ void wxDCBase::DoDrawCheckMark(wxCoord x1, wxCoord y1,
     CalcBoundingBox(x2, y2);
 }
 
     CalcBoundingBox(x2, y2);
 }
 

-// ----------------------------------------------------------------------------
-// stubs for functions not implemented in all ports
-// ----------------------------------------------------------------------------
-

 bool
 bool

-wxDCBase::DoStretchBlit(wxCoord xdest, wxCoord ydest,
+wxDCImpl::DoStretchBlit(wxCoord xdest, wxCoord ydest,

                         wxCoord dstWidth, wxCoord dstHeight,
                         wxDC *source,
                         wxCoord xsrc, wxCoord ysrc,
                         wxCoord srcWidth, wxCoord srcHeight,
                         wxCoord dstWidth, wxCoord dstHeight,
                         wxDC *source,
                         wxCoord xsrc, wxCoord ysrc,
                         wxCoord srcWidth, wxCoord srcHeight,

-                        int rop,
+                        wxRasterOperationMode rop,

                         bool useMask,
                         wxCoord xsrcMask,
                         wxCoord ysrcMask)
 {
     wxCHECK_MSG( srcWidth && srcHeight && dstWidth && dstHeight, false,
                         bool useMask,
                         wxCoord xsrcMask,
                         wxCoord ysrcMask)
 {
     wxCHECK_MSG( srcWidth && srcHeight && dstWidth && dstHeight, false,

-                 _T("invalid blit size") );
+                 wxT("invalid blit size") );

 
     // emulate the stretching by modifying the DC scale
     double xscale = (double)srcWidth/dstWidth,
 
     // emulate the stretching by modifying the DC scale
     double xscale = (double)srcWidth/dstWidth,


@@ -330,19 +583,15 @@ wxDCBase::DoStretchBlit(wxCoord xdest, wxCoord ydest,
     return rc;
 }
 
     return rc;
 }
 

-// ----------------------------------------------------------------------------
-// line/polygons
-// ----------------------------------------------------------------------------
-
-void wxDCBase::DrawLines(const wxList *list, wxCoord xoffset, wxCoord yoffset)
+void wxDCImpl::DrawLines(const wxPointList *list, wxCoord xoffset, wxCoord yoffset)

 {
     int n = list->GetCount();
     wxPoint *points = new wxPoint[n];
 
     int i = 0;
 {
     int n = list->GetCount();
     wxPoint *points = new wxPoint[n];
 
     int i = 0;

-    for ( wxList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )
+    for ( wxPointList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )

     {
     {

-        wxPoint *point = (wxPoint *)node->GetData();
+        wxPoint *point = node->GetData();

         points[i].x = point->x;
         points[i].y = point->y;
     }
         points[i].x = point->x;
         points[i].y = point->y;
     }


@@ -352,18 +601,17 @@ void wxDCBase::DrawLines(const wxList *list, wxCoord xoffset, wxCoord yoffset)
     delete [] points;
 }
 
     delete [] points;
 }
 

-
-void wxDCBase::DrawPolygon(const wxList *list,
+void wxDCImpl::DrawPolygon(const wxPointList *list,

                            wxCoord xoffset, wxCoord yoffset,
                            wxCoord xoffset, wxCoord yoffset,

-                           int fillStyle)
+                           wxPolygonFillMode fillStyle)

 {
     int n = list->GetCount();
     wxPoint *points = new wxPoint[n];
 
     int i = 0;
 {
     int n = list->GetCount();
     wxPoint *points = new wxPoint[n];
 
     int i = 0;

-    for ( wxList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )
+    for ( wxPointList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )

     {
     {

-        wxPoint *point = (wxPoint *)node->GetData();
+        wxPoint *point = node->GetData();

         points[i].x = point->x;
         points[i].y = point->y;
     }
         points[i].x = point->x;
         points[i].y = point->y;
     }


@@ -374,11 +622,11 @@ void wxDCBase::DrawPolygon(const wxList *list,
 }
 
 void
 }
 
 void

-wxDCBase::DoDrawPolyPolygon(int n,
-                            int count[],
-                            wxPoint points[],
+wxDCImpl::DoDrawPolyPolygon(int n,
+                            const int count[],
+                            const wxPoint points[],

                             wxCoord xoffset, wxCoord yoffset,
                             wxCoord xoffset, wxCoord yoffset,

-                            int fillStyle)
+                            wxPolygonFillMode fillStyle)

 {
     if ( n == 1 )
     {
 {
     if ( n == 1 )
     {


@@ -388,7 +636,6 @@ wxDCBase::DoDrawPolyPolygon(int n,
 
     int      i, j, lastOfs;
     wxPoint* pts;
 
     int      i, j, lastOfs;
     wxPoint* pts;

-    wxPen    pen;

 
     for (i = j = lastOfs = 0; i < n; i++)
     {
 
     for (i = j = lastOfs = 0; i < n; i++)
     {


@@ -404,10 +651,11 @@ wxDCBase::DoDrawPolyPolygon(int n,
         pts[j++] = pts[lastOfs];
     }
 
         pts[j++] = pts[lastOfs];
     }
 

-    pen = GetPen();
-    SetPen(wxPen(*wxBLACK, 0, wxTRANSPARENT));
-    DoDrawPolygon(j, pts, xoffset, yoffset, fillStyle);
-    SetPen(pen);
+    {
+        wxDCPenChanger setTransp(*m_owner, *wxTRANSPARENT_PEN);
+        DoDrawPolygon(j, pts, xoffset, yoffset, fillStyle);
+    }
+

     for (i = j = 0; i < n; i++)
     {
         DoDrawLines(count[i], pts+j, xoffset, yoffset);
     for (i = j = 0; i < n; i++)
     {
         DoDrawLines(count[i], pts+j, xoffset, yoffset);


@@ -416,45 +664,21 @@ wxDCBase::DoDrawPolyPolygon(int n,
     delete[] pts;
 }
 
     delete[] pts;
 }
 

-// ----------------------------------------------------------------------------
-// splines
-// ----------------------------------------------------------------------------
-

 #if wxUSE_SPLINES
 
 #if wxUSE_SPLINES
 

-// TODO: this API needs fixing (wxPointList, why (!const) "wxList *"?)
-void wxDCBase::DrawSpline(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord x3, wxCoord y3)
+void wxDCImpl::DrawSpline(wxCoord x1, wxCoord y1,
+                          wxCoord x2, wxCoord y2,
+                          wxCoord x3, wxCoord y3)

 {
 {

-    wxList point_list;
-
-    wxPoint *point1 = new wxPoint;
-    point1->x = x1; point1->y = y1;
-    point_list.Append((wxObject*)point1);
-
-    wxPoint *point2 = new wxPoint;
-    point2->x = x2; point2->y = y2;
-    point_list.Append((wxObject*)point2);
-
-    wxPoint *point3 = new wxPoint;
-    point3->x = x3; point3->y = y3;
-    point_list.Append((wxObject*)point3);
-
-    DrawSpline(&point_list);
-
-    for( wxList::compatibility_iterator node = point_list.GetFirst(); node; node = node->GetNext() )
-    {
-        wxPoint *p = (wxPoint *)node->GetData();
-        delete p;
-    }
+    wxPoint points[] = { wxPoint(x1, y1), wxPoint(x2, y2), wxPoint(x3, y3) };
+    DrawSpline(WXSIZEOF(points), points);

 }
 
 }
 

-void wxDCBase::DrawSpline(int n, wxPoint points[])
+void wxDCImpl::DrawSpline(int n, const wxPoint points[])

 {
 {

-    wxList list;
-    for (int i =0; i < n; i++)
-    {
-        list.Append((wxObject*)&points[i]);
-    }
+    wxPointList list;
+    for ( int i = 0; i < n; i++ )
+        list.Append(const_cast<wxPoint*>(&points[i]));

 
     DrawSpline(&list);
 }
 
     DrawSpline(&list);
 }


@@ -469,9 +693,9 @@ int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
           double x4, double y4);
 static bool wx_spline_add_point(double x, double y);
 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
           double x4, double y4);
 static bool wx_spline_add_point(double x, double y);

-static void wx_spline_draw_point_array(wxDCBase *dc);
+static void wx_spline_draw_point_array(wxDC *dc);

 
 

-wxList wx_spline_point_list;
+static wxPointList wx_spline_point_list;

 
 #define                half(z1, z2)        ((z1+z2)/2.0)
 #define                THRESHOLD        5
 
 #define                half(z1, z2)        ((z1+z2)/2.0)
 #define                THRESHOLD        5


@@ -554,46 +778,44 @@ int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
 
 static bool wx_spline_add_point(double x, double y)
 {
 
 static bool wx_spline_add_point(double x, double y)
 {

-  wxPoint *point = new wxPoint ;
-  point->x = (int) x;
-  point->y = (int) y;
-  wx_spline_point_list.Append((wxObject*)point);
-  return true;
+    wxPoint *point = new wxPoint( wxRound(x), wxRound(y) );
+    wx_spline_point_list.Append(point );
+    return true;

 }
 
 }
 

-static void wx_spline_draw_point_array(wxDCBase *dc)
+static void wx_spline_draw_point_array(wxDC *dc)

 {
 {

-  dc->DrawLines(&wx_spline_point_list, 0, 0 );
-  wxList::compatibility_iterator node = wx_spline_point_list.GetFirst();
-  while (node)
-  {
-    wxPoint *point = (wxPoint *)node->GetData();
-    delete point;
-    wx_spline_point_list.Erase(node);
-    node = wx_spline_point_list.GetFirst();
-  }
+    dc->DrawLines(&wx_spline_point_list, 0, 0 );
+    wxPointList::compatibility_iterator node = wx_spline_point_list.GetFirst();
+    while (node)
+    {
+        wxPoint *point = node->GetData();
+        delete point;
+        wx_spline_point_list.Erase(node);
+        node = wx_spline_point_list.GetFirst();
+    }

 }
 
 }
 

-void wxDCBase::DoDrawSpline( wxList *points )
+void wxDCImpl::DoDrawSpline( const wxPointList *points )

 {
 {

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

 
 

-    wxPoint *p;
+    const wxPoint *p;

     double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
     double           x1, y1, x2, y2;
 
     double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
     double           x1, y1, x2, y2;
 

-    wxList::compatibility_iterator node = points->GetFirst();
+    wxPointList::compatibility_iterator node = points->GetFirst();

     if (!node)
         // empty list
         return;
 
     if (!node)
         // empty list
         return;
 

-    p = (wxPoint *)node->GetData();
+    p = node->GetData();

 
     x1 = p->x;
     y1 = p->y;
 
     node = node->GetNext();
 
     x1 = p->x;
     y1 = p->y;
 
     node = node->GetNext();

-    p = (wxPoint *)node->GetData();
+    p = node->GetData();

 
     x2 = p->x;
     y2 = p->y;
 
     x2 = p->x;
     y2 = p->y;


@@ -605,12 +827,12 @@ void wxDCBase::DoDrawSpline( wxList *points )
     wx_spline_add_point(x1, y1);
 
     while ((node = node->GetNext())
     wx_spline_add_point(x1, y1);
 
     while ((node = node->GetNext())

-#if !wxUSE_STL
+#if !wxUSE_STD_CONTAINERS

            != NULL
            != NULL

-#endif // !wxUSE_STL
+#endif // !wxUSE_STD_CONTAINERS

           )
     {
           )
     {

-        p = (wxPoint *)node->GetData();
+        p = node->GetData();

         x1 = x2;
         y1 = y2;
         x2 = p->x;
         x1 = x2;
         y1 = y2;
         x2 = p->x;


@@ -631,162 +853,224 @@ void wxDCBase::DoDrawSpline( wxList *points )
     wx_spline_add_point( cx1, cy1 );
     wx_spline_add_point( x2, y2 );
 
     wx_spline_add_point( cx1, cy1 );
     wx_spline_add_point( x2, y2 );
 

-    wx_spline_draw_point_array( this );
+    wx_spline_draw_point_array( m_owner );

 }
 
 #endif // wxUSE_SPLINES
 
 }
 
 #endif // wxUSE_SPLINES
 

-// ----------------------------------------------------------------------------
-// Partial Text Extents
-// ----------------------------------------------------------------------------
-

 
 

-// Each element of the widths array will be the width of the string up to and
-// including the corresponding character in text.  This is the generic
-// implementation, the port-specific classes should do this with native APIs
-// if available and if faster.  Note: pango_layout_index_to_pos is much slower
-// than calling GetTextExtent!!

 
 

-#define FWC_SIZE 256
-
-class FontWidthCache
+void wxDCImpl::DoGradientFillLinear(const wxRect& rect,
+                                    const wxColour& initialColour,
+                                    const wxColour& destColour,
+                                    wxDirection nDirection)

 {
 {

-public:
-    FontWidthCache() : m_scaleX(1), m_widths(NULL) { }
-    ~FontWidthCache() { delete []m_widths; }
-
-    void Reset()
-    {
-        if (!m_widths)
-            m_widths = new int[FWC_SIZE];
+    // save old pen
+    wxPen oldPen = m_pen;
+    wxBrush oldBrush = m_brush;

 
 

-        memset(m_widths, 0, sizeof(int)*FWC_SIZE);
-    }
+    wxUint8 nR1 = initialColour.Red();
+    wxUint8 nG1 = initialColour.Green();
+    wxUint8 nB1 = initialColour.Blue();
+    wxUint8 nR2 = destColour.Red();
+    wxUint8 nG2 = destColour.Green();
+    wxUint8 nB2 = destColour.Blue();
+    wxUint8 nR, nG, nB;

 
 

-    wxFont m_font;
-    double m_scaleX;
-    int *m_widths;
-};
+    if ( nDirection == wxEAST || nDirection == wxWEST )
+    {
+        wxInt32 x = rect.GetWidth();
+        wxInt32 w = x;              // width of area to shade
+        wxInt32 xDelta = w/256;     // height of one shade bend
+        if (xDelta < 1)
+            xDelta = 1;

 
 

-static FontWidthCache s_fontWidthCache;
+        while (x >= xDelta)
+        {
+            x -= xDelta;
+            if (nR1 > nR2)
+                nR = nR1 - (nR1-nR2)*(w-x)/w;
+            else
+                nR = nR1 + (nR2-nR1)*(w-x)/w;

 
 

-bool wxDCBase::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
-{
-    int totalWidth = 0;
+            if (nG1 > nG2)
+                nG = nG1 - (nG1-nG2)*(w-x)/w;
+            else
+                nG = nG1 + (nG2-nG1)*(w-x)/w;

 
 

-    const size_t len = text.length();
-    widths.Empty();
-    widths.Add(0, len);
+            if (nB1 > nB2)
+                nB = nB1 - (nB1-nB2)*(w-x)/w;
+            else
+                nB = nB1 + (nB2-nB1)*(w-x)/w;

 
 

-    // reset the cache if font or horizontal scale have changed
-    if ( !s_fontWidthCache.m_widths ||
-         !wxIsSameDouble(s_fontWidthCache.m_scaleX, m_scaleX) ||
-         (s_fontWidthCache.m_font != GetFont()) )
-    {
-        s_fontWidthCache.Reset();
-        s_fontWidthCache.m_font = GetFont();
-        s_fontWidthCache.m_scaleX = m_scaleX;
+            wxColour colour(nR,nG,nB);
+            SetPen(wxPen(colour, 1, wxPENSTYLE_SOLID));
+            SetBrush(wxBrush(colour));
+            if(nDirection == wxEAST)
+                DoDrawRectangle(rect.GetRight()-x-xDelta+1, rect.GetTop(),
+                        xDelta, rect.GetHeight());
+            else //nDirection == wxWEST
+                DoDrawRectangle(rect.GetLeft()+x, rect.GetTop(),
+                        xDelta, rect.GetHeight());
+        }

     }
     }

-
-    // Calculate the position of each character based on the widths of
-    // the previous characters
-    int w, h;
-    for ( size_t i = 0; i < len; i++ )
+    else  // nDirection == wxNORTH || nDirection == wxSOUTH

     {
     {

-        const wxChar c = text[i];
-        unsigned int c_int = (unsigned int)c;
+        wxInt32 y = rect.GetHeight();
+        wxInt32 w = y;              // height of area to shade
+        wxInt32 yDelta = w/255;     // height of one shade bend
+        if (yDelta < 1)
+            yDelta = 1;

 
 

-        if ((c_int < FWC_SIZE) && (s_fontWidthCache.m_widths[c_int] != 0))
-        {
-            w = s_fontWidthCache.m_widths[c_int];
-        }
-        else
+        while (y > 0)

         {
         {

-            GetTextExtent(c, &w, &h);
-            if (c_int < FWC_SIZE)
-                s_fontWidthCache.m_widths[c_int] = w;
-        }
+            y -= yDelta;
+            if (nR1 > nR2)
+                nR = nR1 - (nR1-nR2)*(w-y)/w;
+            else
+                nR = nR1 + (nR2-nR1)*(w-y)/w;
+
+            if (nG1 > nG2)
+                nG = nG1 - (nG1-nG2)*(w-y)/w;
+            else
+                nG = nG1 + (nG2-nG1)*(w-y)/w;
+
+            if (nB1 > nB2)
+                nB = nB1 - (nB1-nB2)*(w-y)/w;
+            else
+                nB = nB1 + (nB2-nB1)*(w-y)/w;

 
 

-        totalWidth += w;
-        widths[i] = totalWidth;
+            wxColour colour(nR,nG,nB);
+            SetPen(wxPen(colour, 1, wxPENSTYLE_SOLID));
+            SetBrush(wxBrush(colour));
+            if(nDirection == wxNORTH)
+                DoDrawRectangle(rect.GetLeft(), rect.GetTop()+y,
+                        rect.GetWidth(), yDelta);
+            else //nDirection == wxSOUTH
+                DoDrawRectangle(rect.GetLeft(), rect.GetBottom()-y-yDelta+1,
+                        rect.GetWidth(), yDelta);
+        }

     }
 
     }
 

-    return true;
+    SetPen(oldPen);
+    SetBrush(oldBrush);

 }
 
 }
 

+void wxDCImpl::DoGradientFillConcentric(const wxRect& rect,
+                                      const wxColour& initialColour,
+                                      const wxColour& destColour,
+                                      const wxPoint& circleCenter)
+{
+    // save the old pen and ensure it is restored on exit
+    const wxPen penOrig = m_pen;
+    wxON_BLOCK_EXIT_SET(m_pen, penOrig);

 
 

-// ----------------------------------------------------------------------------
-// enhanced text drawing
-// ----------------------------------------------------------------------------
+    wxUint8 nR1 = destColour.Red();
+    wxUint8 nG1 = destColour.Green();
+    wxUint8 nB1 = destColour.Blue();
+    wxUint8 nR2 = initialColour.Red();
+    wxUint8 nG2 = initialColour.Green();
+    wxUint8 nB2 = initialColour.Blue();
+    wxUint8 nR, nG, nB;

 
 

-void wxDCBase::GetMultiLineTextExtent(const wxString& text,
-                                      wxCoord *x,
-                                      wxCoord *y,
-                                      wxCoord *h,
-                                      const wxFont *font) const
-{
-    wxCoord widthTextMax = 0, widthLine,
-            heightTextTotal = 0, heightLineDefault = 0, heightLine = 0;

 
 

-    wxString curLine;
-    for ( const wxChar *pc = text; ; pc++ )
+    //Radius
+    double cx = rect.GetWidth() / 2;
+    double cy = rect.GetHeight() / 2;
+    double dRadius;
+    if (cx < cy)
+        dRadius = cx;
+    else
+        dRadius = cy;
+
+    //Offset of circle
+    double ptX, ptY;
+    ptX = circleCenter.x;
+    ptY = circleCenter.y;
+    double nCircleOffX = ptX - cx;
+    double nCircleOffY = ptY - cy;
+
+    double dGradient;
+    double dx, dy;
+
+    for ( wxInt32 x = 0; x < rect.GetWidth(); x++ )

     {
     {

-        if ( *pc == _T('\n') || *pc == _T('\0') )
+        for ( wxInt32 y = 0; y < rect.GetHeight(); y++ )

         {
         {

-            if ( curLine.empty() )
-            {
-                // we can't use GetTextExtent - it will return 0 for both width
-                // and height and an empty line should count in height
-                // calculation
+            //get color difference
+            dx = x;
+            dy = y;

 
 

-                // assume that this line has the same height as the previous
-                // one
-                if ( !heightLineDefault )
-                    heightLineDefault = heightLine;
+            dGradient = ((dRadius - sqrt(  (dx - cx - nCircleOffX) * (dx - cx - nCircleOffX)
+                                          +(dy - cy - nCircleOffY) * (dy - cy - nCircleOffY)
+                                         )
+                         ) * 100
+                        ) / dRadius;

 
 

-                if ( !heightLineDefault )
-                {
-                    // but we don't know it yet - choose something reasonable
-                    GetTextExtent(_T("W"), NULL, &heightLineDefault,
-                                  NULL, NULL, font);
-                }
+            //normalize Gradient
+            if (dGradient < 0)
+                dGradient = 0.0;

 
 

-                heightTextTotal += heightLineDefault;
-            }
-            else
-            {
-                GetTextExtent(curLine, &widthLine, &heightLine,
-                              NULL, NULL, font);
-                if ( widthLine > widthTextMax )
-                    widthTextMax = widthLine;
-                heightTextTotal += heightLine;
-            }
+            //get dest colors
+            nR = (wxUint8)(nR1 + ((nR2 - nR1) * dGradient / 100));
+            nG = (wxUint8)(nG1 + ((nG2 - nG1) * dGradient / 100));
+            nB = (wxUint8)(nB1 + ((nB2 - nB1) * dGradient / 100));

 
 

-            if ( *pc == _T('\n') )
-            {
-               curLine.clear();
-            }
-            else
-            {
-               // the end of string
-               break;
-            }
-        }
-        else
-        {
-            curLine += *pc;
+            //set the pixel
+            SetPen(wxColour(nR,nG,nB));
+            DoDrawPoint(x + rect.GetLeft(), y + rect.GetTop());

         }
     }
         }
     }

+}
+
+void wxDCImpl::InheritAttributes(wxWindow *win)
+{
+    wxCHECK_RET( win, "window can't be NULL" );

 
 

-    if ( x )
-        *x = widthTextMax;
-    if ( y )
-        *y = heightTextTotal;
-    if ( h )
-        *h = heightLine;
+    SetFont(win->GetFont());
+    SetTextForeground(win->GetForegroundColour());
+    SetTextBackground(win->GetBackgroundColour());
+    SetBackground(win->GetBackgroundColour());
+    SetLayoutDirection(win->GetLayoutDirection());

 }
 
 }
 

-void wxDCBase::DrawLabel(const wxString& text,
+void wxDCImpl::DoGetFontMetrics(int *height,
+                                int *ascent,
+                                int *descent,
+                                int *internalLeading,
+                                int *externalLeading,
+                                int *averageWidth) const
+{
+    // Average width is typically the same as width of 'x'.
+    wxCoord h, d;
+    DoGetTextExtent("x", averageWidth, &h, &d, externalLeading);
+
+    if ( height )
+        *height = h;
+    if ( ascent )
+        *ascent = h - d;
+    if ( descent )
+        *descent = d;
+    if ( internalLeading )
+        *internalLeading = 0;
+}
+
+//-----------------------------------------------------------------------------
+// wxDC
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
+
+void wxDC::CopyAttributes(const wxDC& dc)
+{
+    SetFont(dc.GetFont());
+    SetTextForeground(dc.GetTextForeground());
+    SetTextBackground(dc.GetTextBackground());
+    SetBackground(dc.GetBackground());
+    SetLayoutDirection(dc.GetLayoutDirection());
+}
+
+void wxDC::DrawLabel(const wxString& text,

                          const wxBitmap& bitmap,
                          const wxRect& rect,
                          int alignment,
                          const wxBitmap& bitmap,
                          const wxRect& rect,
                          int alignment,


@@ -798,7 +1082,7 @@ void wxDCBase::DrawLabel(const wxString& text,
     GetMultiLineTextExtent(text, &widthText, &heightText, &heightLine);
 
     wxCoord width, height;
     GetMultiLineTextExtent(text, &widthText, &heightText, &heightLine);
 
     wxCoord width, height;

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

     {
         width = widthText + bitmap.GetWidth();
         height = bitmap.GetHeight();
     {
         width = widthText + bitmap.GetWidth();
         height = bitmap.GetHeight();


@@ -840,7 +1124,7 @@ void wxDCBase::DrawLabel(const wxString& text,
     wxCoord x0 = x,
             y0 = y,
             width0 = width;
     wxCoord x0 = x,
             y0 = y,
             width0 = width;

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

     {
         DrawBitmap(bitmap, x, y, true /* use mask */);
 
     {
         DrawBitmap(bitmap, x, y, true /* use mask */);
 


@@ -857,10 +1141,16 @@ void wxDCBase::DrawLabel(const wxString& text,
             yUnderscore = 0;
 
     // split the string into lines and draw each of them separately
             yUnderscore = 0;
 
     // split the string into lines and draw each of them separately

+    //
+    // NB: while wxDC::DrawText() on some platforms supports drawing multi-line
+    //     strings natively, this is not the case for all of them, notably not
+    //     wxMSW which uses this function for multi-line texts, so we may only
+    //     call DrawText() for single-line strings from here to avoid infinite
+    //     recursion.

     wxString curLine;
     for ( wxString::const_iterator pc = text.begin(); ; ++pc )
     {
     wxString curLine;
     for ( wxString::const_iterator pc = text.begin(); ; ++pc )
     {

-        if ( *pc == _T('\n') || pc == text.end() )
+        if ( pc == text.end() || *pc == '\n' )

         {
             int xRealStart = x; // init it here to avoid compielr warnings
 
         {
             int xRealStart = x; // init it here to avoid compielr warnings
 


@@ -907,7 +1197,7 @@ void wxDCBase::DrawLabel(const wxString& text,
         {
             if ( pc - text.begin() == indexAccel )
             {
         {
             if ( pc - text.begin() == indexAccel )
             {

-                // remeber to draw underscore here
+                // remember to draw underscore here

                 GetTextExtent(curLine, &startUnderscore, NULL);
                 curLine += *pc;
                 GetTextExtent(curLine, &endUnderscore, NULL);
                 GetTextExtent(curLine, &startUnderscore, NULL);
                 curLine += *pc;
                 GetTextExtent(curLine, &endUnderscore, NULL);


@@ -925,9 +1215,16 @@ void wxDCBase::DrawLabel(const wxString& text,
     if ( startUnderscore != endUnderscore )
     {
         // it should be of the same colour as text
     if ( startUnderscore != endUnderscore )
     {
         // it should be of the same colour as text

-        SetPen(wxPen(GetTextForeground(), 0, wxSOLID));
+        SetPen(wxPen(GetTextForeground(), 0, wxPENSTYLE_SOLID));

 
 

-        yUnderscore--;
+        // This adjustment is relatively arbitrary: we need to draw the
+        // underline slightly higher to avoid overflowing the character cell
+        // but whether we should do it 1, 2 or 3 pixels higher is not clear.
+        //
+        // The currently used value seems to be compatible with native MSW
+        // behaviour, i.e. it results in the same appearance of the owner-drawn
+        // and normal labels.
+        yUnderscore -= 2;

 
         DrawLine(startUnderscore, yUnderscore, endUnderscore, yUnderscore);
     }
 
         DrawLine(startUnderscore, yUnderscore, endUnderscore, yUnderscore);
     }


@@ -942,162 +1239,67 @@ void wxDCBase::DrawLabel(const wxString& text,
     CalcBoundingBox(x0 + width0, y0 + height);
 }
 
     CalcBoundingBox(x0 + width0, y0 + height);
 }
 

-
-void wxDCBase::DoGradientFillLinear(const wxRect& rect,
-                                    const wxColour& initialColour,
-                                    const wxColour& destColour,
-                                    wxDirection nDirection)
-{
-    // save old pen
-    wxPen oldPen = m_pen;
-    wxBrush oldBrush = m_brush;
-
-    wxUint8 nR1 = initialColour.Red();
-    wxUint8 nG1 = initialColour.Green();
-    wxUint8 nB1 = initialColour.Blue();
-    wxUint8 nR2 = destColour.Red();
-    wxUint8 nG2 = destColour.Green();
-    wxUint8 nB2 = destColour.Blue();
-    wxUint8 nR, nG, nB;
-
-    if ( nDirection == wxEAST || nDirection == wxWEST )
+#if WXWIN_COMPATIBILITY_2_8
+    // for compatibility with the old code when wxCoord was long everywhere
+void wxDC::GetTextExtent(const wxString& string,
+                       long *x, long *y,
+                       long *descent,
+                       long *externalLeading,
+                       const wxFont *theFont) const

     {
     {

-        wxInt32 x = rect.GetWidth();
-        wxInt32 w = x;              // width of area to shade
-        wxInt32 xDelta = w/256;     // height of one shade bend
-        if (xDelta < 1)
-            xDelta = 1;
-
-        while (x >= xDelta)
-        {
-            x -= xDelta;
-            if (nR1 > nR2)
-                nR = nR1 - (nR1-nR2)*(w-x)/w;
-            else
-                nR = nR1 + (nR2-nR1)*(w-x)/w;
-
-            if (nG1 > nG2)
-                nG = nG1 - (nG1-nG2)*(w-x)/w;
-            else
-                nG = nG1 + (nG2-nG1)*(w-x)/w;
-
-            if (nB1 > nB2)
-                nB = nB1 - (nB1-nB2)*(w-x)/w;
-            else
-                nB = nB1 + (nB2-nB1)*(w-x)/w;
-
-            wxColour colour(nR,nG,nB);
-            SetPen(wxPen(colour, 1, wxSOLID));
-            SetBrush(wxBrush(colour));
-            if(nDirection == wxEAST)
-                DrawRectangle(rect.GetRight()-x-xDelta, rect.GetTop(),
-                        xDelta, rect.GetHeight());
-            else //nDirection == wxWEST
-                DrawRectangle(rect.GetLeft()+x, rect.GetTop(),
-                        xDelta, rect.GetHeight());
-        }
+        wxCoord x2, y2, descent2, externalLeading2;
+        m_pimpl->DoGetTextExtent(string, &x2, &y2,
+                        &descent2, &externalLeading2,
+                        theFont);
+        if ( x )
+            *x = x2;
+        if ( y )
+            *y = y2;
+        if ( descent )
+            *descent = descent2;
+        if ( externalLeading )
+            *externalLeading = externalLeading2;

     }
     }

-    else  // nDirection == wxNORTH || nDirection == wxSOUTH
-    {
-        wxInt32 y = rect.GetHeight();
-        wxInt32 w = y;              // height of area to shade
-        wxInt32 yDelta = w/255;     // height of one shade bend
-        if (yDelta < 1)
-            yDelta = 1;
-
-        while (y > 0)
-        {
-            y -= yDelta;
-            if (nR1 > nR2)
-                nR = nR1 - (nR1-nR2)*(w-y)/w;
-            else
-                nR = nR1 + (nR2-nR1)*(w-y)/w;
-
-            if (nG1 > nG2)
-                nG = nG1 - (nG1-nG2)*(w-y)/w;
-            else
-                nG = nG1 + (nG2-nG1)*(w-y)/w;

 
 

-            if (nB1 > nB2)
-                nB = nB1 - (nB1-nB2)*(w-y)/w;
-            else
-                nB = nB1 + (nB2-nB1)*(w-y)/w;
-
-            wxColour colour(nR,nG,nB);
-            SetPen(wxPen(colour, 1, wxSOLID));
-            SetBrush(wxBrush(colour));
-            if(nDirection == wxNORTH)
-                DrawRectangle(rect.GetLeft(), rect.GetTop()+y,
-                        rect.GetWidth(), yDelta);
-            else //nDirection == wxSOUTH
-                DrawRectangle(rect.GetLeft(), rect.GetBottom()-y-yDelta,
-                        rect.GetWidth(), yDelta);
-        }
+void wxDC::GetLogicalOrigin(long *x, long *y) const
+    {
+        wxCoord x2, y2;
+        m_pimpl->DoGetLogicalOrigin(&x2, &y2);
+        if ( x )
+            *x = x2;
+        if ( y )
+            *y = y2;

     }
 
     }
 

-    SetPen(oldPen);
-    SetBrush(oldBrush);
-}
-
-void wxDCBase::DoGradientFillConcentric(const wxRect& rect,
-                                      const wxColour& initialColour,
-                                      const wxColour& destColour,
-                                      const wxPoint& circleCenter)
-{
-    //save the old pen color
-    wxColour oldPenColour = m_pen.GetColour();
-
-    wxUint8 nR1 = destColour.Red();
-    wxUint8 nG1 = destColour.Green();
-    wxUint8 nB1 = destColour.Blue();
-    wxUint8 nR2 = initialColour.Red();
-    wxUint8 nG2 = initialColour.Green();
-    wxUint8 nB2 = initialColour.Blue();
-    wxUint8 nR, nG, nB;
-
-
-    //Radius
-    wxInt32 cx = rect.GetWidth() / 2;
-    wxInt32 cy = rect.GetHeight() / 2;
-    wxInt32 nRadius;
-    if (cx < cy)
-        nRadius = cx;
-    else
-        nRadius = cy;
-
-    //Offset of circle
-    wxInt32 nCircleOffX = circleCenter.x - (rect.GetWidth() / 2);
-    wxInt32 nCircleOffY = circleCenter.y - (rect.GetHeight() / 2);
-
-    for ( wxInt32 x = 0; x < rect.GetWidth(); x++ )
+void wxDC::GetDeviceOrigin(long *x, long *y) const

     {
     {

-        for ( wxInt32 y = 0; y < rect.GetHeight(); y++ )
-        {
-            //get color difference
-            wxInt32 nGradient = ((nRadius -
-                                  (wxInt32)sqrt(
-                                    pow((double)(x - cx - nCircleOffX), 2) +
-                                    pow((double)(y - cy - nCircleOffY), 2)
-                                  )) * 100) / nRadius;
-
-            //normalize Gradient
-            if (nGradient < 0 )
-                nGradient = 0;
-
-            //get dest colors
-            nR = (wxUint8)(nR1 + ((nR2 - nR1) * nGradient / 100));
-            nG = (wxUint8)(nG1 + ((nG2 - nG1) * nGradient / 100));
-            nB = (wxUint8)(nB1 + ((nB2 - nB1) * nGradient / 100));
+        wxCoord x2, y2;
+        m_pimpl->DoGetDeviceOrigin(&x2, &y2);
+        if ( x )
+            *x = x2;
+        if ( y )
+            *y = y2;
+    }

 
 

-            //set the pixel
-            m_pen.SetColour(wxColour(nR,nG,nB));
-            DrawPoint(wxPoint(x + rect.GetLeft(), y + rect.GetTop()));
-        }
+void wxDC::GetClippingBox(long *x, long *y, long *w, long *h) const
+    {
+        wxCoord xx,yy,ww,hh;
+        m_pimpl->DoGetClippingBox(&xx, &yy, &ww, &hh);
+        if (x) *x = xx;
+        if (y) *y = yy;
+        if (w) *w = ww;
+        if (h) *h = hh;

     }
     }

-    //return old pen color
-    m_pen.SetColour(oldPenColour);
+
+void wxDC::DrawObject(wxDrawObject* drawobject)
+{
+    drawobject->Draw(*this);
+    CalcBoundingBox(drawobject->MinX(),drawobject->MinY());
+    CalcBoundingBox(drawobject->MaxX(),drawobject->MaxY());

 }
 
 }
 

+#endif  // WXWIN_COMPATIBILITY_2_8
+

 /*
 Notes for wxWidgets DrawEllipticArcRot(...)
 
 /*
 Notes for wxWidgets DrawEllipticArcRot(...)
 


@@ -1140,26 +1342,26 @@ p.lenhard@t-online.de
 */
 
 #ifdef __WXWINCE__
 */
 
 #ifdef __WXWINCE__

-void wxDCBase::DoDrawEllipticArcRot( wxCoord x, wxCoord y,
+void wxDCImpl::DoDrawEllipticArcRot( wxCoord x, wxCoord y,

                                      wxCoord w, wxCoord h,
                                      double sa, double ea, double angle )
 {
                                      wxCoord w, wxCoord h,
                                      double sa, double ea, double angle )
 {

-    wxList list;
+    wxPointList list;

 
     CalculateEllipticPoints( &list, x, y, w, h, sa, ea );
     Rotate( &list, angle, wxPoint( x+w/2, y+h/2 ) );
 
     // Add center (for polygon/pie)
 
     CalculateEllipticPoints( &list, x, y, w, h, sa, ea );
     Rotate( &list, angle, wxPoint( x+w/2, y+h/2 ) );
 
     // Add center (for polygon/pie)

-    list.Append( (wxObject*) new wxPoint( x+w/2, y+h/2 ) );
+    list.Append( new wxPoint( x+w/2, y+h/2 ) );

 
     // copy list into array and delete list elements
     int n = list.GetCount();
     wxPoint *points = new wxPoint[n];
     int i = 0;
 
     // copy list into array and delete list elements
     int n = list.GetCount();
     wxPoint *points = new wxPoint[n];
     int i = 0;

-    wxNode* node = 0;
+    wxPointList::compatibility_iterator node;

     for ( node = list.GetFirst(); node; node = node->GetNext(), i++ )
     {
     for ( node = list.GetFirst(); node; node = node->GetNext(), i++ )
     {

-        wxPoint *point = (wxPoint *)node->GetData();
+        wxPoint *point = node->GetData();

         points[i].x = point->x;
         points[i].y = point->y;
         delete point;
         points[i].x = point->x;
         points[i].y = point->y;
         delete point;


@@ -1185,16 +1387,17 @@ void wxDCBase::DoDrawEllipticArcRot( wxCoord x, wxCoord y,
 
 } // DrawEllipticArcRot
 
 
 } // DrawEllipticArcRot
 

-void wxDCBase::Rotate( wxList* points, double angle, wxPoint center )
+void wxDCImpl::Rotate( wxPointList* points, double angle, wxPoint center )

 {
     if( angle != 0.0 )
     {
         double pi(M_PI);
         double dSinA = -sin(angle*2.0*pi/360.0);
         double dCosA = cos(angle*2.0*pi/360.0);
 {
     if( angle != 0.0 )
     {
         double pi(M_PI);
         double dSinA = -sin(angle*2.0*pi/360.0);
         double dCosA = cos(angle*2.0*pi/360.0);

-        for ( wxNode* node = points->GetFirst(); node; node = node->GetNext() )
+        wxPointList::compatibility_iterator node;
+        for ( node = points->GetFirst(); node; node = node->GetNext() )

         {
         {

-            wxPoint* point = (wxPoint*)node->GetData();
+            wxPoint* point = node->GetData();

 
             // transform coordinates, if necessary
             if( center.x ) point->x -= center.x;
 
             // transform coordinates, if necessary
             if( center.x ) point->x -= center.x;


@@ -1212,7 +1415,7 @@ void wxDCBase::Rotate( wxList* points, double angle, wxPoint center )
     }
 }
 
     }
 }
 

-void wxDCBase::CalculateEllipticPoints( wxList* points,
+void wxDCImpl::CalculateEllipticPoints( wxPointList* points,

                                         wxCoord xStart, wxCoord yStart,
                                         wxCoord w, wxCoord h,
                                         double sa, double ea )
                                         wxCoord xStart, wxCoord yStart,
                                         wxCoord w, wxCoord h,
                                         double sa, double ea )


@@ -1285,7 +1488,7 @@ void wxDCBase::CalculateEllipticPoints( wxList* points,
     long y2_old = 0;
     long y_old = 0;
     // Lists for quadrant 1 to 4
     long y2_old = 0;
     long y_old = 0;
     // Lists for quadrant 1 to 4

-    wxList pointsarray[4];
+    wxPointList pointsarray[4];

     // Calculate points for first quadrant and set in all quadrants
     for( x = 0; x <= a; ++x )
     {
     // Calculate points for first quadrant and set in all quadrants
     for( x = 0; x <= a; ++x )
     {


@@ -1299,45 +1502,46 @@ void wxDCBase::CalculateEllipticPoints( wxList* points,
             y2 = y2-y-y+1;
             --y;
         }
             y2 = y2-y-y+1;
             --y;
         }

-        // old y now to big: set point with old y, old x
+        // old y now too big: set point with old y, old x

         if( bNewPoint && x>1)
         {
             int x1 = x - 1;
             // remove points on the same line
         if( bNewPoint && x>1)
         {
             int x1 = x - 1;
             // remove points on the same line

-            pointsarray[0].Insert( (wxObject*) new wxPoint( xCenter + x1 - decrX, yCenter - y_old ) );
-            pointsarray[1].Append( (wxObject*) new wxPoint( xCenter - x1, yCenter - y_old ) );
-            pointsarray[2].Insert( (wxObject*) new wxPoint( xCenter - x1, yCenter + y_old - decrY ) );
-            pointsarray[3].Append( (wxObject*) new wxPoint( xCenter + x1 - decrX, yCenter + y_old - decrY ) );
+            pointsarray[0].Insert( new wxPoint( xCenter + x1 - decrX, yCenter - y_old ) );
+            pointsarray[1].Append( new wxPoint( xCenter - x1, yCenter - y_old ) );
+            pointsarray[2].Insert( new wxPoint( xCenter - x1, yCenter + y_old - decrY ) );
+            pointsarray[3].Append( new wxPoint( xCenter + x1 - decrX, yCenter + y_old - decrY ) );

         } // set point
     } // calculate point
 
     // Starting and/or ending points for the quadrants, first quadrant gets both.
         } // set point
     } // calculate point
 
     // Starting and/or ending points for the quadrants, first quadrant gets both.

-    pointsarray[0].Insert( (wxObject*) new wxPoint( xCenter + a - decrX, yCenter ) );
-    pointsarray[0].Append( (wxObject*) new wxPoint( xCenter, yCenter - b ) );
-    pointsarray[1].Append( (wxObject*) new wxPoint( xCenter - a, yCenter ) );
-    pointsarray[2].Append( (wxObject*) new wxPoint( xCenter, yCenter + b - decrY ) );
-    pointsarray[3].Append( (wxObject*) new wxPoint( xCenter + a - decrX, yCenter ) );
+    pointsarray[0].Insert( new wxPoint( xCenter + a - decrX, yCenter ) );
+    pointsarray[0].Append( new wxPoint( xCenter, yCenter - b ) );
+    pointsarray[1].Append( new wxPoint( xCenter - a, yCenter ) );
+    pointsarray[2].Append( new wxPoint( xCenter, yCenter + b - decrY ) );
+    pointsarray[3].Append( new wxPoint( xCenter + a - decrX, yCenter ) );

 
     // copy quadrants in original list
     if( bUseAngles )
     {
         // Copy the right part of the points in the lists
         // and delete the wxPoints, because they do not leave this method.
 
     // copy quadrants in original list
     if( bUseAngles )
     {
         // Copy the right part of the points in the lists
         // and delete the wxPoints, because they do not leave this method.

-        points->Append( (wxObject*) new wxPoint( xsa, ysa ) );
+        points->Append( new wxPoint( xsa, ysa ) );

         int q = sq;
         bool bStarted = false;
         bool bReady = false;
         bool bForceTurn = ( sq == eq && sa > ea );
         while( !bReady )
         {
         int q = sq;
         bool bStarted = false;
         bool bReady = false;
         bool bForceTurn = ( sq == eq && sa > ea );
         while( !bReady )
         {

-            for( wxNode *node = pointsarray[q].GetFirst(); node; node = node->GetNext() )
+            wxPointList::compatibility_iterator node;
+            for( node = pointsarray[q].GetFirst(); node; node = node->GetNext() )

             {
                 // once: go to starting point in start quadrant
                 if( !bStarted &&
                     (
             {
                 // once: go to starting point in start quadrant
                 if( !bStarted &&
                     (

-                      ( (wxPoint*) node->GetData() )->x < xsa+1 && q <= 1
+                      node->GetData()->x < xsa+1 && q <= 1

                       ||
                       ||

-                      ( (wxPoint*) node->GetData() )->x > xsa-1 && q >= 2
+                      node->GetData()->x > xsa-1 && q >= 2

                     )
                   )
                 {
                     )
                   )
                 {


@@ -1355,10 +1559,10 @@ void wxDCBase::CalculateEllipticPoints( wxList* points,
                       )
                     {
                         // copy point
                       )
                     {
                         // copy point

-                        wxPoint* pPoint = new wxPoint( *((wxPoint*) node->GetData() ) );
-                        points->Append( (wxObject*) pPoint );
+                        wxPoint* pPoint = new wxPoint( *(node->GetData()) );
+                        points->Append( pPoint );

                     }
                     }

-                    else if( q == eq && !bForceTurn || ( (wxPoint*) node->GetData() )->x == xea)
+                    else if( q == eq && !bForceTurn || node->GetData()->x == xea)

                     {
                         bReady = true;
                     }
                     {
                         bReady = true;
                     }


@@ -1369,43 +1573,56 @@ void wxDCBase::CalculateEllipticPoints( wxList* points,
             bForceTurn = false;
             bStarted = true;
         } // while not bReady
             bForceTurn = false;
             bStarted = true;
         } // while not bReady

-        points->Append( (wxObject*) new wxPoint( xea, yea ) );
+        points->Append( new wxPoint( xea, yea ) );

 
         // delete points
         for( q = 0; q < 4; ++q )
         {
 
         // delete points
         for( q = 0; q < 4; ++q )
         {

-            for( wxNode *node = pointsarray[q].GetFirst(); node; node = node->GetNext() )
+            wxPointList::compatibility_iterator node;
+            for( node = pointsarray[q].GetFirst(); node; node = node->GetNext() )

             {
             {

-                wxPoint *p = (wxPoint *)node->GetData();
+                wxPoint *p = node->GetData();

                 delete p;
             }
         }
     }
     else
     {
                 delete p;
             }
         }
     }
     else
     {

-        wxNode* node;
+        wxPointList::compatibility_iterator node;

         // copy whole ellipse, wxPoints will be deleted outside
         for( node = pointsarray[0].GetFirst(); node; node = node->GetNext() )
         {
         // copy whole ellipse, wxPoints will be deleted outside
         for( node = pointsarray[0].GetFirst(); node; node = node->GetNext() )
         {

-            wxObject *p = node->GetData();
+            wxPoint *p = node->GetData();

             points->Append( p );
         }
         for( node = pointsarray[1].GetFirst(); node; node = node->GetNext() )
         {
             points->Append( p );
         }
         for( node = pointsarray[1].GetFirst(); node; node = node->GetNext() )
         {

-            wxObject *p = node->GetData();
+            wxPoint *p = node->GetData();

             points->Append( p );
         }
         for( node = pointsarray[2].GetFirst(); node; node = node->GetNext() )
         {
             points->Append( p );
         }
         for( node = pointsarray[2].GetFirst(); node; node = node->GetNext() )
         {

-            wxObject *p = node->GetData();
+            wxPoint *p = node->GetData();

             points->Append( p );
         }
         for( node = pointsarray[3].GetFirst(); node; node = node->GetNext() )
         {
             points->Append( p );
         }
         for( node = pointsarray[3].GetFirst(); node; node = node->GetNext() )
         {

-            wxObject *p = node->GetData();
+            wxPoint *p = node->GetData();

             points->Append( p );
         }
     } // not iUseAngles
 } // CalculateEllipticPoints
 
 #endif // __WXWINCE__
             points->Append( p );
         }
     } // not iUseAngles
 } // CalculateEllipticPoints
 
 #endif // __WXWINCE__

+
+float wxDCImpl::GetFontPointSizeAdjustment(float dpi)
+{
+    // wxMSW has long-standing bug where wxFont point size is interpreted as
+    // "pixel size corresponding to given point size *on screen*". In other
+    // words, on a typical 600dpi printer and a typical 96dpi screen, fonts
+    // are ~6 times smaller when printing. Unfortunately, this bug is so severe
+    // that *all* printing code has to account for it and consequently, other
+    // ports need to emulate this bug too:
+    const wxSize screenPPI = wxGetDisplayPPI();
+    return float(screenPPI.y) / dpi;
+}