]> git.saurik.com Git - wxWidgets.git/blobdiff - src/msw/dc.cpp
unneeded line removed
[wxWidgets.git] / src / msw / dc.cpp
index f4201d6e49b2bf8c7308e27c893cfb251335a0f6..45e37fc9a2c63bd552ba64ead296bd16c43ca3cf 100644 (file)
@@ -6,7 +6,7 @@
 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart and Markus Holzem
 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart and Markus Holzem
-// Licence:    wxWindows licence
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__
 /////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__
@@ -26,6 +26,8 @@
 #include "wx/utils.h"
 #include "wx/dialog.h"
 #include "wx/app.h"
 #include "wx/utils.h"
 #include "wx/dialog.h"
 #include "wx/app.h"
+#include "wx/bitmap.h"
+#include "wx/dcmemory.h"
 #endif
 
 #include "wx/dcprint.h"
 #endif
 
 #include "wx/dcprint.h"
@@ -33,9 +35,8 @@
 
 #include <string.h>
 #include <math.h>
 
 #include <string.h>
 #include <math.h>
-#include <fstream.h>
 
 
-#if USE_COMMON_DIALOGS
+#if wxUSE_COMMON_DIALOGS
 #include <commdlg.h>
 #endif
 
 #include <commdlg.h>
 #endif
 
@@ -91,7 +92,7 @@ wxDC::wxDC(void)
   m_signY = 1;
   m_systemScaleX = 1.0;
   m_systemScaleY = 1.0;
   m_signY = 1;
   m_systemScaleX = 1.0;
   m_systemScaleY = 1.0;
-  m_mappingMode = MM_TEXT;
+  m_mappingMode = wxMM_TEXT;
   m_bOwnsDC = FALSE;
   m_hDC = 0;
   m_clipping = FALSE;
   m_bOwnsDC = FALSE;
   m_hDC = 0;
   m_clipping = FALSE;
@@ -130,16 +131,10 @@ wxDC::~wxDC(void)
 // DC.
 void wxDC::SelectOldObjects(WXHDC dc)
 {
 // DC.
 void wxDC::SelectOldObjects(WXHDC dc)
 {
-#if WXDEBUG > 1
-  wxDebugMsg("wxDC::SelectOldObjects %X\n", this);
-#endif
   if (dc)
   {
     if (m_oldBitmap)
     {
   if (dc)
   {
     if (m_oldBitmap)
     {
-#if WXDEBUG > 1
-      wxDebugMsg("wxDC::SelectOldObjects: Selecting old HBITMAP %X\n", m_oldBitmap);
-#endif
       ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);
       if (m_selectedBitmap.Ok())
       {
       ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);
       if (m_selectedBitmap.Ok())
       {
@@ -149,38 +144,23 @@ void wxDC::SelectOldObjects(WXHDC dc)
     m_oldBitmap = 0 ;
     if (m_oldPen)
     {
     m_oldBitmap = 0 ;
     if (m_oldPen)
     {
-#if WXDEBUG > 1
-      wxDebugMsg("wxDC::SelectOldObjects: Selecting old HPEN %X\n", m_oldPen);
-#endif
       ::SelectObject((HDC) dc, (HPEN) m_oldPen);
     }
     m_oldPen = 0 ;
     if (m_oldBrush)
     {
       ::SelectObject((HDC) dc, (HPEN) m_oldPen);
     }
     m_oldPen = 0 ;
     if (m_oldBrush)
     {
-#if WXDEBUG > 1
-      wxDebugMsg("wxDC::SelectOldObjects: Selecting old HBRUSH %X\n", m_oldBrush);
-#endif
       ::SelectObject((HDC) dc, (HBRUSH) m_oldBrush);
     }
     m_oldBrush = 0 ;
     if (m_oldFont)
     {
       ::SelectObject((HDC) dc, (HBRUSH) m_oldBrush);
     }
     m_oldBrush = 0 ;
     if (m_oldFont)
     {
-#if WXDEBUG > 1
-      wxDebugMsg("wxDC::SelectOldObjects: Selecting old HFONT %X\n", m_oldFont);
-#endif
       ::SelectObject((HDC) dc, (HFONT) m_oldFont);
     }
     m_oldFont = 0 ;
     if (m_oldPalette)
     {
       ::SelectObject((HDC) dc, (HFONT) m_oldFont);
     }
     m_oldFont = 0 ;
     if (m_oldPalette)
     {
-#if WXDEBUG > 1
-      wxDebugMsg("wxDC::SelectOldObjects: Selecting old HPALETTE %X\n", m_oldPalette);
-#endif
       ::SelectPalette((HDC) dc, (HPALETTE) m_oldPalette, TRUE);
     }
       ::SelectPalette((HDC) dc, (HPALETTE) m_oldPalette, TRUE);
     }
-#if WXDEBUG > 1
-    wxDebugMsg("wxDC::SelectOldObjects: Done.\n");
-#endif
     m_oldPalette = 0 ;
   }
 
     m_oldPalette = 0 ;
   }
 
@@ -203,6 +183,26 @@ void wxDC::SetClippingRegion(long cx, long cy, long cw, long ch)
   DoClipping((WXHDC) m_hDC);
 }
 
   DoClipping((WXHDC) m_hDC);
 }
 
+void wxDC::SetClippingRegion(const wxRegion& region)
+{
+  if (!region.GetHRGN())
+    return;
+
+  wxRect box = region.GetBox();
+
+  m_clipping = TRUE;
+  m_clipX1 = box.x;
+  m_clipY1 = box.y;
+  m_clipX2 = box.x + box.width;
+  m_clipY2 = box.y + box.height;
+
+#ifdef __WIN16__
+  SelectClipRgn((HDC) m_hDC, (HRGN) region.GetHRGN());
+#else
+  ExtSelectClipRgn((HDC) m_hDC, (HRGN) region.GetHRGN(), RGN_AND);
+#endif
+}
+
 void wxDC::DoClipping(WXHDC dc)
 {
   if (m_clipping && dc)
 void wxDC::DoClipping(WXHDC dc)
 {
   if (m_clipping && dc)
@@ -216,17 +216,14 @@ void wxDC::DestroyClippingRegion(void)
 {
   if (m_clipping && m_hDC)
   {
 {
   if (m_clipping && m_hDC)
   {
+    // TODO: this should restore the previous clipping region,
+    // so that OnPaint processing works correctly, and the update clipping region
+    // doesn't get destroyed after the first DestroyClippingRegion.
     HRGN rgn = CreateRectRgn(0, 0, 32000, 32000);
     HRGN rgn = CreateRectRgn(0, 0, 32000, 32000);
-#if WXDEBUG > 1
-    wxDebugMsg("wxDC::DestroyClippingRegion: Selecting HRGN %X\n", rgn);
-#endif
     SelectClipRgn((HDC) m_hDC, rgn);
     SelectClipRgn((HDC) m_hDC, rgn);
-#if WXDEBUG > 1
-    wxDebugMsg("wxDC::DestroyClippingRegion: Deleting HRGN %X\n", rgn);
-#endif
     DeleteObject(rgn);
     DeleteObject(rgn);
-   }
-   m_clipping = FALSE;
+  }
+  m_clipping = FALSE;
 }
 
 bool wxDC::CanDrawBitmap(void) const
 }
 
 bool wxDC::CanDrawBitmap(void) const
@@ -258,7 +255,7 @@ void wxDC::SetPalette(const wxPalette& palette)
     m_oldPalette = 0;
   }
 
     m_oldPalette = 0;
   }
 
-  m_palette = m_palette;
+  m_palette = palette;
 
   if (!m_palette.Ok())
   {
 
   if (!m_palette.Ok())
   {
@@ -267,13 +264,10 @@ void wxDC::SetPalette(const wxPalette& palette)
     if (m_oldPalette)
     {
       ::SelectPalette((HDC) m_hDC, (HPALETTE) m_oldPalette, TRUE);
     if (m_oldPalette)
     {
       ::SelectPalette((HDC) m_hDC, (HPALETTE) m_oldPalette, TRUE);
-#if WXDEBUG > 1
-      wxDebugMsg("wxDC::SetPalette: set old palette %X\n", m_oldPalette);
-#endif
       m_oldPalette = 0;
     }
 
       m_oldPalette = 0;
     }
 
-       return;
+    return;
   }
     
   if (m_palette.Ok() && m_palette.GetHPALETTE())
   }
     
   if (m_palette.Ok() && m_palette.GetHPALETTE())
@@ -282,13 +276,6 @@ void wxDC::SetPalette(const wxPalette& palette)
     if (!m_oldPalette)
       m_oldPalette = (WXHPALETTE) oldPal;
 
     if (!m_oldPalette)
       m_oldPalette = (WXHPALETTE) oldPal;
 
-#if WXDEBUG > 1
-    wxDebugMsg("wxDC::SetPalette %X: selected palette %X\n", this, m_palette.GetHPALETTE());
-    if (oldPal)
-      wxDebugMsg("wxDC::SetPalette: oldPal was palette %X\n", oldPal);
-    if (m_oldPalette)
-      wxDebugMsg("wxDC::SetPalette: m_oldPalette is palette %X\n", m_oldPalette);
-#endif
     ::RealizePalette((HDC) m_hDC);
   }
 }
     ::RealizePalette((HDC) m_hDC);
   }
 }
@@ -393,7 +380,7 @@ void wxDC::DrawArc(long x1,long y1,long x2,long y2, long xc, long yc)
   double radius = (double)sqrt(dx*dx+dy*dy) ;;
   if (x1==x2 && x2==y2)
   {
   double radius = (double)sqrt(dx*dx+dy*dy) ;;
   if (x1==x2 && x2==y2)
   {
-    DrawEllipse(xc,yc,(double)(radius*2.0),(double)(radius*2)) ;
+    DrawEllipse(xc,yc,(long)(radius*2.0),(long)(radius*2.0)) ;
     return ;
   }
 
     return ;
   }
 
@@ -512,28 +499,28 @@ void wxDC::DrawRectangle(long x, long y, long width, long height)
   do_pen = m_pen.Ok() && m_pen.GetStyle() != wxTRANSPARENT;
 
   if (do_brush) {
   do_pen = m_pen.Ok() && m_pen.GetStyle() != wxTRANSPARENT;
 
   if (do_brush) {
-        HPEN orig_pen = NULL;
+     HPEN orig_pen = NULL;
 
 
-        if (do_pen || !m_pen.Ok())
-               orig_pen = (HPEN) ::SelectObject((HDC) m_hDC, (HPEN) ::GetStockObject(NULL_PEN));
+     if (do_pen || !m_pen.Ok())
+        orig_pen = (HPEN) ::SelectObject((HDC) m_hDC, (HPEN) ::GetStockObject(NULL_PEN));
 
 
-        (void)Rectangle((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y),
-                 XLOG2DEV(x2) + 1, YLOG2DEV(y2) + 1);
+     (void)Rectangle((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y),
+          XLOG2DEV(x2) + 1, YLOG2DEV(y2) + 1);
 
 
-        if (do_pen || !m_pen.Ok())
-               ::SelectObject((HDC) m_hDC , orig_pen);
+     if (do_pen || !m_pen.Ok())
+        ::SelectObject((HDC) m_hDC , orig_pen);
   }
   if (do_pen) {
   }
   if (do_pen) {
-        HBRUSH orig_brush = NULL;
+     HBRUSH orig_brush = NULL;
 
 
-        if (do_brush || !m_brush.Ok())
-               orig_brush = (HBRUSH) ::SelectObject((HDC) m_hDC, (HBRUSH) ::GetStockObject(NULL_BRUSH));
+     if (do_brush || !m_brush.Ok())
+        orig_brush = (HBRUSH) ::SelectObject((HDC) m_hDC, (HBRUSH) ::GetStockObject(NULL_BRUSH));
 
 
-        (void)Rectangle((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y),
-                 XLOG2DEV(x2), YLOG2DEV(y2));
+     (void)Rectangle((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y),
+          XLOG2DEV(x2), YLOG2DEV(y2));
 
 
-        if (do_brush || !m_brush.Ok())
-               ::SelectObject((HDC) m_hDC, orig_brush);
+     if (do_brush || !m_brush.Ok())
+        ::SelectObject((HDC) m_hDC, orig_brush);
   }
 #else
   (void)Rectangle((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
   }
 #else
   (void)Rectangle((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
@@ -601,16 +588,16 @@ void wxDC::DrawEllipticArc(long x,long y,long w,long h,double sa,double ea)
   if (m_signY > 0)
   {
     (void)Pie((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2)+1, YLOG2DEV(y2)+1,
   if (m_signY > 0)
   {
     (void)Pie((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2)+1, YLOG2DEV(y2)+1,
-           rx1, ry1, rx2, ry2);
+        rx1, ry1, rx2, ry2);
   }
   else
   {
     (void)Pie((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y)-1, XLOG2DEV(x2)+1, YLOG2DEV(y2),
   }
   else
   {
     (void)Pie((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y)-1, XLOG2DEV(x2)+1, YLOG2DEV(y2),
-           rx1, ry1-1, rx2, ry2-1);
+        rx1, ry1-1, rx2, ry2-1);
   }
   ::SelectObject((HDC) m_hDC, orig_pen);
   (void)Arc((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2),
   }
   ::SelectObject((HDC) m_hDC, orig_pen);
   (void)Arc((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2),
-         rx1, ry1, rx2, ry2);
+      rx1, ry1, rx2, ry2);
 
   CalcBoundingBox(x, y);
   CalcBoundingBox(x2, y2);
 
   CalcBoundingBox(x, y);
   CalcBoundingBox(x2, y2);
@@ -618,11 +605,56 @@ void wxDC::DrawEllipticArc(long x,long y,long w,long h,double sa,double ea)
 
 void wxDC::DrawIcon(const wxIcon& icon, long x, long y)
 {
 
 void wxDC::DrawIcon(const wxIcon& icon, long x, long y)
 {
+#if defined(__WIN32__) && !defined(__SC__) && !defined(__TWIN32__)
+  ::DrawIconEx((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), (HICON) icon.GetHICON(),
+      icon.GetWidth(), icon.GetHeight(), 0, 0, DI_NORMAL);
+#else
   ::DrawIcon((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), (HICON) icon.GetHICON());
   ::DrawIcon((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), (HICON) icon.GetHICON());
+#endif
+
   CalcBoundingBox(x, y);
   CalcBoundingBox(x+icon.GetWidth(), y+icon.GetHeight());
 }
 
   CalcBoundingBox(x, y);
   CalcBoundingBox(x+icon.GetWidth(), y+icon.GetHeight());
 }
 
+void wxDC::DrawBitmap( const wxBitmap &bmp, long x, long y, bool useMask )
+{
+    if (!bmp.Ok())
+        return;
+
+    // If we're not drawing transparently, and not drawing to a printer,
+    // optimize this function to use Windows functions.
+    if (!useMask && !IsKindOf(CLASSINFO(wxPrinterDC)))
+    {
+        HDC cdc = (HDC)m_hDC;
+        HDC memdc = ::CreateCompatibleDC( cdc );
+        HBITMAP hbitmap = (HBITMAP) bmp.GetHBITMAP( );
+        ::SelectObject( memdc, hbitmap );
+        ::BitBlt( cdc, x, y, bmp.GetWidth(), bmp.GetHeight(), memdc, 0, 0, SRCCOPY);
+        ::SelectObject( memdc, 0 );
+        ::DeleteDC( memdc );
+    }
+    else
+    {
+        // Rather than reproduce wxDC::Blit, let's do it at the wxWin API level
+        wxMemoryDC memDC;
+        memDC.SelectObject(bmp);
+
+        /* Not sure if we need this. The mask should leave the
+         * masked areas as per the original background of this DC.
+         */
+/*
+        // There might be transparent areas, so make these
+        // the same colour as this DC
+        memDC.SetBackground(* GetBackground());
+        memDC.Clear();
+*/
+
+        Blit(x, y, bmp.GetWidth(), bmp.GetHeight(), & memDC, 0, 0, wxCOPY, useMask);
+
+        memDC.SelectObject(wxNullBitmap);
+    }
+}
+
 void wxDC::SetFont(const wxFont& the_font)
 {
   // Set the old object temporarily, in case the assignment deletes an object
 void wxDC::SetFont(const wxFont& the_font)
 {
   // Set the old object temporarily, in case the assignment deletes an object
@@ -644,11 +676,8 @@ void wxDC::SetFont(const wxFont& the_font)
 
   if (m_font.Ok() && m_font.GetResourceHandle())
   {
 
   if (m_font.Ok() && m_font.GetResourceHandle())
   {
-#if WXDEBUG > 1
-    wxDebugMsg("wxDC::SetFont: Selecting HFONT %X\n", m_font.GetResourceHandle());
-#endif
     HFONT f = (HFONT) ::SelectObject((HDC) m_hDC, (HFONT) m_font.GetResourceHandle());
     HFONT f = (HFONT) ::SelectObject((HDC) m_hDC, (HFONT) m_font.GetResourceHandle());
-    if (f == NULL)
+    if (f == (HFONT) NULL)
     {
         wxDebugMsg("::SelectObject failed in wxDC::SetFont.");
     }
     {
         wxDebugMsg("::SelectObject failed in wxDC::SetFont.");
     }
@@ -724,9 +753,6 @@ void wxDC::DrawText(const wxString& text, long x, long y, bool use16bit)
 #if 0
   if (m_font.Ok() && m_font.GetResourceHandle())
   {
 #if 0
   if (m_font.Ok() && m_font.GetResourceHandle())
   {
-#if WXDEBUG > 1
-    wxDebugMsg("wxDC::DrawText: Selecting HFONT %X\n", m_font.GetResourceHandle());
-#endif
     HFONT f = (HFONT) ::SelectObject((HDC) m_hDC, (HFONT) m_font.GetResourceHandle());
     if (!m_oldFont)
       m_oldFont = (WXHFONT) f;
     HFONT f = (HFONT) ::SelectObject((HDC) m_hDC, (HFONT) m_font.GetResourceHandle());
     if (!m_oldFont)
       m_oldFont = (WXHFONT) f;
@@ -736,7 +762,7 @@ void wxDC::DrawText(const wxString& text, long x, long y, bool use16bit)
   if (m_textForegroundColour.Ok())
     SetTextColor((HDC) m_hDC, m_textForegroundColour.GetPixel() ) ;
 
   if (m_textForegroundColour.Ok())
     SetTextColor((HDC) m_hDC, m_textForegroundColour.GetPixel() ) ;
 
-  DWORD old_background;
+  DWORD old_background = 0;
   if (m_textBackgroundColour.Ok())
   {
     old_background = SetBkColor((HDC) m_hDC, m_textBackgroundColour.GetPixel() ) ;
   if (m_textBackgroundColour.Ok())
   {
     old_background = SetBkColor((HDC) m_hDC, m_textBackgroundColour.GetPixel() ) ;
@@ -868,16 +894,23 @@ bool wxDC::StartDoc(const wxString& message)
 #else
 #ifdef UNICODE
      ::StartDocW((HDC) m_hDC, &docinfo);
 #else
 #ifdef UNICODE
      ::StartDocW((HDC) m_hDC, &docinfo);
+#else
+#ifdef __TWIN32__
+     ::StartDoc((HDC) m_hDC, &docinfo);
 #else
      ::StartDocA((HDC) m_hDC, &docinfo);
 #endif
 #endif
 #else
      ::StartDocA((HDC) m_hDC, &docinfo);
 #endif
 #endif
+#endif
 
 
+#ifndef __WIN16__
   if (ret <= 0)
   {
     DWORD lastError = GetLastError();
     wxDebugMsg("wxDC::StartDoc failed with error: %d\n", lastError);
   }
   if (ret <= 0)
   {
     DWORD lastError = GetLastError();
     wxDebugMsg("wxDC::StartDoc failed with error: %d\n", lastError);
   }
+#endif
+
   return (ret > 0);
 }
 
   return (ret > 0);
 }
 
@@ -965,32 +998,32 @@ void wxDC::SetMapMode(int mode)
 
   switch (mode)
   {
 
   switch (mode)
   {
-    case MM_TWIPS:
+    case wxMM_TWIPS:
     {
       m_logicalScaleX = (twips2mm * mm2pixelsX);
       m_logicalScaleY = (twips2mm * mm2pixelsY);
       break;
     }
     {
       m_logicalScaleX = (twips2mm * mm2pixelsX);
       m_logicalScaleY = (twips2mm * mm2pixelsY);
       break;
     }
-    case MM_POINTS:
+    case wxMM_POINTS:
     {
       m_logicalScaleX = (pt2mm * mm2pixelsX);
       m_logicalScaleY = (pt2mm * mm2pixelsY);
       break;
     }
     {
       m_logicalScaleX = (pt2mm * mm2pixelsX);
       m_logicalScaleY = (pt2mm * mm2pixelsY);
       break;
     }
-    case MM_METRIC:
+    case wxMM_METRIC:
     {
       m_logicalScaleX = mm2pixelsX;
       m_logicalScaleY = mm2pixelsY;
       break;
     }
     {
       m_logicalScaleX = mm2pixelsX;
       m_logicalScaleY = mm2pixelsY;
       break;
     }
-    case MM_LOMETRIC:
+    case wxMM_LOMETRIC:
     {
       m_logicalScaleX = (mm2pixelsX/10.0);
       m_logicalScaleY = (mm2pixelsY/10.0);
       break;
     }
     default:
     {
       m_logicalScaleX = (mm2pixelsX/10.0);
       m_logicalScaleY = (mm2pixelsY/10.0);
       break;
     }
     default:
-    case MM_TEXT:
+    case wxMM_TEXT:
     {
       m_logicalScaleX = 1.0;
       m_logicalScaleY = 1.0;
     {
       m_logicalScaleX = 1.0;
       m_logicalScaleY = 1.0;
@@ -1051,42 +1084,42 @@ void wxDC::SetDeviceOrigin(long x, long y)
 
 long wxDC::DeviceToLogicalX(long x) const
 {
 
 long wxDC::DeviceToLogicalX(long x) const
 {
-       return (long) (((x) - m_deviceOriginX)/(m_logicalScaleX*m_userScaleX*m_signX*m_systemScaleX) - m_logicalOriginX) ;
+    return (long) (((x) - m_deviceOriginX)/(m_logicalScaleX*m_userScaleX*m_signX*m_systemScaleX) - m_logicalOriginX) ;
 }
 
 long wxDC::DeviceToLogicalXRel(long x) const
 {
 }
 
 long wxDC::DeviceToLogicalXRel(long x) const
 {
-       return (long) ((x)/(m_logicalScaleX*m_userScaleX*m_signX*m_systemScaleX)) ;
+    return (long) ((x)/(m_logicalScaleX*m_userScaleX*m_signX*m_systemScaleX)) ;
 }
 
 long wxDC::DeviceToLogicalY(long y) const
 {
 }
 
 long wxDC::DeviceToLogicalY(long y) const
 {
-       return (long) (((y) - m_deviceOriginY)/(m_logicalScaleY*m_userScaleY*m_signY*m_systemScaleY) - m_logicalOriginY) ;
+    return (long) (((y) - m_deviceOriginY)/(m_logicalScaleY*m_userScaleY*m_signY*m_systemScaleY) - m_logicalOriginY) ;
 }
 
 long wxDC::DeviceToLogicalYRel(long y) const
 {
 }
 
 long wxDC::DeviceToLogicalYRel(long y) const
 {
-       return (long) ((y)/(m_logicalScaleY*m_userScaleY*m_signY*m_systemScaleY)) ;
+    return (long) ((y)/(m_logicalScaleY*m_userScaleY*m_signY*m_systemScaleY)) ;
 }
 
 long wxDC::LogicalToDeviceX(long x) const
 {
 }
 
 long wxDC::LogicalToDeviceX(long x) const
 {
-       return (long) (floor((x) - m_logicalOriginX)*m_logicalScaleX*m_userScaleX*m_signX*m_systemScaleX + m_deviceOriginX) ;
+    return (long) (floor((x) - m_logicalOriginX)*m_logicalScaleX*m_userScaleX*m_signX*m_systemScaleX + m_deviceOriginX) ;
 }
 
 long wxDC::LogicalToDeviceXRel(long x) const
 {
 }
 
 long wxDC::LogicalToDeviceXRel(long x) const
 {
-       return (long) (floor(x)*m_logicalScaleX*m_userScaleX*m_signX*m_systemScaleX) ;
+    return (long) (floor(x)*m_logicalScaleX*m_userScaleX*m_signX*m_systemScaleX) ;
 }
 
 long wxDC::LogicalToDeviceY(long y) const
 {
 }
 
 long wxDC::LogicalToDeviceY(long y) const
 {
-       return (long) (floor((y) - m_logicalOriginY)*m_logicalScaleY*m_userScaleY*m_signY*m_systemScaleY + m_deviceOriginY);
+    return (long) (floor((y) - m_logicalOriginY)*m_logicalScaleY*m_userScaleY*m_signY*m_systemScaleY + m_deviceOriginY);
 }
 
 long wxDC::LogicalToDeviceYRel(long y) const
 {
 }
 
 long wxDC::LogicalToDeviceYRel(long y) const
 {
-       return (long) (floor(y)*m_logicalScaleY*m_userScaleY*m_signY*m_systemScaleY) ;
+    return (long) (floor(y)*m_logicalScaleY*m_userScaleY*m_signY*m_systemScaleY) ;
 }
 
 // This group of functions may not do any conversion
 }
 
 // This group of functions may not do any conversion
@@ -1095,50 +1128,50 @@ long wxDC::LogicalToDeviceYRel(long y) const
 
 long wxDC::ImplDeviceToLogicalX(long x) const
 {
 
 long wxDC::ImplDeviceToLogicalX(long x) const
 {
-//     return (m_scaleGDI ?  x :  DeviceToLogicalX(x));
-       return x;
+//  return (m_scaleGDI ?  x :  DeviceToLogicalX(x));
+    return x;
 }
 
 long wxDC::ImplDeviceToLogicalY(long y) const
 {
 }
 
 long wxDC::ImplDeviceToLogicalY(long y) const
 {
-//     return (m_scaleGDI ?  y :  DeviceToLogicalY(y));
-       return y;
+//  return (m_scaleGDI ?  y :  DeviceToLogicalY(y));
+    return y;
 }
 
 long wxDC::ImplDeviceToLogicalXRel(long x) const
 {
 }
 
 long wxDC::ImplDeviceToLogicalXRel(long x) const
 {
-//     return (m_scaleGDI ?  x :  DeviceToLogicalXRel(x));
-       return x;
+//  return (m_scaleGDI ?  x :  DeviceToLogicalXRel(x));
+    return x;
 }
 
 long wxDC::ImplDeviceToLogicalYRel(long y) const
 {
 }
 
 long wxDC::ImplDeviceToLogicalYRel(long y) const
 {
-//     return (m_scaleGDI ?  y :  DeviceToLogicalYRel(y));
-       return y;
+//  return (m_scaleGDI ?  y :  DeviceToLogicalYRel(y));
+    return y;
 }
 
 long wxDC::ImplLogicalToDeviceX(long x) const
 {
 }
 
 long wxDC::ImplLogicalToDeviceX(long x) const
 {
-//     return (m_scaleGDI ?  (floor(double(x))) :  LogicalToDeviceX(x));
-       return x;
+//  return (m_scaleGDI ?  (floor(double(x))) :  LogicalToDeviceX(x));
+    return x;
 }
 
 long wxDC::ImplLogicalToDeviceY(long y) const
 {
 }
 
 long wxDC::ImplLogicalToDeviceY(long y) const
 {
-//     return (m_scaleGDI ?  (floor(double(y))) :  LogicalToDeviceY(y));
-       return y;
+//  return (m_scaleGDI ?  (floor(double(y))) :  LogicalToDeviceY(y));
+    return y;
 }
 
 long wxDC::ImplLogicalToDeviceXRel(long x) const
 {
 }
 
 long wxDC::ImplLogicalToDeviceXRel(long x) const
 {
-//     return (m_scaleGDI ?  (floor(double(x))) :  LogicalToDeviceXRel(x));
-       return x;
+//  return (m_scaleGDI ?  (floor(double(x))) :  LogicalToDeviceXRel(x));
+    return x;
 }
 
 long wxDC::ImplLogicalToDeviceYRel(long y) const
 {
 }
 
 long wxDC::ImplLogicalToDeviceYRel(long y) const
 {
-//     return (m_scaleGDI ?  (floor(double(y))) :  LogicalToDeviceYRel(y));
-       return y;
+//  return (m_scaleGDI ?  (floor(double(y))) :  LogicalToDeviceYRel(y));
+    return y;
 }
 
 bool wxDC::Blit(long xdest, long ydest, long width, long height,
 }
 
 bool wxDC::Blit(long xdest, long ydest, long width, long height,
@@ -1155,11 +1188,11 @@ bool wxDC::Blit(long xdest, long ydest, long width, long height,
   COLORREF old_background = ::GetBkColor((HDC)m_hDC);
   if (m_textForegroundColour.Ok())
   {
   COLORREF old_background = ::GetBkColor((HDC)m_hDC);
   if (m_textForegroundColour.Ok())
   {
-       ::SetTextColor((HDC) m_hDC, m_textForegroundColour.GetPixel() ) ;
+    ::SetTextColor((HDC) m_hDC, m_textForegroundColour.GetPixel() ) ;
   }
   if (m_textBackgroundColour.Ok())
   {
   }
   if (m_textBackgroundColour.Ok())
   {
-       ::SetBkColor((HDC) m_hDC, m_textBackgroundColour.GetPixel() ) ;
+    ::SetBkColor((HDC) m_hDC, m_textBackgroundColour.GetPixel() ) ;
   }
 
   DWORD dwRop = rop == wxCOPY ? SRCCOPY :
   }
 
   DWORD dwRop = rop == wxCOPY ? SRCCOPY :
@@ -1176,12 +1209,12 @@ bool wxDC::Blit(long xdest, long ydest, long width, long height,
                 rop == wxSRC_AND ? SRCAND :
                 SRCCOPY;
 
                 rop == wxSRC_AND ? SRCAND :
                 SRCCOPY;
 
-  bool success;
+  bool success = TRUE;
   if (useMask && source->m_selectedBitmap.Ok() && source->m_selectedBitmap.GetMask())
   {
 
 #if 0 // __WIN32__
   if (useMask && source->m_selectedBitmap.Ok() && source->m_selectedBitmap.GetMask())
   {
 
 #if 0 // __WIN32__
-       // Not implemented under Win95 (or maybe a specific device?)
+    // Not implemented under Win95 (or maybe a specific device?)
     if (MaskBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height,
             (HDC) source->m_hDC, xsrc1, ysrc1, (HBITMAP) source->m_selectedBitmap.GetMask()->GetMaskBitmap(),
             0, 0, 0xAACC0020))
     if (MaskBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height,
             (HDC) source->m_hDC, xsrc1, ysrc1, (HBITMAP) source->m_selectedBitmap.GetMask()->GetMaskBitmap(),
             0, 0, 0xAACC0020))
@@ -1193,116 +1226,116 @@ bool wxDC::Blit(long xdest, long ydest, long width, long height,
     {
         // Old code
 #if 0
     {
         // Old code
 #if 0
-           HDC dc_mask = CreateCompatibleDC((HDC) source->m_hDC);
-           ::SelectObject(dc_mask, (HBITMAP) source->m_selectedBitmap.GetMask()->GetMaskBitmap());
+        HDC dc_mask = CreateCompatibleDC((HDC) source->m_hDC);
+        ::SelectObject(dc_mask, (HBITMAP) source->m_selectedBitmap.GetMask()->GetMaskBitmap());
         success = (BitBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height,
         success = (BitBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height,
-                                        dc_mask, xsrc1, ysrc1, 0x00220326 /* NOTSRCAND */) != 0);
+                     dc_mask, xsrc1, ysrc1, 0x00220326 /* NOTSRCAND */) != 0);
         success = (BitBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height,
         success = (BitBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height,
-                                        (HDC) source->m_hDC, xsrc1, ysrc1, SRCPAINT) != 0);
-           ::SelectObject(dc_mask, 0);
-           ::DeleteDC(dc_mask);
+                     (HDC) source->m_hDC, xsrc1, ysrc1, SRCPAINT) != 0);
+        ::SelectObject(dc_mask, 0);
+        ::DeleteDC(dc_mask);
 #endif
         // New code from Chris Breeze, 15/7/98
 #endif
         // New code from Chris Breeze, 15/7/98
-               // Blit bitmap with mask
-
-               if (IsKindOf(CLASSINFO(wxPrinterDC)))
-               {
-                       // If we are printing source colours are screen colours
-                       // not printer colours and so we need copy the bitmap
-                       // pixel by pixel.
-                       RECT rect;
-                       HDC dc_mask = ::CreateCompatibleDC((HDC) source->m_hDC);
-                       HDC dc_src = (HDC) source->m_hDC;
-
-                       ::SelectObject(dc_mask, (HBITMAP) source->m_selectedBitmap.GetMask()->GetMaskBitmap());
-                       for (int x = 0; x < width; x++)
-                       {
-                               for (int y = 0; y < height; y++)
-                               {
-                                       COLORREF cref = ::GetPixel(dc_mask, x, y);
-                                       if (cref)
-                                       {
-                                               HBRUSH brush = ::CreateSolidBrush(::GetPixel(dc_src, x, y));
-                                               rect.left = xdest1 + x; rect.right = rect.left + 1;
-                                               rect.top = ydest1 + y;  rect.bottom = rect.top + 1;
-                                               ::FillRect((HDC) m_hDC, &rect, brush);
-                                               ::DeleteObject(brush);
-                                       }
-                               }
-                       }
-                       ::SelectObject(dc_mask, 0);
-                       ::DeleteDC(dc_mask);
-               }
-               else
-               {
-                       // create a temp buffer bitmap and DCs to access it and the mask
-                       HDC dc_mask = ::CreateCompatibleDC((HDC) source->m_hDC);
-                       HDC dc_buffer = ::CreateCompatibleDC((HDC) m_hDC);
-                       HBITMAP buffer_bmap = ::CreateCompatibleBitmap((HDC) m_hDC, width, height);
-                       ::SelectObject(dc_mask, (HBITMAP) source->m_selectedBitmap.GetMask()->GetMaskBitmap());
-                       ::SelectObject(dc_buffer, buffer_bmap);
-
-                       // copy dest to buffer
-                       ::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
-                               (HDC) m_hDC, xdest1, ydest1, SRCCOPY);
-
-                       // copy src to buffer using selected raster op
-                       ::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
-                               (HDC) source->m_hDC, xsrc1, ysrc1, dwRop);
-
-                       // set masked area in buffer to BLACK (pixel value 0)
-                       COLORREF prevBkCol = ::SetBkColor((HDC) m_hDC, RGB(255, 255, 255));
-                       COLORREF prevCol = ::SetTextColor((HDC) m_hDC, RGB(0, 0, 0));
-                       ::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
-                               dc_mask, xsrc1, ysrc1, SRCAND);
-
-                       // set unmasked area in dest to BLACK
-                       ::SetBkColor((HDC) m_hDC, RGB(0, 0, 0));
-                       ::SetTextColor((HDC) m_hDC, RGB(255, 255, 255));
-                       ::BitBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height,
-                               dc_mask, xsrc1, ysrc1, SRCAND);
-                       ::SetBkColor((HDC) m_hDC, prevBkCol);   // restore colours to original values
-                       ::SetTextColor((HDC) m_hDC, prevCol);
-
-                       // OR buffer to dest
-                       success = (::BitBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height,
-                               dc_buffer, 0, 0, SRCPAINT) != 0);
-
-                       // tidy up temporary DCs and bitmap
-                       ::SelectObject(dc_mask, 0);
-                       ::DeleteDC(dc_mask);
-                       ::SelectObject(dc_buffer, 0);
-                       ::DeleteDC(dc_buffer);
-                       ::DeleteObject(buffer_bmap);
-               }
-       }
+        // Blit bitmap with mask
+
+        if (IsKindOf(CLASSINFO(wxPrinterDC)))
+        {
+            // If we are printing source colours are screen colours
+            // not printer colours and so we need copy the bitmap
+            // pixel by pixel.
+            RECT rect;
+            HDC dc_mask = ::CreateCompatibleDC((HDC) source->m_hDC);
+            HDC dc_src = (HDC) source->m_hDC;
+
+            ::SelectObject(dc_mask, (HBITMAP) source->m_selectedBitmap.GetMask()->GetMaskBitmap());
+            for (int x = 0; x < width; x++)
+            {
+                for (int y = 0; y < height; y++)
+                {
+                    COLORREF cref = ::GetPixel(dc_mask, x, y);
+                    if (cref)
+                    {
+                        HBRUSH brush = ::CreateSolidBrush(::GetPixel(dc_src, x, y));
+                        rect.left = xdest1 + x; rect.right = rect.left + 1;
+                        rect.top = ydest1 + y;  rect.bottom = rect.top + 1;
+                        ::FillRect((HDC) m_hDC, &rect, brush);
+                        ::DeleteObject(brush);
+                    }
+                }
+            }
+            ::SelectObject(dc_mask, 0);
+            ::DeleteDC(dc_mask);
+        }
+        else
+        {
+            // create a temp buffer bitmap and DCs to access it and the mask
+            HDC dc_mask = ::CreateCompatibleDC((HDC) source->m_hDC);
+            HDC dc_buffer = ::CreateCompatibleDC((HDC) m_hDC);
+            HBITMAP buffer_bmap = ::CreateCompatibleBitmap((HDC) m_hDC, width, height);
+            ::SelectObject(dc_mask, (HBITMAP) source->m_selectedBitmap.GetMask()->GetMaskBitmap());
+            ::SelectObject(dc_buffer, buffer_bmap);
+
+            // copy dest to buffer
+            ::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
+                (HDC) m_hDC, xdest1, ydest1, SRCCOPY);
+
+            // copy src to buffer using selected raster op
+            ::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
+                (HDC) source->m_hDC, xsrc1, ysrc1, dwRop);
+
+            // set masked area in buffer to BLACK (pixel value 0)
+            COLORREF prevBkCol = ::SetBkColor((HDC) m_hDC, RGB(255, 255, 255));
+            COLORREF prevCol = ::SetTextColor((HDC) m_hDC, RGB(0, 0, 0));
+            ::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
+                dc_mask, xsrc1, ysrc1, SRCAND);
+
+            // set unmasked area in dest to BLACK
+            ::SetBkColor((HDC) m_hDC, RGB(0, 0, 0));
+            ::SetTextColor((HDC) m_hDC, RGB(255, 255, 255));
+            ::BitBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height,
+                dc_mask, xsrc1, ysrc1, SRCAND);
+            ::SetBkColor((HDC) m_hDC, prevBkCol);   // restore colours to original values
+            ::SetTextColor((HDC) m_hDC, prevCol);
+
+            // OR buffer to dest
+            success = (::BitBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height,
+                dc_buffer, 0, 0, SRCPAINT) != 0);
+
+            // tidy up temporary DCs and bitmap
+            ::SelectObject(dc_mask, 0);
+            ::DeleteDC(dc_mask);
+            ::SelectObject(dc_buffer, 0);
+            ::DeleteDC(dc_buffer);
+            ::DeleteObject(buffer_bmap);
+        }
+    }
   }
   else
   {
   }
   else
   {
-       if (IsKindOf(CLASSINFO(wxPrinterDC)))
-       {
-      // If we are printing source colours are screen colours
+    if (IsKindOf(CLASSINFO(wxPrinterDC)))
+    {
+      // If we are printing, source colours are screen colours
       // not printer colours and so we need copy the bitmap
       // pixel by pixel.
       HDC dc_src = (HDC) source->m_hDC;
       RECT rect;
       for (int x = 0; x < width; x++)
       // not printer colours and so we need copy the bitmap
       // pixel by pixel.
       HDC dc_src = (HDC) source->m_hDC;
       RECT rect;
       for (int x = 0; x < width; x++)
-         {
+      {
         for (int y = 0; y < height; y++)
         for (int y = 0; y < height; y++)
-               {
+        {
           HBRUSH brush = ::CreateSolidBrush(::GetPixel(dc_src, x, y));
           HBRUSH brush = ::CreateSolidBrush(::GetPixel(dc_src, x, y));
-          rect.left = xdest1 + x;      rect.right = rect.left + 1;
-          rect.top = ydest1 + y;       rect.bottom = rect.top + 1;
+          rect.left = xdest1 + x;   rect.right = rect.left + 1;
+          rect.top = ydest1 + y;    rect.bottom = rect.top + 1;
           ::FillRect((HDC) m_hDC, &rect, brush);
           ::DeleteObject(brush);
           ::FillRect((HDC) m_hDC, &rect, brush);
           ::DeleteObject(brush);
-               }
-         }
+        }
+      }
     }
     }
-       else
-       {
+    else
+    {
       success = (BitBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height, (HDC) source->m_hDC,
                             xsrc1, ysrc1, dwRop) != 0);
       success = (BitBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height, (HDC) source->m_hDC,
                             xsrc1, ysrc1, dwRop) != 0);
-       }
+    }
   }
   ::SetTextColor((HDC)m_hDC, old_textground);
   ::SetBkColor((HDC)m_hDC, old_background);
   }
   ::SetTextColor((HDC)m_hDC, old_textground);
   ::SetBkColor((HDC)m_hDC, old_background);
@@ -1326,10 +1359,6 @@ void wxDC::GetSizeMM(long *width, long *height) const
   *height = h;
 }
 
   *height = h;
 }
 
-#if USE_SPLINES
-#include "xfspline.inc"
-#endif // USE_SPLINES
-
 void wxDC::DrawPolygon(wxList *list, long xoffset, long yoffset,int fillStyle)
 {
   int n = list->Number();
 void wxDC::DrawPolygon(wxList *list, long xoffset, long yoffset,int fillStyle)
 {
   int n = list->Number();
@@ -1370,34 +1399,6 @@ void wxDC::SetTextBackground(const wxColour& colour)
     m_textBackgroundColour = colour;
 }
 
     m_textBackgroundColour = colour;
 }
 
-#if USE_SPLINES
-// Make a 3-point spline
-void wxDC::DrawSpline(long x1, long y1, long x2, long y2, long x3, long y3)
-{
-  wxList *point_list = new wxList;
-
-  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(wxNode *node = point_list->First(); node; node = node->Next()) {
-    wxPoint *p = (wxPoint *)node->Data();
-    delete p;
-  }
-  delete point_list;
-}
-#endif
-
 // For use by wxWindows only, unless custom units are required.
 void wxDC::SetLogicalScale(double x, double y)
 {
 // For use by wxWindows only, unless custom units are required.
 void wxDC::SetLogicalScale(double x, double y)
 {
@@ -1432,8 +1433,8 @@ void wxDC::GetTextExtent(const wxString& string, float *x, float *y,
                      wxFont *theFont, bool use16bit) const
 {
     long x1, y1, descent1, externalLeading1;
                      wxFont *theFont, bool use16bit) const
 {
     long x1, y1, descent1, externalLeading1;
-       GetTextExtent(string, & x1, & y1, & descent1, & externalLeading1, theFont, use16bit);
-       *x = x1; *y = y1;
+    GetTextExtent(string, & x1, & y1, & descent1, & externalLeading1, theFont, use16bit);
+    *x = x1; *y = y1;
     if (descent)
         *descent = descent1;
     if (externalLeading)
     if (descent)
         *descent = descent1;
     if (externalLeading)
@@ -1441,3 +1442,279 @@ void wxDC::GetTextExtent(const wxString& string, float *x, float *y,
 }
 #endif
 
 }
 #endif
 
+int wxDC::GetDepth(void) const
+{
+  return (int) ::GetDeviceCaps((HDC) m_hDC,BITSPIXEL);
+}
+
+#if wxUSE_SPLINES
+
+// Make a 3-point spline
+void wxDC::DrawSpline(long x1, long y1, long x2, long y2, long x3, long y3)
+{
+  wxList *point_list = new wxList;
+
+  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(wxNode *node = point_list->First(); node; node = node->Next()) {
+    wxPoint *p = (wxPoint *)node->Data();
+    delete p;
+  }
+  delete point_list;
+}
+
+////#define     wx_round(a)    (int)((a)+.5)
+//#define     wx_round(a)    (a)
+
+class wxSpline: public wxObject
+{
+ public:
+  int type;
+  wxList *points;
+
+  wxSpline(wxList *list);
+  void DeletePoints(void);
+
+  // Doesn't delete points
+  ~wxSpline(void);
+};
+
+void wxDC::DrawSpline(int n, wxPoint points[])
+{
+  wxList list;
+  int i;
+  for (i =0; i < n; i++)
+    list.Append((wxObject*)&points[i]);
+  DrawSpline((wxList *)&list);
+}
+
+void wx_draw_open_spline(wxDC *dc, wxSpline *spline);
+
+void wx_quadratic_spline(double a1, double b1, double a2, double b2,
+                         double a3, double b3, double a4, double b4);
+void wx_clear_stack(void);
+int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
+        double *y3, double *x4, double *y4);
+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(wxDC *dc);
+wxSpline *wx_make_spline(int x1, int y1, int x2, int y2, int x3, int y3);
+
+void wxDC::DrawSpline(wxList *list)
+{
+  wxSpline spline(list);
+
+  wx_draw_open_spline(this, &spline);
+}
+
+
+wxList wx_spline_point_list;
+
+void wx_draw_open_spline(wxDC *dc, wxSpline *spline)
+{
+    wxPoint *p;
+    double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
+    double           x1, y1, x2, y2;
+
+    wxNode *node = spline->points->First();
+    p = (wxPoint *)node->Data();
+
+    x1 = p->x;
+    y1 = p->y;
+
+    node = node->Next();
+    p = (wxPoint *)node->Data();
+
+    x2 = p->x;
+    y2 = p->y;
+    cx1 = (double)((x1 + x2) / 2);
+    cy1 = (double)((y1 + y2) / 2);
+    cx2 = (double)((cx1 + x2) / 2);
+    cy2 = (double)((cy1 + y2) / 2);
+
+    wx_spline_add_point(x1, y1);
+
+    while ((node = node->Next()) != NULL)
+    {
+        p = (wxPoint *)node->Data();
+    x1 = x2;
+    y1 = y2;
+    x2 = p->x;
+    y2 = p->y;
+        cx4 = (double)(x1 + x2) / 2;
+        cy4 = (double)(y1 + y2) / 2;
+        cx3 = (double)(x1 + cx4) / 2;
+        cy3 = (double)(y1 + cy4) / 2;
+
+        wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
+
+    cx1 = cx4;
+    cy1 = cy4;
+        cx2 = (double)(cx1 + x2) / 2;
+        cy2 = (double)(cy1 + y2) / 2;
+    }
+
+    wx_spline_add_point((double)wx_round(cx1), (double)wx_round(cy1));
+    wx_spline_add_point(x2, y2);
+
+    wx_spline_draw_point_array(dc);
+
+}
+
+/********************* CURVES FOR SPLINES *****************************
+
+    The following spline drawing routine is from
+
+    "An Algorithm for High-Speed Curve Generation"
+    by George Merrill Chaikin,
+    Computer Graphics and Image Processing, 3, Academic Press,
+    1974, 346-349.
+
+    and
+
+    "On Chaikin's Algorithm" by R. F. Riesenfeld,
+    Computer Graphics and Image Processing, 4, Academic Press,
+    1975, 304-310.
+
+***********************************************************************/
+
+#define     half(z1, z2)    ((z1+z2)/2.0)
+#define     THRESHOLD   5
+
+/* iterative version */
+
+void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
+                 double b4)
+{
+    register double  xmid, ymid;
+    double           x1, y1, x2, y2, x3, y3, x4, y4;
+
+    wx_clear_stack();
+    wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
+
+    while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
+        xmid = (double)half(x2, x3);
+        ymid = (double)half(y2, y3);
+    if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
+        fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
+            wx_spline_add_point((double)wx_round(x1), (double)wx_round(y1));
+            wx_spline_add_point((double)wx_round(xmid), (double)wx_round(ymid));
+    } else {
+            wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
+                 (double)half(x3, x4), (double)half(y3, y4), x4, y4);
+            wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
+                 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
+    }
+    }
+}
+
+
+/* utilities used by spline drawing routines */
+
+
+typedef struct wx_spline_stack_struct {
+    double           x1, y1, x2, y2, x3, y3, x4, y4;
+}
+                Stack;
+
+#define         SPLINE_STACK_DEPTH             20
+static Stack    wx_spline_stack[SPLINE_STACK_DEPTH];
+static Stack   *wx_stack_top;
+static int      wx_stack_count;
+
+void wx_clear_stack(void)
+{
+    wx_stack_top = wx_spline_stack;
+    wx_stack_count = 0;
+}
+
+void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
+{
+    wx_stack_top->x1 = x1;
+    wx_stack_top->y1 = y1;
+    wx_stack_top->x2 = x2;
+    wx_stack_top->y2 = y2;
+    wx_stack_top->x3 = x3;
+    wx_stack_top->y3 = y3;
+    wx_stack_top->x4 = x4;
+    wx_stack_top->y4 = y4;
+    wx_stack_top++;
+    wx_stack_count++;
+}
+
+int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
+                  double *x3, double *y3, double *x4, double *y4)
+{
+    if (wx_stack_count == 0)
+    return (0);
+    wx_stack_top--;
+    wx_stack_count--;
+    *x1 = wx_stack_top->x1;
+    *y1 = wx_stack_top->y1;
+    *x2 = wx_stack_top->x2;
+    *y2 = wx_stack_top->y2;
+    *x3 = wx_stack_top->x3;
+    *y3 = wx_stack_top->y3;
+    *x4 = wx_stack_top->x4;
+    *y4 = wx_stack_top->y4;
+    return (1);
+}
+
+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;
+}
+
+static void wx_spline_draw_point_array(wxDC *dc)
+{
+  dc->DrawLines(&wx_spline_point_list, 0, 0);
+  wxNode *node = wx_spline_point_list.First();
+  while (node)
+  {
+    wxPoint *point = (wxPoint *)node->Data();
+    delete point;
+    delete node;
+    node = wx_spline_point_list.First();
+  }
+}
+
+wxSpline::wxSpline(wxList *list)
+{
+  points = list;
+}
+
+wxSpline::~wxSpline(void)
+{
+}
+
+void wxSpline::DeletePoints(void)
+{
+  for(wxNode *node = points->First(); node; node = points->First())
+  {
+    wxPoint *point = (wxPoint *)node->Data();
+    delete point;
+    delete node;
+  }
+  delete points;
+}
+
+
+#endif // wxUSE_SPLINES
+