]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/dcbase.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Added wxVariantData::Clone and wxVariant::Unshare
[wxWidgets.git] / src / common / dcbase.cpp
diff --git a/src/common/dcbase.cpp b/src/common/dcbase.cpp
index f42c88530e070a08b9cc46f1e58e263eb8759efc..a6e495af411513c3ce188dc9e3e7c97cec29a1a3 100644 (file)
--- a/src/common/dcbase.cpp
+++ b/src/common/dcbase.cpp
@@ -25,6 +25,9 @@
 #endif
 
 #include "wx/dc.h"
 #endif
 
 #include "wx/dc.h"
+#include "wx/dcclient.h"
+#include "wx/dcmemory.h"
+#include "wx/dcscreen.h"
 #include "wx/dcbuffer.h" // for IMPLEMENT_DYNAMIC_CLASS
 
 #ifndef WX_PRECOMP
 #include "wx/dcbuffer.h" // for IMPLEMENT_DYNAMIC_CLASS
 
 #ifndef WX_PRECOMP
@@ -61,246 +64,273 @@ wxDCFactory *wxDCFactory::GetFactory()
 // wxNativeDCFactory
 //-----------------------------------------------------------------------------
 
 // wxNativeDCFactory
 //-----------------------------------------------------------------------------
 
-wxImplDC* wxNativeDCFactory::CreateWindowDC()
+wxImplDC* wxNativeDCFactory::CreateWindowDC( wxWindowDC *owner )
 { 
 #if defined(__WXMSW__)
 { 
 #if defined(__WXMSW__)
-    return new wxWindowsWindowImplDC();
+    return new wxWindowsWindowImplDC( owner );
 #elif defined(__WXGTK20__)
 #elif defined(__WXGTK20__)
-    return new wxGTKWindowImplDC();
+    return new wxGTKWindowImplDC( owner );
 #elif defined(__WXGTK__)
 #elif defined(__WXGTK__)
-    return new wxGTKWindowImplDC();
+    return new wxGTKWindowImplDC( owner );
 #elif defined(__WXMAC__)
 #elif defined(__WXMAC__)
-    return new wxMacWindowImplDC();
+    return new wxMacWindowImplDC( owner );
 #elif defined(__WXCOCOA__)
 #elif defined(__WXCOCOA__)
-    return new wxCocoaWindowImplDC();
+    return new wxCocoaWindowImplDC( owner );
 #elif defined(__WXMOTIF__)
 #elif defined(__WXMOTIF__)
-    return new wxMotifWindowImplDC();
+    return new wxMotifWindowImplDC( owner );
 #elif defined(__WXX11__)
 #elif defined(__WXX11__)
-    return new wxX11WindowImplDC();
+    return new wxX11WindowImplDC( owner );
 #elif defined(__WXMGL__)
 #elif defined(__WXMGL__)
-    return new wxMGLWindowImplDC();
+    return new wxMGLWindowImplDC( owner );
 #elif defined(__WXDFB__)
 #elif defined(__WXDFB__)
-    return new wxDFBWindowImplDC();
+    return new wxDFBWindowImplDC( owner );
 #elif defined(__WXPM__)
 #elif defined(__WXPM__)
-    return new wxPMWindowImplDC();
+    return new wxPMWindowImplDC( owner );
 #elif defined(__PALMOS__)
 #elif defined(__PALMOS__)
-    return new wxPalmWindowImplDC();
+    return new wxPalmWindowImplDC( owner );
 #endif
 }
 
 #endif
 }
 
-wxImplDC* wxNativeDCFactory::CreateWindowDC( wxWindow *window )
+wxImplDC* wxNativeDCFactory::CreateWindowDC( wxWindowDC *owner, wxWindow *window )
 { 
 #if defined(__WXMSW__)
 { 
 #if defined(__WXMSW__)
-    return new wxWindowsWindowImplDC( window );
+    return new wxWindowsWindowImplDC( owner, window );
 #elif defined(__WXGTK20__)
 #elif defined(__WXGTK20__)
-    return new wxGTKWindowImplDC( window );
+    return new wxGTKWindowImplDC( owner, window );
 #elif defined(__WXGTK__)
 #elif defined(__WXGTK__)
-    return new wxGTKWindowImplDC( window );
+    return new wxGTKWindowImplDC( owner, window );
 #elif defined(__WXMAC__)
 #elif defined(__WXMAC__)
-    return new wxMacWindowImplDC( window );
+    return new wxMacWindowImplDC( owner, window );
 #elif defined(__WXCOCOA__)
 #elif defined(__WXCOCOA__)
-    return new wxCocoaWindowImplDC( window );
+    return new wxCocoaWindowImplDC( owner, window );
 #elif defined(__WXMOTIF__)
 #elif defined(__WXMOTIF__)
-    return new wxMotifWindowImplDC( window );
+    return new wxMotifWindowImplDC( owner, window );
 #elif defined(__WXX11__)
 #elif defined(__WXX11__)
-    return new wxX11WindowImplDC( window );
+    return new wxX11WindowImplDC( owner, window );
 #elif defined(__WXMGL__)
 #elif defined(__WXMGL__)
-    return new wxMGLWindowImplDC( window );
+    return new wxMGLWindowImplDC( owner, window );
 #elif defined(__WXDFB__)
 #elif defined(__WXDFB__)
-    return new wxDFBWindowImplDC( window );
+    return new wxDFBWindowImplDC( owner, window );
 #elif defined(__WXPM__)
 #elif defined(__WXPM__)
-    return new wxPMWindowImplDC( window );
+    return new wxPMWindowImplDC( owner, window );
 #elif defined(__PALMOS__)
 #elif defined(__PALMOS__)
-    return new wxPalmWindowImplDC( window );
+    return new wxPalmWindowImplDC( owner, window );
 #endif
 }
 
 #endif
 }
 
-wxImplDC* wxNativeDCFactory::CreateClientDC()
+wxImplDC* wxNativeDCFactory::CreateClientDC( wxClientDC *owner )
 {
 #if defined(__WXMSW__)
 {
 #if defined(__WXMSW__)
-    return new wxWindowsClientImplDC();
+    return new wxWindowsClientImplDC( owner );
 #elif defined(__WXGTK20__)
 #elif defined(__WXGTK20__)
-    return new wxGTKClientImplDC();
+    return new wxGTKClientImplDC( owner );
 #elif defined(__WXGTK__)
 #elif defined(__WXGTK__)
-    return new wxGTKClientImplDC();
+    return new wxGTKClientImplDC( owner );
 #elif defined(__WXMAC__)
 #elif defined(__WXMAC__)
-    return new wxMacClientImplDC();
+    return new wxMacClientImplDC( owner );
 #elif defined(__WXCOCOA__)
 #elif defined(__WXCOCOA__)
-    return new wxCocoaClientImplDC();
+    return new wxCocoaClientImplDC( owner );
 #elif defined(__WXMOTIF__)
 #elif defined(__WXMOTIF__)
-    return new wxMotifClientImplDC();
+    return new wxMotifClientImplDC( owner );
 #elif defined(__WXX11__)
 #elif defined(__WXX11__)
-    return new wxX11ClientImplDC();
+    return new wxX11ClientImplDC( owner );
 #elif defined(__WXMGL__)
 #elif defined(__WXMGL__)
-    return new wxMGLClientImplDC();
+    return new wxMGLClientImplDC( owner );
 #elif defined(__WXDFB__)
 #elif defined(__WXDFB__)
-    return new wxDFBClientImplDC();
+    return new wxDFBClientImplDC( owner );
 #elif defined(__WXPM__)
 #elif defined(__WXPM__)
-    return new wxPMClientImplDC();
+    return new wxPMClientImplDC( owner );
 #elif defined(__PALMOS__)
 #elif defined(__PALMOS__)
-    return new wxPalmClientImplDC();
+    return new wxPalmClientImplDC( owner );
 #endif
 }
 
 #endif
 }
 
-wxImplDC* wxNativeDCFactory::CreateClientDC( wxWindow *window )
+wxImplDC* wxNativeDCFactory::CreateClientDC( wxClientDC *owner, wxWindow *window )
 {
 #if defined(__WXMSW__)
 {
 #if defined(__WXMSW__)
-    return new wxWindowsClientImplDC( window );
+    return new wxWindowsClientImplDC( owner, window );
 #elif defined(__WXGTK20__)
 #elif defined(__WXGTK20__)
-    return new wxGTKClientImplDC( window );
+    return new wxGTKClientImplDC( owner, window );
 #elif defined(__WXGTK__)
 #elif defined(__WXGTK__)
-    return new wxGTKClientImplDC( window );
+    return new wxGTKClientImplDC( owner, window );
 #elif defined(__WXMAC__)
 #elif defined(__WXMAC__)
-    return new wxMacClientImplDC( window );
+    return new wxMacClientImplDC( owner, window );
 #elif defined(__WXCOCOA__)
 #elif defined(__WXCOCOA__)
-    return new wxCocoaClientImplDC( window );
+    return new wxCocoaClientImplDC( owner, window );
 #elif defined(__WXMOTIF__)
 #elif defined(__WXMOTIF__)
-    return new wxMotifClientImplDC( window );
+    return new wxMotifClientImplDC( owner, window );
 #elif defined(__WXX11__)
 #elif defined(__WXX11__)
-    return new wxX11ClientImplDC( window );
+    return new wxX11ClientImplDC( owner, window );
 #elif defined(__WXMGL__)
 #elif defined(__WXMGL__)
-    return new wxMGLClientImplDC( window );
+    return new wxMGLClientImplDC( owner, window );
 #elif defined(__WXDFB__)
 #elif defined(__WXDFB__)
-    return new wxDFBClientImplDC( window );
+    return new wxDFBClientImplDC( owner, window );
 #elif defined(__WXPM__)
 #elif defined(__WXPM__)
-    return new wxPMClientImplDC( window );
+    return new wxPMClientImplDC( owner, window );
 #elif defined(__PALMOS__)
 #elif defined(__PALMOS__)
-    return new wxPalmClientImplDC( window );
+    return new wxPalmClientImplDC( owner, window );
 #endif
 }
 
 #endif
 }
 
-wxImplDC* wxNativeDCFactory::CreatePaintDC()
+wxImplDC* wxNativeDCFactory::CreatePaintDC( wxPaintDC *owner )
 {
 #if defined(__WXMSW__)
 {
 #if defined(__WXMSW__)
-    return new wxWindowsPaintImplDC();
+    return new wxWindowsPaintImplDC( owner );
 #elif defined(__WXGTK20__)
 #elif defined(__WXGTK20__)
-    return new wxGTKPaintImplDC();
+    return new wxGTKPaintImplDC( owner );
 #elif defined(__WXGTK__)
 #elif defined(__WXGTK__)
-    return new wxGTKPaintImplDC();
+    return new wxGTKPaintImplDC( owner );
 #elif defined(__WXMAC__)
 #elif defined(__WXMAC__)
-    return new wxMacPaintImplDC();
+    return new wxMacPaintImplDC( owner );
 #elif defined(__WXCOCOA__)
 #elif defined(__WXCOCOA__)
-    return new wxCocoaPaintImplDC();
+    return new wxCocoaPaintImplDC( owner );
 #elif defined(__WXMOTIF__)
 #elif defined(__WXMOTIF__)
-    return new wxMotifPaintImplDC();
+    return new wxMotifPaintImplDC( owner );
 #elif defined(__WXX11__)
 #elif defined(__WXX11__)
-    return new wxX11PaintImplDC();
+    return new wxX11PaintImplDC( owner );
 #elif defined(__WXMGL__)
 #elif defined(__WXMGL__)
-    return new wxMGLPaintImplDC();
+    return new wxMGLPaintImplDC( owner );
 #elif defined(__WXDFB__)
 #elif defined(__WXDFB__)
-    return new wxDFBPaintImplDC();
+    return new wxDFBPaintImplDC( owner );
 #elif defined(__WXPM__)
 #elif defined(__WXPM__)
-    return new wxPMPaintImplDC();
+    return new wxPMPaintImplDC( owner );
 #elif defined(__PALMOS__)
 #elif defined(__PALMOS__)
-    return new wxPalmPaintImplDC();
+    return new wxPalmPaintImplDC( owner );
 #endif
 }
 
 #endif
 }
 
-wxImplDC* wxNativeDCFactory::CreatePaintDC( wxWindow *window )
+wxImplDC* wxNativeDCFactory::CreatePaintDC( wxPaintDC *owner, wxWindow *window )
 {
 #if defined(__WXMSW__)
 {
 #if defined(__WXMSW__)
-    return new wxWindowsPaintImplDC( window );
+    return new wxWindowsPaintImplDC( owner, window );
 #elif defined(__WXGTK20__)
 #elif defined(__WXGTK20__)
-    return new wxGTKPaintImplDC( window );
+    return new wxGTKPaintImplDC( owner, window );
 #elif defined(__WXGTK__)
 #elif defined(__WXGTK__)
-    return new wxGTKPaintImplDC( window );
+    return new wxGTKPaintImplDC( owner, window );
 #elif defined(__WXMAC__)
 #elif defined(__WXMAC__)
-    return new wxMacPaintImplDC( window );
+    return new wxMacPaintImplDC( owner, window );
 #elif defined(__WXCOCOA__)
 #elif defined(__WXCOCOA__)
-    return new wxCocoaPaintImplDC( window );
+    return new wxCocoaPaintImplDC( owner, window );
 #elif defined(__WXMOTIF__)
 #elif defined(__WXMOTIF__)
-    return new wxMotifPaintImplDC( window );
+    return new wxMotifPaintImplDC( owner, window );
 #elif defined(__WXX11__)
 #elif defined(__WXX11__)
-    return new wxX11PaintImplDC( window );
+    return new wxX11PaintImplDC( owner, window );
 #elif defined(__WXMGL__)
 #elif defined(__WXMGL__)
-    return new wxMGLPaintImplDC( window );
+    return new wxMGLPaintImplDC( owner, window );
 #elif defined(__WXDFB__)
 #elif defined(__WXDFB__)
-    return new wxDFBPaintImplDC( window );
+    return new wxDFBPaintImplDC( owner, window );
 #elif defined(__WXPM__)
 #elif defined(__WXPM__)
-    return new wxPMPaintImplDC( window );
+    return new wxPMPaintImplDC( owner, window );
 #elif defined(__PALMOS__)
 #elif defined(__PALMOS__)
-    return new wxPalmPaintImplDC( window );
+    return new wxPalmPaintImplDC( owner, window );
 #endif
 }
 
 #endif
 }
 
-wxImplDC* wxNativeDCFactory::CreateMemoryDC()
+wxImplDC* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner )
 {
 #if defined(__WXMSW__)
 {
 #if defined(__WXMSW__)
-    return new wxWindowsMemoryImplDC();
+    return new wxWindowsMemoryImplDC( owner );
 #elif defined(__WXGTK20__)
 #elif defined(__WXGTK20__)
-    return new wxGTKMemoryImplDC();
+    return new wxGTKMemoryImplDC( owner );
 #elif defined(__WXGTK__)
 #elif defined(__WXGTK__)
-    return new wxGTKMemoryImplDC();
+    return new wxGTKMemoryImplDC( owner );
 #elif defined(__WXMAC__)
 #elif defined(__WXMAC__)
-    return new wxMacMemoryImplDC();
+    return new wxMacMemoryImplDC( owner );
 #elif defined(__WXCOCOA__)
 #elif defined(__WXCOCOA__)
-    return new wxCocoaMemoryImplDC();
+    return new wxCocoaMemoryImplDC( owner );
 #elif defined(__WXMOTIF__)
 #elif defined(__WXMOTIF__)
-    return new wxMotifMemoryImplDC();
+    return new wxMotifMemoryImplDC( owner );
 #elif defined(__WXX11__)
 #elif defined(__WXX11__)
-    return new wxX11MemoryImplDC();
+    return new wxX11MemoryImplDC( owner );
 #elif defined(__WXMGL__)
 #elif defined(__WXMGL__)
-    return new wxMGLMemoryImplDC();
+    return new wxMGLMemoryImplDC( owner );
 #elif defined(__WXDFB__)
 #elif defined(__WXDFB__)
-    return new wxDFBMemoryImplDC();
+    return new wxDFBMemoryImplDC( owner );
 #elif defined(__WXPM__)
 #elif defined(__WXPM__)
-    return new wxPMMemoryImplDC();
+    return new wxPMMemoryImplDC( owner );
 #elif defined(__PALMOS__)
 #elif defined(__PALMOS__)
-    return new wxPalmMemoryImplDC();
+    return new wxPalmMemoryImplDC( owner );
 #endif
 }
 
 #endif
 }
 
-wxImplDC* wxNativeDCFactory::CreateMemoryDC( wxBitmap &bitmap )
+wxImplDC* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner, wxBitmap &bitmap )
 {
 #if defined(__WXMSW__)
 {
 #if defined(__WXMSW__)
-    return new wxWindowsMemoryImplDC( bitmap );
+    return new wxWindowsMemoryImplDC( owner, bitmap );
 #elif defined(__WXGTK20__)
 #elif defined(__WXGTK20__)
-    return new wxGTKMemoryImplDC( bitmap );
+    return new wxGTKMemoryImplDC( owner, bitmap );
 #elif defined(__WXGTK__)
 #elif defined(__WXGTK__)
-    return new wxGTKMemoryImplDC( bitmap );
+    return new wxGTKMemoryImplDC( owner, bitmap );
 #elif defined(__WXMAC__)
 #elif defined(__WXMAC__)
-    return new wxMacMemoryImplDC( bitmap );
+    return new wxMacMemoryImplDC( owner, bitmap );
 #elif defined(__WXCOCOA__)
 #elif defined(__WXCOCOA__)
-    return new wxCocoaMemoryImplDC( bitmap );
+    return new wxCocoaMemoryImplDC( owner, bitmap );
 #elif defined(__WXMOTIF__)
 #elif defined(__WXMOTIF__)
-    return new wxMotifMemoryImplDC( bitmap );
+    return new wxMotifMemoryImplDC( owner, bitmap );
 #elif defined(__WXX11__)
 #elif defined(__WXX11__)
-    return new wxX11MemoryImplDC( bitmap );
+    return new wxX11MemoryImplDC( owner, bitmap );
 #elif defined(__WXMGL__)
 #elif defined(__WXMGL__)
-    return new wxMGLMemoryImplDC( bitmap );
+    return new wxMGLMemoryImplDC( owner, bitmap );
 #elif defined(__WXDFB__)
 #elif defined(__WXDFB__)
-    return new wxDFBMemoryImplDC( bitmap );
+    return new wxDFBMemoryImplDC( owner, bitmap );
 #elif defined(__WXPM__)
 #elif defined(__WXPM__)
-    return new wxPMMemoryImplDC( bitmap );
+    return new wxPMMemoryImplDC( owner, bitmap );
 #elif defined(__PALMOS__)
 #elif defined(__PALMOS__)
-    return new wxPalmMemoryImplDC( bitmap );
+    return new wxPalmMemoryImplDC( owner, bitmap );
 #endif
 }
 
 #endif
 }
 
-wxImplDC* wxNativeDCFactory::CreateMemoryDC( wxDC *dc )
+wxImplDC* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner, wxDC *dc )
 {
 #if defined(__WXMSW__)
 {
 #if defined(__WXMSW__)
-    return new wxWindowsMemoryImplDC( dc );
+    return new wxWindowsMemoryImplDC( owner, dc );
 #elif defined(__WXGTK20__)
 #elif defined(__WXGTK20__)
-    return new wxGTKMemoryImplDC( dc );
+    return new wxGTKMemoryImplDC( owner, dc );
 #elif defined(__WXGTK__)
 #elif defined(__WXGTK__)
-    return new wxGTKMemoryImplDC( dc );
+    return new wxGTKMemoryImplDC( owner, dc );
 #elif defined(__WXMAC__)
 #elif defined(__WXMAC__)
-    return new wxMacMemoryImplDC( dc );
+    return new wxMacMemoryImplDC( owner, dc );
 #elif defined(__WXCOCOA__)
 #elif defined(__WXCOCOA__)
-    return new wxCocoaMemoryImplDC( dc );
+    return new wxCocoaMemoryImplDC( owner, dc );
 #elif defined(__WXMOTIF__)
 #elif defined(__WXMOTIF__)
-    return new wxMotifMemoryImplDC( dc );
+    return new wxMotifMemoryImplDC( owner, dc );
 #elif defined(__WXX11__)
 #elif defined(__WXX11__)
-    return new wxX11MemoryImplDC( dc );
+    return new wxX11MemoryImplDC( owner, dc );
 #elif defined(__WXMGL__)
 #elif defined(__WXMGL__)
-    return new wxMGLMemoryImplDC( dc );
+    return new wxMGLMemoryImplDC( owner, dc );
 #elif defined(__WXDFB__)
 #elif defined(__WXDFB__)
-    return new wxDFBMemoryImplDC( dc );
+    return new wxDFBMemoryImplDC( owner, dc );
 #elif defined(__WXPM__)
 #elif defined(__WXPM__)
-    return new wxPMMemoryImplDC( dc );
+    return new wxPMMemoryImplDC( owner, dc );
 #elif defined(__PALMOS__)
 #elif defined(__PALMOS__)
-    return new wxPalmMemoryImplDC( dc );
+    return new wxPalmMemoryImplDC( owner, dc );
+#endif
+}
+
+wxImplDC* wxNativeDCFactory::CreateScreenDC( wxScreenDC *owner )
+{
+#if defined(__WXMSW__)
+    return new wxWindowsScreenImplDC( owner );
+#elif defined(__WXGTK20__)
+    return new wxGTKScreenImplDC( owner );
+#elif defined(__WXGTK__)
+    return new wxGTKScreenImplDC( owner );
+#elif defined(__WXMAC__)
+    return new wxMacScreenImplDC( owner );
+#elif defined(__WXCOCOA__)
+    return new wxCocoaScreenImplDC( owner );
+#elif defined(__WXMOTIF__)
+    return new wxMotifScreenImplDC( owner );
+#elif defined(__WXX11__)
+    return new wxX11ScreenImplDC( owner );
+#elif defined(__WXMGL__)
+    return new wxMGLScreenImplDC( owner );
+#elif defined(__WXDFB__)
+    return new wxDFBScreenImplDC( owner );
+#elif defined(__WXPM__)
+    return new wxPMScreenImplDC( owner );
+#elif defined(__PALMOS__)
+    return new wxPalmScreenImplDC( owner );
 #endif
 }
 
 #endif
 }
 
@@ -310,16 +340,16 @@ wxImplDC* wxNativeDCFactory::CreateMemoryDC( wxDC *dc )
 
 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
 
-wxWindow::wxWindowDC()
+wxWindowDC::wxWindowDC()
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
-    m_pimpl = factory->CreateWindowDC();
+    m_pimpl = factory->CreateWindowDC( this );
 }
 
 }
 
-wxWindow::wxWindowDC( wxWindow *win )
+wxWindowDC::wxWindowDC( wxWindow *win )
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
-    m_pimpl = factory->CreateWindowDC( win );
+    m_pimpl = factory->CreateWindowDC( this, win );
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------
@@ -331,13 +361,13 @@ IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxDC)
 wxClientDC::wxClientDC()
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
 wxClientDC::wxClientDC()
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
-    m_pimpl = factory->CreateClientDC();
+    m_pimpl = factory->CreateClientDC( this );
 }
 
 wxClientDC::wxClientDC( wxWindow *win )
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
 }
 
 wxClientDC::wxClientDC( wxWindow *win )
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
-    m_pimpl = factory->CreateClientDC( win );
+    m_pimpl = factory->CreateClientDC( this, win );
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------
@@ -349,20 +379,75 @@ IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxDC)
 wxMemoryDC::wxMemoryDC()
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
 wxMemoryDC::wxMemoryDC()
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
-    m_pimpl = factory->CreateMemoryDC();
+    m_pimpl = factory->CreateMemoryDC( this );
 }
 
 wxMemoryDC::wxMemoryDC( wxBitmap& bitmap )
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
 }
 
 wxMemoryDC::wxMemoryDC( wxBitmap& bitmap )
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
-    m_pimpl = factory->CreateMemoryDC( bitmap );
+    m_pimpl = factory->CreateMemoryDC( this, bitmap );
 }
 
 wxMemoryDC::wxMemoryDC( wxDC *dc )
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
 }
 
 wxMemoryDC::wxMemoryDC( wxDC *dc )
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
-    m_pimpl = factory->CreateMemoryDC( dc );
+    m_pimpl = factory->CreateMemoryDC( this, dc );
 }
 }
+
+void wxMemoryDC::SelectObject(wxBitmap& bmp)
+{
+    // 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();
+
+#ifdef __WXGTK__
+    wxGTKMemoryImplDC *mem_pimpl = wxDynamicCast( m_pimpl, wxGTKMemoryImplDC );
+#else
+    // TODO
+#endif
+    if (mem_pimpl)
+        mem_pimpl->DoSelect(bmp);
+}
+
+void wxMemoryDC::SelectObjectAsSource(const wxBitmap& bmp)
+{
+#ifdef __WXGTK__
+    wxGTKMemoryImplDC *mem_pimpl = wxDynamicCast( m_pimpl, wxGTKMemoryImplDC );
+#else
+    // TODO
+#endif
+    mem_pimpl->DoSelect(bmp);
+}
+
+const wxBitmap& wxMemoryDC::GetSelectedBitmap() const
+{
+#ifdef __WXGTK__
+    wxGTKMemoryImplDC *mem_pimpl = wxDynamicCast( m_pimpl, wxGTKMemoryImplDC );
+#else
+    // TODO
+#endif
+    if (mem_pimpl)
+        return mem_pimpl->DoGetSelectedBitmap();
+
+    return wxNullBitmap;    
+}
+
+wxBitmap& wxMemoryDC::GetSelectedBitmap()
+{
+#ifdef __WXGTK__
+    wxGTKMemoryImplDC *mem_pimpl = wxDynamicCast( m_pimpl, wxGTKMemoryImplDC );
+#else
+    // TODO
+#endif
+    
+    if (mem_pimpl)
+        return mem_pimpl->DoGetSelectedBitmap();
+   
+    return wxNullBitmap;    
+}
+
     
 //-----------------------------------------------------------------------------
 // wxPaintDC
     
 //-----------------------------------------------------------------------------
 // wxPaintDC
@@ -373,13 +458,25 @@ IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxDC)
 wxPaintDC::wxPaintDC()
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
 wxPaintDC::wxPaintDC()
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
-    m_pimpl = factory->CreatePaintDC();
+    m_pimpl = factory->CreatePaintDC( this );
 }
 
 wxPaintDC::wxPaintDC( wxWindow *win )
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
 }
 
 wxPaintDC::wxPaintDC( wxWindow *win )
 {
     wxDCFactory *factory = wxDCFactory::GetFactory();
-    m_pimpl = factory->CreatePaintDC( win );
+    m_pimpl = factory->CreatePaintDC( this, win );
+}
+
+//-----------------------------------------------------------------------------
+// wxScreenDC
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxWindowDC)
+
+wxScreenDC::wxScreenDC()
+{
+    wxDCFactory *factory = wxDCFactory::GetFactory();
+    m_pimpl = factory->CreateScreenDC( this );
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------
@@ -432,61 +529,6 @@ wxImplDC::~wxImplDC()
 {
 }
 
 {
 }
 
-#if WXWIN_COMPATIBILITY_2_8
-    // for compatibility with the old code when wxCoord was long everywhere
-void wxImplDC::GetTextExtent(const wxString& string,
-                       long *x, long *y,
-                       long *descent,
-                       long *externalLeading,
-                       const wxFont *theFont) 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 wxImplDC::GetLogicalOrigin(long *x, long *y) const 
-    {
-        wxCoord x2, y2;
-        DoGetLogicalOrigin(&x2, &y2);
-        if ( x )
-            *x = x2;
-        if ( y )
-            *y = y2;
-    }
-
-void wxImplDC::GetDeviceOrigin(long *x, long *y) const 
-    {
-        wxCoord x2, y2;
-        DoGetDeviceOrigin(&x2, &y2);
-        if ( x )
-            *x = x2;
-        if ( y )
-            *y = y2;
-    } 
-    
-void wxImplDC::GetClippingBox(long *x, long *y, long *w, long *h) const 
-    {
-        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
-
-
-
 // ----------------------------------------------------------------------------
 // coordinate conversions and transforms
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // coordinate conversions and transforms
 // ----------------------------------------------------------------------------
@@ -513,12 +555,12 @@ wxCoord wxImplDC::DeviceToLogicalYRel(wxCoord y) const
 
 wxCoord wxImplDC::LogicalToDeviceX(wxCoord x) const
 {
 
 wxCoord wxImplDC::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_scaleX) * m_signX + m_deviceOriginX * m_signY + m_deviceLocalOriginX;
 }
 
 wxCoord wxImplDC::LogicalToDeviceY(wxCoord y) const
 {
 }
 
 wxCoord wxImplDC::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_scaleY) * m_signY + m_deviceOriginY * m_signY + m_deviceLocalOriginY;
 }
 
 wxCoord wxImplDC::LogicalToDeviceXRel(wxCoord x) const
 }
 
 wxCoord wxImplDC::LogicalToDeviceXRel(wxCoord x) const
@@ -601,6 +643,7 @@ void wxImplDC::SetDeviceLocalOrigin( wxCoord x, wxCoord y )
 void wxImplDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
 {
     // only wxPostScripDC has m_signX = -1, we override SetAxisOrientation there
 void wxImplDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
 {
     // 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();
@@ -668,7 +711,7 @@ bool wxImplDC::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths)
         }
         else
         {
         }
         else
         {
-            GetTextExtent(c, &w, &h);
+            DoGetTextExtent(c, &w, &h);
             if (c_int < FWC_SIZE)
                 s_fontWidthCache.m_widths[c_int] = w;
         }
             if (c_int < FWC_SIZE)
                 s_fontWidthCache.m_widths[c_int] = w;
         }
@@ -750,13 +793,13 @@ void wxImplDC::GetMultiLineTextExtent(const wxString& text,
 void wxImplDC::DoDrawCheckMark(wxCoord x1, wxCoord y1,
                                wxCoord width, wxCoord height)
 {
 void wxImplDC::DoDrawCheckMark(wxCoord x1, wxCoord y1,
                                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(m_owner, 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
@@ -800,15 +843,15 @@ wxImplDC::DoStretchBlit(wxCoord xdest, wxCoord ydest,
     return rc;
 }
 
     return rc;
 }
 
-void wxImplDC::DrawLines(const wxList *list, wxCoord xoffset, wxCoord yoffset)
+void wxImplDC::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;
     }
@@ -818,7 +861,7 @@ void wxImplDC::DrawLines(const wxList *list, wxCoord xoffset, wxCoord yoffset)
     delete [] points;
 }
 
     delete [] points;
 }
 
-void wxImplDC::DrawPolygon(const wxList *list,
+void wxImplDC::DrawPolygon(const wxPointList *list,
                            wxCoord xoffset, wxCoord yoffset,
                            int fillStyle)
 {
                            wxCoord xoffset, wxCoord yoffset,
                            int fillStyle)
 {
@@ -826,9 +869,9 @@ void wxImplDC::DrawPolygon(const wxList *list,
     wxPoint *points = new wxPoint[n];
 
     int i = 0;
     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;
     }
@@ -883,41 +926,38 @@ wxImplDC::DoDrawPolyPolygon(int n,
 
 #if wxUSE_SPLINES
 
 
 #if wxUSE_SPLINES
 
-// TODO: this API needs fixing (wxPointList, why (!const) "wxList *"?)
-void wxImplDC::DrawSpline(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord x3, wxCoord y3)
+void wxImplDC::DoDrawSpline(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord x3, wxCoord y3)
 {
 {
-    wxList point_list;
+    wxPointList point_list;
 
     wxPoint *point1 = new wxPoint;
     point1->x = x1; point1->y = y1;
 
     wxPoint *point1 = new wxPoint;
     point1->x = x1; point1->y = y1;
-    point_list.Append((wxObject*)point1);
+    point_list.Append( point1 );
 
     wxPoint *point2 = new wxPoint;
     point2->x = x2; point2->y = y2;
 
     wxPoint *point2 = new wxPoint;
     point2->x = x2; point2->y = y2;
-    point_list.Append((wxObject*)point2);
+    point_list.Append( point2 );
 
     wxPoint *point3 = new wxPoint;
     point3->x = x3; point3->y = y3;
 
     wxPoint *point3 = new wxPoint;
     point3->x = x3; point3->y = y3;
-    point_list.Append((wxObject*)point3);
+    point_list.Append( point3 );
 
 
-    DrawSpline(&point_list);
+    DoDrawSpline(&point_list);
 
 
-    for( wxList::compatibility_iterator node = point_list.GetFirst(); node; node = node->GetNext() )
+    for( wxPointList::compatibility_iterator node = point_list.GetFirst(); node; node = node->GetNext() )
     {
     {
-        wxPoint *p = (wxPoint *)node->GetData();
+        wxPoint *p = node->GetData();
         delete p;
     }
 }
 
         delete p;
     }
 }
 
-void wxImplDC::DrawSpline(int n, wxPoint points[])
+void wxImplDC::DoDrawSpline(int n, wxPoint points[])
 {
 {
-    wxList list;
+    wxPointList list;
     for (int i =0; i < n; i++)
     for (int i =0; i < n; i++)
-    {
-        list.Append((wxObject*)&points[i]);
-    }
+        list.Append( &points[i] );
 
 
-    DrawSpline(&list);
+    DoDrawSpline(&list);
 }
 
 // ----------------------------------- spline code ----------------------------------------
 }
 
 // ----------------------------------- spline code ----------------------------------------
@@ -930,9 +970,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;
+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
@@ -1015,35 +1055,32 @@ 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(wxDC *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();
-  }
+    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 wxImplDC::DoDrawSpline( wxList *points )
+void wxImplDC::DoDrawSpline( const wxPointList *points )
 {
 {
-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid window dc") );
 
     wxPoint *p;
     double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
     double           x1, y1, x2, y2;
 
 
     wxPoint *p;
     double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
     double           x1, y1, x2, y2;
 
-    wxList::compatibility_iterator node = points->GetFirst();
+    wxPointList::compatibility_iterator node = points->GetFirst();
     if (!node)
         // empty list
         return;
     if (!node)
         // empty list
         return;
@@ -1054,7 +1091,7 @@ void wxImplDC::DoDrawSpline( wxList *points )
     y1 = p->y;
 
     node = node->GetNext();
     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;
@@ -1071,7 +1108,7 @@ void wxImplDC::DoDrawSpline( wxList *points )
 #endif // !wxUSE_STL
           )
     {
 #endif // !wxUSE_STL
           )
     {
-        p = (wxPoint *)node->GetData();
+        p = node->GetData();
         x1 = x2;
         y1 = y2;
         x2 = p->x;
         x1 = x2;
         y1 = y2;
         x2 = p->x;
@@ -1098,162 +1135,6 @@ void wxImplDC::DoDrawSpline( wxList *points )
 #endif // wxUSE_SPLINES
 
 
 #endif // wxUSE_SPLINES
 
 
-void wxImplDC::DrawLabel(const wxString& text,
-                         const wxBitmap& bitmap,
-                         const wxRect& rect,
-                         int alignment,
-                         int indexAccel,
-                         wxRect *rectBounding)
-{
-    // find the text position
-    wxCoord widthText, heightText, heightLine;
-    GetMultiLineTextExtent(text, &widthText, &heightText, &heightLine);
-
-    wxCoord width, height;
-    if ( bitmap.Ok() )
-    {
-        width = widthText + bitmap.GetWidth();
-        height = bitmap.GetHeight();
-    }
-    else // no bitmap
-    {
-        width = widthText;
-        height = heightText;
-    }
-
-    wxCoord x, y;
-    if ( alignment & wxALIGN_RIGHT )
-    {
-        x = rect.GetRight() - width;
-    }
-    else if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
-    {
-        x = (rect.GetLeft() + rect.GetRight() + 1 - width) / 2;
-    }
-    else // alignment & wxALIGN_LEFT
-    {
-        x = rect.GetLeft();
-    }
-
-    if ( alignment & wxALIGN_BOTTOM )
-    {
-        y = rect.GetBottom() - height;
-    }
-    else if ( alignment & wxALIGN_CENTRE_VERTICAL )
-    {
-        y = (rect.GetTop() + rect.GetBottom() + 1 - height) / 2;
-    }
-    else // alignment & wxALIGN_TOP
-    {
-        y = rect.GetTop();
-    }
-
-    // draw the bitmap first
-    wxCoord x0 = x,
-            y0 = y,
-            width0 = width;
-    if ( bitmap.Ok() )
-    {
-        DoDrawBitmap(bitmap, x, y, true /* use mask */);
-
-        wxCoord offset = bitmap.GetWidth() + 4;
-        x += offset;
-        width -= offset;
-
-        y += (height - heightText) / 2;
-    }
-
-    // we will draw the underscore under the accel char later
-    wxCoord startUnderscore = 0,
-            endUnderscore = 0,
-            yUnderscore = 0;
-
-    // split the string into lines and draw each of them separately
-    wxString curLine;
-    for ( wxString::const_iterator pc = text.begin(); ; ++pc )
-    {
-        if ( *pc == _T('\n') || pc == text.end() )
-        {
-            int xRealStart = x; // init it here to avoid compielr warnings
-
-            if ( !curLine.empty() )
-            {
-                // NB: can't test for !(alignment & wxALIGN_LEFT) because
-                //     wxALIGN_LEFT is 0
-                if ( alignment & (wxALIGN_RIGHT | wxALIGN_CENTRE_HORIZONTAL) )
-                {
-                    wxCoord widthLine;
-                    m_owner->GetTextExtent(curLine, &widthLine, NULL);
-
-                    if ( alignment & wxALIGN_RIGHT )
-                    {
-                        xRealStart += width - widthLine;
-                    }
-                    else // if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
-                    {
-                        xRealStart += (width - widthLine) / 2;
-                    }
-                }
-                //else: left aligned, nothing to do
-
-                DoDrawText(curLine, xRealStart, y);
-            }
-
-            y += heightLine;
-
-            // do we have underscore in this line? we can check yUnderscore
-            // because it is set below to just y + heightLine if we do
-            if ( y == yUnderscore )
-            {
-                // adjust the horz positions to account for the shift
-                startUnderscore += xRealStart;
-                endUnderscore += xRealStart;
-            }
-
-            if ( pc == text.end() )
-                break;
-
-            curLine.clear();
-        }
-        else // not end of line
-        {
-            if ( pc - text.begin() == indexAccel )
-            {
-                // remeber to draw underscore here
-                GetTextExtent(curLine, &startUnderscore, NULL);
-                curLine += *pc;
-                GetTextExtent(curLine, &endUnderscore, NULL);
-
-                yUnderscore = y + heightLine;
-            }
-            else
-            {
-                curLine += *pc;
-            }
-        }
-    }
-
-    // draw the underscore if found
-    if ( startUnderscore != endUnderscore )
-    {
-        // it should be of the same colour as text
-        SetPen(wxPen(GetTextForeground(), 0, wxSOLID));
-
-        yUnderscore--;
-
-        DoDrawLine(startUnderscore, yUnderscore, endUnderscore, yUnderscore);
-    }
-
-    // return bounding rect if requested
-    if ( rectBounding )
-    {
-        *rectBounding = wxRect(x, y - heightText, widthText, heightText);
-    }
-
-    CalcBoundingBox(x0, y0);
-    CalcBoundingBox(x0 + width0, y0 + height);
-}
-
 
 void wxImplDC::DoGradientFillLinear(const wxRect& rect,
                                     const wxColour& initialColour,
 
 void wxImplDC::DoGradientFillLinear(const wxRect& rect,
                                     const wxColour& initialColour,
@@ -1302,7 +1183,7 @@ void wxImplDC::DoGradientFillLinear(const wxRect& rect,
             SetPen(wxPen(colour, 1, wxSOLID));
             SetBrush(wxBrush(colour));
             if(nDirection == wxEAST)
             SetPen(wxPen(colour, 1, wxSOLID));
             SetBrush(wxBrush(colour));
             if(nDirection == wxEAST)
-                DoDrawRectangle(rect.GetRight()-x-xDelta, rect.GetTop(),
+                DoDrawRectangle(rect.GetRight()-x-xDelta+1, rect.GetTop(),
                         xDelta, rect.GetHeight());
             else //nDirection == wxWEST
                 DoDrawRectangle(rect.GetLeft()+x, rect.GetTop(),
                         xDelta, rect.GetHeight());
             else //nDirection == wxWEST
                 DoDrawRectangle(rect.GetLeft()+x, rect.GetTop(),
@@ -1342,7 +1223,7 @@ void wxImplDC::DoGradientFillLinear(const wxRect& rect,
                 DoDrawRectangle(rect.GetLeft(), rect.GetTop()+y,
                         rect.GetWidth(), yDelta);
             else //nDirection == wxSOUTH
                 DoDrawRectangle(rect.GetLeft(), rect.GetTop()+y,
                         rect.GetWidth(), yDelta);
             else //nDirection == wxSOUTH
-                DoDrawRectangle(rect.GetLeft(), rect.GetBottom()-y-yDelta,
+                DoDrawRectangle(rect.GetLeft(), rect.GetBottom()-y-yDelta+1,
                         rect.GetWidth(), yDelta);
         }
     }
                         rect.GetWidth(), yDelta);
         }
     }
@@ -1403,7 +1284,7 @@ void wxImplDC::DoGradientFillConcentric(const wxRect& rect,
 
             //set the pixel
             m_pen.SetColour(wxColour(nR,nG,nB));
 
             //set the pixel
             m_pen.SetColour(wxColour(nR,nG,nB));
-            DoDrawPoint(wxPoint(x + rect.GetLeft(), y + rect.GetTop()));
+            DoDrawPoint(x + rect.GetLeft(), y + rect.GetTop());
         }
     }
     //return old pen color
         }
     }
     //return old pen color
@@ -1416,6 +1297,162 @@ void wxImplDC::DoGradientFillConcentric(const wxRect& rect,
 
 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
 
 
 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
 
+void wxDC::DrawLabel(const wxString& text,
+                         const wxBitmap& bitmap,
+                         const wxRect& rect,
+                         int alignment,
+                         int indexAccel,
+                         wxRect *rectBounding)
+{
+    // find the text position
+    wxCoord widthText, heightText, heightLine;
+    GetMultiLineTextExtent(text, &widthText, &heightText, &heightLine);
+
+    wxCoord width, height;
+    if ( bitmap.Ok() )
+    {
+        width = widthText + bitmap.GetWidth();
+        height = bitmap.GetHeight();
+    }
+    else // no bitmap
+    {
+        width = widthText;
+        height = heightText;
+    }
+
+    wxCoord x, y;
+    if ( alignment & wxALIGN_RIGHT )
+    {
+        x = rect.GetRight() - width;
+    }
+    else if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
+    {
+        x = (rect.GetLeft() + rect.GetRight() + 1 - width) / 2;
+    }
+    else // alignment & wxALIGN_LEFT
+    {
+        x = rect.GetLeft();
+    }
+
+    if ( alignment & wxALIGN_BOTTOM )
+    {
+        y = rect.GetBottom() - height;
+    }
+    else if ( alignment & wxALIGN_CENTRE_VERTICAL )
+    {
+        y = (rect.GetTop() + rect.GetBottom() + 1 - height) / 2;
+    }
+    else // alignment & wxALIGN_TOP
+    {
+        y = rect.GetTop();
+    }
+
+    // draw the bitmap first
+    wxCoord x0 = x,
+            y0 = y,
+            width0 = width;
+    if ( bitmap.Ok() )
+    {
+        DrawBitmap(bitmap, x, y, true /* use mask */);
+
+        wxCoord offset = bitmap.GetWidth() + 4;
+        x += offset;
+        width -= offset;
+
+        y += (height - heightText) / 2;
+    }
+
+    // we will draw the underscore under the accel char later
+    wxCoord startUnderscore = 0,
+            endUnderscore = 0,
+            yUnderscore = 0;
+
+    // split the string into lines and draw each of them separately
+    wxString curLine;
+    for ( wxString::const_iterator pc = text.begin(); ; ++pc )
+    {
+        if ( *pc == _T('\n') || pc == text.end() )
+        {
+            int xRealStart = x; // init it here to avoid compielr warnings
+
+            if ( !curLine.empty() )
+            {
+                // NB: can't test for !(alignment & wxALIGN_LEFT) because
+                //     wxALIGN_LEFT is 0
+                if ( alignment & (wxALIGN_RIGHT | wxALIGN_CENTRE_HORIZONTAL) )
+                {
+                    wxCoord widthLine;
+                    GetTextExtent(curLine, &widthLine, NULL);
+
+                    if ( alignment & wxALIGN_RIGHT )
+                    {
+                        xRealStart += width - widthLine;
+                    }
+                    else // if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
+                    {
+                        xRealStart += (width - widthLine) / 2;
+                    }
+                }
+                //else: left aligned, nothing to do
+
+                DrawText(curLine, xRealStart, y);
+            }
+
+            y += heightLine;
+
+            // do we have underscore in this line? we can check yUnderscore
+            // because it is set below to just y + heightLine if we do
+            if ( y == yUnderscore )
+            {
+                // adjust the horz positions to account for the shift
+                startUnderscore += xRealStart;
+                endUnderscore += xRealStart;
+            }
+
+            if ( pc == text.end() )
+                break;
+
+            curLine.clear();
+        }
+        else // not end of line
+        {
+            if ( pc - text.begin() == indexAccel )
+            {
+                // remeber to draw underscore here
+                GetTextExtent(curLine, &startUnderscore, NULL);
+                curLine += *pc;
+                GetTextExtent(curLine, &endUnderscore, NULL);
+
+                yUnderscore = y + heightLine;
+            }
+            else
+            {
+                curLine += *pc;
+            }
+        }
+    }
+
+    // draw the underscore if found
+    if ( startUnderscore != endUnderscore )
+    {
+        // it should be of the same colour as text
+        SetPen(wxPen(GetTextForeground(), 0, wxSOLID));
+
+        yUnderscore--;
+
+        DrawLine(startUnderscore, yUnderscore, endUnderscore, yUnderscore);
+    }
+
+    // return bounding rect if requested
+    if ( rectBounding )
+    {
+        *rectBounding = wxRect(x, y - heightText, widthText, heightText);
+    }
+
+    CalcBoundingBox(x0, y0);
+    CalcBoundingBox(x0 + width0, y0 + height);
+}
+
 #if WXWIN_COMPATIBILITY_2_8
     // for compatibility with the old code when wxCoord was long everywhere
 void wxDC::GetTextExtent(const wxString& string,
 #if WXWIN_COMPATIBILITY_2_8
     // for compatibility with the old code when wxCoord was long everywhere
 void wxDC::GetTextExtent(const wxString& string,
@@ -1706,6 +1743,7 @@ void wxDCBase::SetDeviceLocalOrigin( wxCoord x, wxCoord y )
 void wxDCBase::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
 {
     // only wxPostScripDC has m_signX = -1, we override SetAxisOrientation there
 void wxDCBase::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
 {
     // 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();
@@ -1777,15 +1815,16 @@ wxDCBase::DoStretchBlit(wxCoord xdest, wxCoord ydest,
 // line/polygons
 // ----------------------------------------------------------------------------
 
 // line/polygons
 // ----------------------------------------------------------------------------
 
-void wxDCBase::DrawLines(const wxList *list, wxCoord xoffset, wxCoord yoffset)
+void wxDCBase::DrawLines(const wxPointList *list, wxCoord xoffset, wxCoord yoffset)
 {
 {
-    int n = list->GetCount();
+    unsigned int n = list->GetCount();
     wxPoint *points = new wxPoint[n];
 
     wxPoint *points = new wxPoint[n];
 
-    int i = 0;
-    for ( wxList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )
+    unsigned int i = 0;
+    wxPointList::compatibility_iterator node;
+    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;
     }
         points[i].x = point->x;
         points[i].y = point->y;
     }
@@ -1795,18 +1834,63 @@ void wxDCBase::DrawLines(const wxList *list, wxCoord xoffset, wxCoord yoffset)
     delete [] points;
 }
 
     delete [] points;
 }
 
+#if WXWIN_COMPATIBILITY_2_8
+void wxDCBase::DrawLines(const wxList *list, wxCoord xoffset, wxCoord yoffset )
+{
+    unsigned int n = list->GetCount();
+    wxPoint *points = new wxPoint[n];
 
 
-void wxDCBase::DrawPolygon(const wxList *list,
+    unsigned int i = 0;
+    wxNode *node;
+    for ( node = list->GetFirst(); node; node = node->GetNext(), i++ )
+    {
+        wxPoint *point = (wxPoint*) node->GetData();
+        points[i].x = point->x;
+        points[i].y = point->y;
+    }
+
+    DoDrawLines(n, points, xoffset, yoffset);
+
+    delete [] points;
+}
+#endif  // WXWIN_COMPATIBILITY_2_8
+
+
+void wxDCBase::DrawPolygon(const wxPointList *list,
                            wxCoord xoffset, wxCoord yoffset,
                            int fillStyle)
 {
                            wxCoord xoffset, wxCoord yoffset,
                            int fillStyle)
 {
-    int n = list->GetCount();
+    unsigned int n = list->GetCount();
     wxPoint *points = new wxPoint[n];
 
     wxPoint *points = new wxPoint[n];
 
-    int i = 0;
-    for ( wxList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )
+    unsigned int i = 0;
+    wxPointList::compatibility_iterator node;
+    for ( node = list->GetFirst(); node; node = node->GetNext(), i++ )
+    {
+        wxPoint *point = node->GetData();
+        points[i].x = point->x;
+        points[i].y = point->y;
+    }
+
+    DoDrawPolygon(n, points, xoffset, yoffset, fillStyle);
+
+    delete [] points;
+}
+
+
+#if WXWIN_COMPATIBILITY_2_8
+void wxDCBase::DrawPolygon(const wxList *list,
+                     wxCoord xoffset, wxCoord yoffset,
+                     int fillStyle )
+{
+    unsigned int n = list->GetCount();
+    wxPoint *points = new wxPoint[n];
+
+    unsigned int i = 0;
+    wxNode *node;
+    for ( node = list->GetFirst(); node; node = node->GetNext(), i++ )
     {
     {
-        wxPoint *point = (wxPoint *)node->GetData();
+        wxPoint *point = (wxPoint*) node->GetData();
         points[i].x = point->x;
         points[i].y = point->y;
     }
         points[i].x = point->x;
         points[i].y = point->y;
     }
@@ -1815,6 +1899,7 @@ void wxDCBase::DrawPolygon(const wxList *list,
 
     delete [] points;
 }
 
     delete [] points;
 }
+#endif  // WXWIN_COMPATIBILITY_2_8
 
 void
 wxDCBase::DoDrawPolyPolygon(int n,
 
 void
 wxDCBase::DoDrawPolyPolygon(int n,
@@ -1865,39 +1950,36 @@ wxDCBase::DoDrawPolyPolygon(int n,
 
 #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 wxDCBase::DrawSpline(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord x3, wxCoord y3)
 {
-    wxList point_list;
+    wxPointList point_list;
 
     wxPoint *point1 = new wxPoint;
     point1->x = x1; point1->y = y1;
 
     wxPoint *point1 = new wxPoint;
     point1->x = x1; point1->y = y1;
-    point_list.Append((wxObject*)point1);
+    point_list.Append( point1 );
 
     wxPoint *point2 = new wxPoint;
     point2->x = x2; point2->y = y2;
 
     wxPoint *point2 = new wxPoint;
     point2->x = x2; point2->y = y2;
-    point_list.Append((wxObject*)point2);
+    point_list.Append( point2 );
 
     wxPoint *point3 = new wxPoint;
     point3->x = x3; point3->y = y3;
 
     wxPoint *point3 = new wxPoint;
     point3->x = x3; point3->y = y3;
-    point_list.Append((wxObject*)point3);
+    point_list.Append( point3 );
 
     DrawSpline(&point_list);
 
 
     DrawSpline(&point_list);
 
-    for( wxList::compatibility_iterator node = point_list.GetFirst(); node; node = node->GetNext() )
+    for( wxPointList::compatibility_iterator node = point_list.GetFirst(); node; node = node->GetNext() )
     {
     {
-        wxPoint *p = (wxPoint *)node->GetData();
+        wxPoint *p = node->GetData();
         delete p;
     }
 }
 
 void wxDCBase::DrawSpline(int n, wxPoint points[])
 {
         delete p;
     }
 }
 
 void wxDCBase::DrawSpline(int n, wxPoint points[])
 {
-    wxList list;
+    wxPointList list;
     for (int i =0; i < n; i++)
     for (int i =0; i < n; i++)
-    {
-        list.Append((wxObject*)&points[i]);
-    }
+        list.Append( &points[i] );
 
     DrawSpline(&list);
 }
 
     DrawSpline(&list);
 }
@@ -1914,7 +1996,7 @@ void wx_spline_push(double x1, double y1, double x2, double y2, double x3, doubl
 static bool wx_spline_add_point(double x, double y);
 static void wx_spline_draw_point_array(wxDCBase *dc);
 
 static bool wx_spline_add_point(double x, double y);
 static void wx_spline_draw_point_array(wxDCBase *dc);
 
-wxList wx_spline_point_list;
+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
@@ -1997,27 +2079,39 @@ 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(wxDCBase *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();
+    }
+}
+
+#if WXWIN_COMPATIBILITY_2_8
+void wxDCBase::DrawSpline(const wxList *points)
+{
+    wxPointList list;
+    wxNode *node = points->GetFirst();
+    while (node)
+    {
+        list.Append( (wxPoint*) node->GetData() );
+        node = node->GetNext();
+    }
+    DoDrawSpline( &list );
 }
 }
+#endif  // WXWIN_COMPATIBILITY_2_8
 
 
-void wxDCBase::DoDrawSpline( wxList *points )
+void wxDCBase::DoDrawSpline( const wxPointList *points )
 {
     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 
 {
     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 
@@ -2025,18 +2119,18 @@ void wxDCBase::DoDrawSpline( wxList *points )
     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;
@@ -2053,7 +2147,7 @@ void wxDCBase::DoDrawSpline( wxList *points )
 #endif // !wxUSE_STL
           )
     {
 #endif // !wxUSE_STL
           )
     {
-        p = (wxPoint *)node->GetData();
+        p = node->GetData();
         x1 = x2;
         y1 = y2;
         x2 = p->x;
         x1 = x2;
         y1 = y2;
         x2 = p->x;
@@ -2302,7 +2396,7 @@ void wxDCBase::DrawLabel(const wxString& text,
     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 == _T('\n') )
         {
             int xRealStart = x; // init it here to avoid compielr warnings
 
         {
             int xRealStart = x; // init it here to avoid compielr warnings
 
@@ -2432,7 +2526,7 @@ void wxDCBase::DoGradientFillLinear(const wxRect& rect,
             SetPen(wxPen(colour, 1, wxSOLID));
             SetBrush(wxBrush(colour));
             if(nDirection == wxEAST)
             SetPen(wxPen(colour, 1, wxSOLID));
             SetBrush(wxBrush(colour));
             if(nDirection == wxEAST)
-                DrawRectangle(rect.GetRight()-x-xDelta, rect.GetTop(),
+                DrawRectangle(rect.GetRight()-x-xDelta+1, rect.GetTop(),
                         xDelta, rect.GetHeight());
             else //nDirection == wxWEST
                 DrawRectangle(rect.GetLeft()+x, rect.GetTop(),
                         xDelta, rect.GetHeight());
             else //nDirection == wxWEST
                 DrawRectangle(rect.GetLeft()+x, rect.GetTop(),
@@ -2472,7 +2566,7 @@ void wxDCBase::DoGradientFillLinear(const wxRect& rect,
                 DrawRectangle(rect.GetLeft(), rect.GetTop()+y,
                         rect.GetWidth(), yDelta);
             else //nDirection == wxSOUTH
                 DrawRectangle(rect.GetLeft(), rect.GetTop()+y,
                         rect.GetWidth(), yDelta);
             else //nDirection == wxSOUTH
-                DrawRectangle(rect.GetLeft(), rect.GetBottom()-y-yDelta,
+                DrawRectangle(rect.GetLeft(), rect.GetBottom()-y-yDelta+1,
                         rect.GetWidth(), yDelta);
         }
     }
                         rect.GetWidth(), yDelta);
         }
     }
@@ -2586,22 +2680,22 @@ void wxDCBase::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;
@@ -2627,16 +2721,17 @@ void wxDCBase::DoDrawEllipticArcRot( wxCoord x, wxCoord y,
 
 } // DrawEllipticArcRot
 
 
 } // DrawEllipticArcRot
 
-void wxDCBase::Rotate( wxList* points, double angle, wxPoint center )
+void wxDCBase::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;
@@ -2654,7 +2749,7 @@ void wxDCBase::Rotate( wxList* points, double angle, wxPoint center )
     }
 }
 
     }
 }
 
-void wxDCBase::CalculateEllipticPoints( wxList* points,
+void wxDCBase::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 )
@@ -2727,7 +2822,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 )
     {
@@ -2746,40 +2841,41 @@ void wxDCBase::CalculateEllipticPoints( wxList* points,
         {
             int x1 = x - 1;
             // remove points on the same line
         {
             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
                     )
                   )
                 {
                     )
                   )
                 {
@@ -2797,10 +2893,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;
                     }
@@ -2811,40 +2907,41 @@ 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
             points->Append( p );
         }
     } // not iUseAngles
wxWidgets (Impactor)