X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/1408104d04fdea106c8ec288866c4143078ae71b..1be06faf7318abf88a35b299b90ceb2a49c0353b:/src/os2/dc.cpp

diff --git a/src/os2/dc.cpp b/src/os2/dc.cpp
index c32e0528d4..63a91c8b71 100644
--- a/src/os2/dc.cpp
+++ b/src/os2/dc.cpp
@@ -1,287 +1,410 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        dc.cpp
 // Purpose:     wxDC class
-// Author:      AUTHOR
+// Author:      David Webster
 // Modified by:
-// Created:     01/02/97
+// Created:     10/14/99
 // RCS-ID:      $Id$
-// Copyright:   (c) AUTHOR
-// Licence:   	wxWindows licence
+// Copyright:   (c) David Webster
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
-#ifdef __GNUG__
-#pragma implementation "dc.h"
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/window.h"
+    #include "wx/dc.h"
+    #include "wx/utils.h"
+    #include "wx/dialog.h"
+    #include "wx/app.h"
+    #include "wx/bitmap.h"
+    #include "wx/dcmemory.h"
+    #include "wx/log.h"
+    #include "wx/icon.h"
 #endif
 
-#include "wx/dc.h"
+#include "wx/dcprint.h"
 
-#if !USE_SHARED_LIBRARY
-IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
-#endif
+#include <string.h>
+#include <math.h>
+
+#include "wx/os2/private.h"
+
+    IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
 
-//-----------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
 // constants
-//-----------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
 
-#define mm2inches		0.0393700787402
-#define inches2mm		25.4
-#define mm2twips		56.6929133859
-#define twips2mm		0.0176388888889
-#define mm2pt			2.83464566929
-#define pt2mm			0.352777777778
+static const int VIEWPORT_EXTENT = 1000;
 
-//-----------------------------------------------------------------------------
-// wxDCBase
-//-----------------------------------------------------------------------------
+static const int MM_POINTS = 9;
+static const int MM_METRIC = 10;
 
-long wxDCBase::DeviceToLogicalX(long x) const
-{
-  return XDEV2LOG(x);
-};
+// usually this is defined in math.h
+#ifndef M_PI
+    static const double M_PI = 3.14159265358979323846;
+#endif // M_PI
 
-long wxDCBase::DeviceToLogicalY(long y) const
+// ---------------------------------------------------------------------------
+// private functions
+// ---------------------------------------------------------------------------
+
+// convert degrees to radians
+static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
+
+// ===========================================================================
+// implementation
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// wxDC
+// ---------------------------------------------------------------------------
+
+wxDC::wxDC(void)
 {
-  return YDEV2LOG(y);
+    m_pCanvas     = NULL;
+
+    m_hOldBitmap  = 0;
+    m_hOldPen     = 0;
+    m_hOldBrush   = 0;
+    m_hOldFont    = 0;
+    m_hOldPalette = 0;
+
+    m_bOwnsDC     = FALSE;
+    m_hDC         = 0;
+    m_nDCCount    = 0;
 };
 
-long wxDCBase::DeviceToLogicalXRel(long x) const
+wxDC::~wxDC(void)
 {
-  return XDEV2LOGREL(x);
+    // TODO:
 };
 
-long wxDCBase::DeviceToLogicalYRel(long y) const
+// This will select current objects out of the DC,
+// which is what you have to do before deleting the
+// DC.
+void wxDC::SelectOldObjects(WXHDC dc)
+{
+    if (dc)
+    {
+        if (m_hOldBitmap)
+        {
+//            ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);
+            if (m_vSelectedBitmap.Ok())
+            {
+                m_vSelectedBitmap.SetSelectedInto(NULL);
+            }
+        }
+        m_hOldBitmap = 0;
+        if (m_hOldPen)
+        {
+//            ::SelectObject((HDC) dc, (HPEN) m_oldPen);
+        }
+        m_hOldPen = 0;
+        if (m_hOldBrush)
+        {
+//            ::SelectObject((HDC) dc, (HBRUSH) m_oldBrush);
+        }
+        m_hOldBrush = 0;
+        if (m_hOldFont)
+        {
+//            ::SelectObject((HDC) dc, (HFONT) m_oldFont);
+        }
+        m_hOldFont = 0;
+        if (m_hOldPalette)
+        {
+//            ::SelectPalette((HDC) dc, (HPALETTE) m_oldPalette, TRUE);
+        }
+        m_hOldPalette = 0;
+    }
+
+    m_brush           = wxNullBrush;
+    m_pen             = wxNullPen;
+    m_palette         = wxNullPalette;
+    m_font            = wxNullFont;
+    m_backgroundBrush = wxNullBrush;
+    m_vSelectedBitmap = wxNullBitmap;
+}
+
+// ---------------------------------------------------------------------------
+// clipping
+// ---------------------------------------------------------------------------
+
+#define DO_SET_CLIPPING_BOX()                   \
+{                                               \
+    RECT rect;                                  \
+                                                \
+    GetClipBox(GetHdc(), &rect);                \
+                                                \
+    m_clipX1 = (wxCoord) XDEV2LOG(rect.left);   \
+    m_clipY1 = (wxCoord) YDEV2LOG(rect.top);    \
+    m_clipX2 = (wxCoord) XDEV2LOG(rect.right);  \
+    m_clipY2 = (wxCoord) YDEV2LOG(rect.bottom); \
+}
+
+void wxDC::DoSetClippingRegion( wxCoord x, wxCoord y
+                               ,wxCoord width, wxCoord height
+                              )
 {
-  return YDEV2LOGREL(y);
-};
+   // TODO
+}
 
-long wxDCBase::LogicalToDeviceX(long x) const
+void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
 {
-  return XLOG2DEV(x);
-};
+   // TODO
+}
 
-long wxDCBase::LogicalToDeviceY(long y) const
+void wxDC::DestroyClippingRegion(void)
 {
-  return YLOG2DEV(y);
+    // TODO:
 };
 
-long wxDCBase::LogicalToDeviceXRel(long x) const
+// ---------------------------------------------------------------------------
+// query capabilities
+// ---------------------------------------------------------------------------
+
+bool wxDC::CanDrawBitmap() const
 {
-  return XLOG2DEVREL(x);
-};
+    return TRUE;
+}
 
-long wxDCBase::LogicalToDeviceYRel(long y) const
+bool wxDC::CanGetTextExtent() const
 {
-  return YLOG2DEVREL(y);
-};
+    // What sort of display is it?
+    int technology = 0; // TODO:  ::GetDeviceCaps(GetHdc(), TECHNOLOGY);
 
-//-----------------------------------------------------------------------------
-// wxDC
-//-----------------------------------------------------------------------------
+    // TODO: return (technology == DT_RASDISPLAY) || (technology == DT_RASPRINTER);
+    return FALSE;
+}
 
-wxDC::wxDC(void)
+int wxDC::GetDepth() const
 {
-  m_ok = FALSE;
-  m_optimize = FALSE;
-  m_autoSetting = FALSE;
-  m_colour = TRUE;
-  m_clipping = FALSE;
-
-  m_mm_to_pix_x = 1.0;
-  m_mm_to_pix_y = 1.0;
-
-  m_logicalOriginX = 0;
-  m_logicalOriginY = 0;
-  m_deviceOriginX = 0;
-  m_deviceOriginY = 0;
-  m_internalDeviceOriginX = 0;
-  m_internalDeviceOriginY = 0;
-  m_externalDeviceOriginX = 0;
-  m_externalDeviceOriginY = 0;
-
-  m_logicalScaleX = 1.0;
-  m_logicalScaleY = 1.0;
-  m_userScaleX = 1.0;
-  m_userScaleY = 1.0;
-  m_scaleX = 1.0;
-  m_scaleY = 1.0;
-
-  m_mappingMode = wxMM_TEXT;
-  m_needComputeScaleX = FALSE;
-  m_needComputeScaleY = FALSE;
-
-  m_signX = 1;  // default x-axis left to right
-  m_signY = 1;  // default y-axis top down
-
-  m_maxX = m_maxY = -100000;
-  m_minY = m_minY =  100000;
-
-  m_logicalFunction = wxCOPY;
-//  m_textAlignment = wxALIGN_TOP_LEFT;
-  m_backgroundMode = wxTRANSPARENT;
-
-  m_textForegroundColour = *wxBLACK;
-  m_textBackgroundColour = *wxWHITE;
-  m_pen = *wxBLACK_PEN;
-  m_font = *wxNORMAL_FONT;
-  m_brush = *wxTRANSPARENT_BRUSH;
-  m_backgroundBrush = *wxWHITE_BRUSH;
-
-//  m_palette = wxAPP_COLOURMAP;
-};
+   // TODO:
+   return (1);
+}
 
-wxDC::~wxDC(void)
-{
-};
+// ---------------------------------------------------------------------------
+// drawing
+// ---------------------------------------------------------------------------
 
-void wxDC::DestroyClippingRegion(void)
+void wxDC::Clear()
 {
-  m_clipping = FALSE;
-};
+   // TODO
+}
 
-void wxDC::GetSize( int* width, int* height ) const
+void wxDC::DoFloodFill( wxCoord x
+                       ,wxCoord y
+                       ,const wxColour& col
+                       ,int style
+                      )
 {
-  *width = m_maxX-m_minX;
-  *height = m_maxY-m_minY;
-};
+   // TODO
+}
 
-void wxDC::GetSizeMM( long* width, long* height ) const
+bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
 {
-  int w = 0;
-  int h = 0;
-  GetSize( &w, &h );
-  *width = long( double(w) / (m_scaleX*m_mm_to_pix_x) );
-  *height = long( double(h) / (m_scaleY*m_mm_to_pix_y) );
-};
+   // TODO
+   return(TRUE);
+}
 
-void wxDC::SetMapMode( int mode )
+void wxDC::DoCrossHair(wxCoord x, wxCoord y)
 {
-  switch (mode)
-  {
-    case wxMM_TWIPS:
-      SetLogicalScale( twips2mm*m_mm_to_pix_x, twips2mm*m_mm_to_pix_y );
-      break;
-    case wxMM_POINTS:
-      SetLogicalScale( pt2mm*m_mm_to_pix_x, pt2mm*m_mm_to_pix_y );
-      break;
-    case wxMM_METRIC:
-      SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
-      break;
-    case wxMM_LOMETRIC:
-      SetLogicalScale( m_mm_to_pix_x/10.0, m_mm_to_pix_y/10.0 );
-      break;
-    default:
-    case wxMM_TEXT:
-      SetLogicalScale( 1.0, 1.0 );
-      break;
-  };
-  if (mode != wxMM_TEXT)
-  {
-    m_needComputeScaleX = TRUE;
-    m_needComputeScaleY = TRUE;
-  };
-};
+   // TODO
+}
 
-void wxDC::SetUserScale( double x, double y )
+void wxDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
 {
-  // allow negative ? -> no
-  m_userScaleX = x;
-  m_userScaleY = y;
-  ComputeScaleAndOrigin();
-};
+   // TODO
+}
 
-void wxDC::GetUserScale( double *x, double *y )
+void wxDC::DoDrawArc( wxCoord x1, wxCoord y1
+                     ,wxCoord x2, wxCoord y2
+                     ,wxCoord xc, wxCoord yc
+                    )
 {
-  if (x) *x = m_userScaleX;
-  if (y) *y = m_userScaleY;
-};
+   // TODO
+}
 
-void wxDC::SetLogicalScale( double x, double y )
+void wxDC::DoDrawCheckMark(wxCoord x1, wxCoord y1,
+                           wxCoord width, wxCoord height)
 {
-  // allow negative ?
-  m_logicalScaleX = x;
-  m_logicalScaleY = y;
-  ComputeScaleAndOrigin();
-};
+    // TODO
+}
 
-void wxDC::SetLogicalOrigin( long x, long y )
+void wxDC::DoDrawPoint(wxCoord x, wxCoord y)
 {
-  m_logicalOriginX = x * m_signX;   // is this still correct ?
-  m_logicalOriginY = y * m_signY;
-  ComputeScaleAndOrigin();
-};
+   // TODO
+}
 
-void wxDC::SetDeviceOrigin( long x, long y )
+void wxDC::DoDrawPolygon(int n, wxPoint points[]
+                         ,wxCoord xoffset, wxCoord yoffset
+                         ,int fillStyle
+                        )
 {
-  m_externalDeviceOriginX = x;
-  m_externalDeviceOriginY = y;
-  ComputeScaleAndOrigin();
-};
+   // TODO
+}
 
-void wxDC::SetInternalDeviceOrigin( long x, long y )
+void wxDC::DoDrawLines( int n, wxPoint points[]
+                       ,wxCoord xoffset, wxCoord yoffset
+                      )
 {
-  m_internalDeviceOriginX = x;
-  m_internalDeviceOriginY = y;
-  ComputeScaleAndOrigin();
-};
+   // TODO
+}
 
-void wxDC::GetInternalDeviceOrigin( long *x, long *y )
+void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 {
-  if (x) *x = m_internalDeviceOriginX;
-  if (y) *y = m_internalDeviceOriginY;
-};
+   // TODO
+}
 
-void wxDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
+void wxDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y
+                                  ,wxCoord width, wxCoord height
+                                  ,double radius
+                                 )
 {
-  m_signX = (xLeftRight ?  1 : -1);
-  m_signY = (yBottomUp  ? -1 :  1);
-  ComputeScaleAndOrigin();
-};
+   // TODO
+}
 
+void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+{
+   // TODO
+}
 
-int wxDC::GetDepth() const
+void wxDC::DoDrawEllipticArc( wxCoord x
+                             ,wxCoord y
+                             ,wxCoord w
+                             ,wxCoord h
+                             ,double sa
+                             ,double ea
+                            )
 {
-   // TODO:
-   return (1);
+   // TODO
 }
 
-wxSize wxDC::GetPPI() const
+void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
 {
-   // TODO:
-   return (1);
+   // TODO
 }
-void wxDC::GetTextExtent( const wxString& string
-                         ,long* x
-                         ,long* y
-                         ,long* decent
-                         ,long* externalLeading
-                         ,wxFont* theFont
-                        ) const
+
+void wxDC::DoDrawBitmap( const wxBitmap &bmp
+                        ,wxCoord x, wxCoord y
+                        ,bool useMask
+                       )
 {
-   // TODO:
+   // TODO
 }
 
-void wxDC::GetCharWidth() const
+void wxDC::DoDrawText(const wxString& text, wxCoord x, wxCoord y)
 {
-    // TODO
-    return(1);
+   // TODO
 }
 
-void wxDC::GetCharHeight() const
+void wxDC::DrawAnyText(const wxString& text, wxCoord x, wxCoord y)
 {
     // TODO
-    return(1);
 }
 
-void wxDC::Clear()
+void wxDC::DoDrawRotatedText(const wxString& text,
+                             wxCoord x, wxCoord y,
+                             double angle)
 {
-   // TODO
-}
+   // TODO:
+   /*
+    if ( angle == 0.0 )
+    {
+        DoDrawText(text, x, y);
+    }
+    else
+    {
+        LOGFONT lf;
+        wxFillLogFont(&lf, &m_font);
+
+        // GDI wants the angle in tenth of degree
+        long angle10 = (long)(angle * 10);
+        lf.lfEscapement = angle10;
+        lf. lfOrientation = angle10;
+
+        HFONT hfont = ::CreateFontIndirect(&lf);
+        if ( !hfont )
+        {
+            wxLogLastError("CreateFont");
+        }
+        else
+        {
+            HFONT hfontOld = ::SelectObject(GetHdc(), hfont);
+
+            DrawAnyText(text, x, y);
+
+            (void)::SelectObject(GetHdc(), hfontOld);
+        }
+
+        // call the bounding box by adding all four vertices of the rectangle
+        // containing the text to it (simpler and probably not slower than
+        // determining which of them is really topmost/leftmost/...)
+        wxCoord w, h;
+        GetTextExtent(text, &w, &h);
+
+        double rad = DegToRad(angle);
+
+        // "upper left" and "upper right"
+        CalcBoundingBox(x, y);
+        CalcBoundingBox(x + w*cos(rad), y - h*sin(rad));
+        CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
+
+        // "bottom left" and "bottom right"
+        x += (wxCoord)(h*sin(rad));
+        y += (wxCoord)(h*cos(rad));
+        CalcBoundingBox(x, y);
+        CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
+    }
+*/
+}
+
+// ---------------------------------------------------------------------------
+// set GDI objects
+// ---------------------------------------------------------------------------
 
-void wxDC::SetFont(const wxFont& font)
+void wxDC::SetPalette(const wxPalette& palette)
 {
    // TODO
 }
 
+void wxDC::SetFont(
+  const wxFont&                     rFont
+)
+{
+    //
+    // Set the old object temporarily, in case the assignment deletes an object
+    // that's not yet selected out.
+    //
+    if (m_hOldFont)
+    {
+//        ::SelectObject(GetHdc(), (HFONT) m_hOldFont);
+        m_hOldFont = 0;
+    }
+
+    m_font = rFont;
+
+    if (!rFont.Ok())
+    {
+        if (m_hOldFont)
+//            ::SelectObject(GetHdc(), (HFONT) m_hOldFont);
+        m_hOldFont = 0;
+    }
+
+    if (m_font.Ok() && m_font.GetResourceHandle())
+    {
+        HFONT                       hFont = (HFONT)0; //::SelectObject(GetHdc(), (HFONT) m_font.GetResourceHandle());
+        if (hFont == (HFONT) NULL)
+        {
+            wxLogDebug(wxT("::SelectObject failed in wxDC::SetFont."));
+        }
+        if (!m_hOldFont)
+            m_hOldFont = (WXHFONT) hFont;
+    }
+}
+
 void wxDC::SetPen(const wxPen& pen)
 {
    // TODO
@@ -296,257 +419,466 @@ void wxDC::SetBackground(const wxBrush& brush)
    // TODO
 }
 
-void wxDC::SetLogicalFunction(int function)
+void wxDC::SetBackgroundMode(int mode)
 {
    // TODO
 }
 
-void wxDC::SetBackgroundMode(int mode)
+void wxDC::SetLogicalFunction(int function)
 {
    // TODO
 }
 
-void wxDC::SetPalette(const wxPalette& palette)
+void wxDC::SetRop(WXHDC dc)
+{
+    if (!dc || m_logicalFunction < 0)
+        return;
+
+    int c_rop;
+    // These may be wrong
+    switch (m_logicalFunction)
+    {
+// TODO: Figure this stuff out
+        //    case wxXOR: c_rop = R2_XORPEN; break;
+//    case wxXOR: c_rop = R2_NOTXORPEN; break;
+//    case wxINVERT: c_rop = R2_NOT; break;
+//    case wxOR_REVERSE: c_rop = R2_MERGEPENNOT; break;
+//    case wxAND_REVERSE: c_rop = R2_MASKPENNOT; break;
+//    case wxCLEAR: c_rop = R2_WHITE; break;
+//    case wxSET: c_rop = R2_BLACK; break;
+//    case wxSRC_INVERT: c_rop = R2_NOTCOPYPEN; break;
+//    case wxOR_INVERT: c_rop = R2_MERGENOTPEN; break;
+//    case wxAND: c_rop = R2_MASKPEN; break;
+//    case wxOR: c_rop = R2_MERGEPEN; break;
+//    case wxAND_INVERT: c_rop = R2_MASKNOTPEN; break;
+//    case wxEQUIV:
+//    case wxNAND:
+//    case wxCOPY:
+    default:
+//      c_rop = R2_COPYPEN;
+        break;
+    }
+//    SetROP2((HDC) dc, c_rop);
+}
+
+bool wxDC::StartDoc(const wxString& message)
 {
-   // TODO
+    // We might be previewing, so return TRUE to let it continue.
+    return TRUE;
 }
 
-void wxDC::DoFloodFill( long x
-                       ,long y
-                       ,const wxColour& col
-                       ,int style = wxFLOOD_SURFACE
-                      )
+void wxDC::EndDoc()
 {
-   // TODO
 }
 
-bool wxDC::DoGetPixel(long x, long y, wxColour *col) const
+void wxDC::StartPage()
 {
-   // TODO
-   return(TRUE);
 }
 
-void wxDC::DoDrawPoint(long x, long y)
+void wxDC::EndPage()
 {
-   // TODO
 }
 
-void wxDC::DoDrawLine(long x1, long y1, long x2, long y2)
+// ---------------------------------------------------------------------------
+// text metrics
+// ---------------------------------------------------------------------------
+
+wxCoord wxDC::GetCharHeight() const
 {
-   // TODO
+    // TODO
+    return(1);
 }
 
-void wxDC::DoDrawArc( long x1, long y1
-                     ,long x2, long y2
-                     ,long xc, long yc
-                    )
+wxCoord wxDC::GetCharWidth() const
 {
-   // TODO
+    // TODO
+    return(1);
 }
 
-void wxDC::DoDrawEllipticArc( long x
-                             ,long y
-                             ,long w
-                             ,long h
-                             ,double sa
-                             ,double ea
-                            )
+void wxDC::DoGetTextExtent( const wxString& string
+                           ,wxCoord* x
+                           ,wxCoord* y
+                           ,wxCoord* decent
+                           ,wxCoord* externalLeading
+                           ,wxFont* theFont
+                          ) const
 {
-   // TODO
+   // TODO:
 }
 
-void wxDC::DoDrawRectangle(long x, long y, long width, long height)
+void wxDC::SetMapMode( int mode )
+{
+    // TODO:
+};
+
+void wxDC::SetUserScale(double x, double y)
 {
-   // TODO
+    m_userScaleX = x;
+    m_userScaleY = y;
+
+    SetMapMode(m_mappingMode);
 }
 
-void wxDC::DoDrawRoundedRectangle( long x, long y
-                                  ,long width, long height
-                                  ,double radius
-                                 )
+void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
 {
-   // TODO
+    m_signX = xLeftRight ? 1 : -1;
+    m_signY = yBottomUp ? -1 : 1;
+
+    SetMapMode(m_mappingMode);
 }
 
-void wxDC::DoDrawEllipse(long x, long y, long width, long height)
+void wxDC::SetSystemScale(double x, double y)
 {
-   // TODO
+    m_scaleX = x;
+    m_scaleY = y;
+
+    SetMapMode(m_mappingMode);
 }
 
-void wxDC::DoCrossHair(long x, long y)
+void wxDC::SetLogicalOrigin( wxCoord x, wxCoord y )
 {
-   // TODO
+    // TODO:
+};
+
+void wxDC::SetDeviceOrigin( wxCoord x, wxCoord y )
+{
+    // TODO:
+};
+
+// ---------------------------------------------------------------------------
+// coordinates transformations
+// ---------------------------------------------------------------------------
+
+wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
+{
+    return (wxCoord) (((x) - m_deviceOriginX)/(m_logicalScaleX*m_userScaleX*m_signX*m_scaleX) - m_logicalOriginX);
 }
 
-void wxDC::DoDrawIcon(const wxIcon& icon, long x, long y)
+wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
 {
-   // TODO
+    return (wxCoord) ((x)/(m_logicalScaleX*m_userScaleX*m_signX*m_scaleX));
 }
 
-void wxDC::DoDrawBitmap( const wxBitmap &bmp
-                        ,long x, long y
-                        ,bool useMask = FALSE
-                       )
+wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
 {
-   // TODO
+    return (wxCoord) (((y) - m_deviceOriginY)/(m_logicalScaleY*m_userScaleY*m_signY*m_scaleY) - m_logicalOriginY);
 }
 
-void wxDC::DoDrawText(const wxString& text, long x, long y)
+wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
 {
-   // TODO
+    return (wxCoord) ((y)/(m_logicalScaleY*m_userScaleY*m_signY*m_scaleY));
 }
 
-bool wxDC::DoBlit( long xdest
-                  ,long ydest
-                  ,long width
-                  ,long height
-                  ,wxDC *source
-                  ,long xsrc
-                  ,long ysrc
-                  ,int  rop = wxCOPY
-                  ,bool useMask = FALSE
-                 )
+wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
 {
-   // TODO
-   return(TRUE);
+    return (wxCoord) ((x - m_logicalOriginX)*m_logicalScaleX*m_userScaleX*m_signX*m_scaleX + m_deviceOriginX);
 }
 
-void wxDC::DoGetSize(int *width, int *height) const
+wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
 {
-   // TODO
+    return (wxCoord) (x*m_logicalScaleX*m_userScaleX*m_signX*m_scaleX);
 }
 
-void wxDC::DoGetSizeMM(int* width, int* height) const
+wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
 {
-   // TODO
+    return (wxCoord) ((y - m_logicalOriginY)*m_logicalScaleY*m_userScaleY*m_signY*m_scaleY + m_deviceOriginY);
 }
 
-void wxDC::DoDrawLines( int n, wxPoint points[]
-                       ,long xoffset, long yoffset
-                      )
+wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
 {
-   // TODO
+    return (wxCoord) (y*m_logicalScaleY*m_userScaleY*m_signY*m_scaleY);
 }
 
-void wxDC::DoDrawPolygon(int n, wxPoint points[]
-                         ,long xoffset, long yoffset
-                         ,int fillStyle = wxODDEVEN_RULE
-                        )
+// ---------------------------------------------------------------------------
+// bit blit
+// ---------------------------------------------------------------------------
+
+bool wxDC::DoBlit( wxCoord xdest
+                  ,wxCoord ydest
+                  ,wxCoord width
+                  ,wxCoord height
+                  ,wxDC *source
+                  ,wxCoord xsrc
+                  ,wxCoord ysrc
+                  ,int  rop
+                  ,bool useMask
+                 )
 {
    // TODO
+   return(TRUE);
 }
 
-void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
+void wxDC::DoGetSize( int* width, int* height ) const
 {
-   // TODO
+    // TODO:
+};
+
+void wxDC::DoGetSizeMM( int* width, int* height ) const
+{
+    // TODO:
+};
+
+wxSize wxDC::GetPPI() const
+{
+   int x = 1;
+   int y = 1;
+   // TODO:
+   return (wxSize(x,y));
 }
 
-void wxDC::DoSetClippingRegion( long x, long y
-                               ,long width, long height
-                              )
+void wxDC::SetLogicalScale( double x, double y )
 {
-   // TODO
+    // TODO:
+};
+
+#if WXWIN_COMPATIBILITY
+void wxDC::DoGetTextExtent(const wxString& string, float *x, float *y,
+                         float *descent, float *externalLeading,
+                         wxFont *theFont, bool use16bit) const
+{
+    wxCoord x1, y1, descent1, externalLeading1;
+    GetTextExtent(string, & x1, & y1, & descent1, & externalLeading1, theFont, use16bit);
+    *x = x1; *y = y1;
+    if (descent)
+        *descent = descent1;
+    if (externalLeading)
+        *externalLeading = externalLeading1;
 }
+#endif
+
+// ---------------------------------------------------------------------------
+// spline drawing code
+// ---------------------------------------------------------------------------
 
 #if wxUSE_SPLINES
-void wxDC::DoDrawSpline(wxList *points)
+
+class wxSpline: public wxObject
 {
-   // TODO
+public:
+    int type;
+    wxList *points;
+
+    wxSpline(wxList *list);
+    void DeletePoints();
+
+    // Doesn't delete points
+    ~wxSpline();
+};
+
+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();
+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::DoDrawSpline(wxList *list)
+{
+    wxSpline spline(list);
+
+    wx_draw_open_spline(this, &spline);
 }
-#endif
 
-//
-// Private functions
-//
-long wxDC::XDEV2LOG(long x) const
+wxList wx_spline_point_list;
+
+void wx_draw_open_spline(wxDC *dc, wxSpline *spline)
 {
-    long new_x = x - m_deviceOriginX;
-    if (new_x > 0)
-        return (long)((double)(new_x) / m_scaleX + 0.5) * m_signX + m_logicalOriginX;
-    else
-        return (long)((double)(new_x) / m_scaleX - 0.5) * m_signX + m_logicalOriginX;
+    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);
+
 }
 
-long wxDC::XDEV2LOGREL(long x) const
+/********************* 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)
 {
-    if (x > 0)
-        return (long)((double)(x) / m_scaleX + 0.5);
-    else
-        return (long)((double)(x) / m_scaleX - 0.5);
+    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);
+        }
+    }
 }
 
-long wxDC::YDEV2LOG(long y) const
+
+/* 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()
 {
-    long new_y = y - m_deviceOriginY;
-    if (new_y > 0)
-        return (long)((double)(new_y) / m_scaleY + 0.5) * m_signY + m_logicalOriginY;
-    else
-        return (long)((double)(new_y) / m_scaleY - 0.5) * m_signY + m_logicalOriginY;
+    wx_stack_top = wx_spline_stack;
+    wx_stack_count = 0;
 }
 
-long wxDC::YDEV2LOGREL(long y) const
+void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
 {
-    if (y > 0)
-        return (long)((double)(y) / m_scaleY + 0.5);
-    else
-        return (long)((double)(y) / m_scaleY - 0.5);
+    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++;
 }
 
-long wxDC::XLOG2DEV(long x) const
+int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
+                  double *x3, double *y3, double *x4, double *y4)
 {
-    long new_x = x - m_logicalOriginX;
-    if (new_x > 0)
-        return (long)((double)(new_x) * m_scaleX + 0.5) * m_signX + m_deviceOriginX;
-    else
-    return (long)((double)(new_x) * m_scaleX - 0.5) * m_signX + m_deviceOriginX;
+    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);
 }
 
-long wxDC::XLOG2DEVREL(long x) const
+static bool wx_spline_add_point(double x, double y)
 {
-    if (x > 0)
-        return (long)((double)(x) * m_scaleX + 0.5);
-    else
-        return (long)((double)(x) * m_scaleX - 0.5);
+    wxPoint *point = new wxPoint;
+    point->x = (int) x;
+    point->y = (int) y;
+    wx_spline_point_list.Append((wxObject*)point);
+    return TRUE;
 }
 
-long wxDC::YLOG2DEV(long y) const
+static void wx_spline_draw_point_array(wxDC *dc)
 {
-    long new_y = y - m_logicalOriginY;
-    if (new_y > 0)
-        return (long)((double)(new_y) * m_scaleY + 0.5) * m_signY + m_deviceOriginY;
-    else
-        return (long)((double)(new_y) * m_scaleY - 0.5) * m_signY + m_deviceOriginY;
+    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();
+    }
 }
 
-long wxDC::YLOG2DEVREL(long y) const
+wxSpline::wxSpline(wxList *list)
 {
-    if (y > 0)
-        return (long)((double)(y) * m_scaleY + 0.5);
-    else
-        return (long)((double)(y) * m_scaleY - 0.5);
+    points = list;
 }
 
-void wxDC::ComputeScaleAndOrigin(void)
+wxSpline::~wxSpline()
 {
-  // CMB: copy scale to see if it changes
-  double origScaleX = m_scaleX;
-  double origScaleY = m_scaleY;
+}
 
-  m_scaleX = m_logicalScaleX * m_userScaleX;
-  m_scaleY = m_logicalScaleY * m_userScaleY;
+void wxSpline::DeletePoints()
+{
+    for(wxNode *node = points->First(); node; node = points->First())
+    {
+        wxPoint *point = (wxPoint *)node->Data();
+        delete point;
+        delete node;
+    }
+    delete points;
+}
 
-  m_deviceOriginX = m_internalDeviceOriginX + m_externalDeviceOriginX;
-  m_deviceOriginY = m_internalDeviceOriginY + m_externalDeviceOriginY;
 
-  // CMB: if scale has changed call SetPen to recalulate the line width
-  if (m_scaleX != origScaleX || m_scaleY != origScaleY)
-  {
-    // this is a bit artificial, but we need to force wxDC to think
-    // the pen has changed
-    wxPen* pen = & GetPen();
-    wxPen tempPen;
-    m_pen = tempPen;
-    SetPen(* pen);
-  }
-};
+#endif // wxUSE_SPLINES