X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/0e320a79f187558effb04d92020b470372bbe456..399b60a0ad232265cd74ce8bf6a53a1f2cc57ff2:/src/os2/dc.cpp

diff --git a/src/os2/dc.cpp b/src/os2/dc.cpp
index 2c1c613595..05dbc01904 100644
--- a/src/os2/dc.cpp
+++ b/src/os2/dc.cpp
@@ -1,385 +1,857 @@
 /////////////////////////////////////////////////////////////////////////////
 // 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
-//-----------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+static const int VIEWPORT_EXTENT = 1000;
 
-#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 MM_POINTS = 9;
+static const int MM_METRIC = 10;
 
-//-----------------------------------------------------------------------------
+// ===========================================================================
+// implementation
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
 // wxDC
-//-----------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
 
 wxDC::wxDC(void)
 {
-  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;
+    m_canvas  = NULL;
+
+    m_oldBitmap  = 0;
+    m_oldPen     = 0;
+    m_oldBrush   = 0;
+    m_oldFont    = 0;
+    m_oldPalette = 0;
+
+    m_bOwnsDC = FALSE;
+    m_hDC        = 0;
+    m_hDCCount   = 0;
 };
 
 wxDC::~wxDC(void)
 {
-};
+    // TODO:
+};
+
+// 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_oldBitmap)
+        {
+//            ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);
+            if (m_selectedBitmap.Ok())
+            {
+                m_selectedBitmap.SetSelectedInto(NULL);
+            }
+        }
+        m_oldBitmap = 0;
+        if (m_oldPen)
+        {
+//            ::SelectObject((HDC) dc, (HPEN) m_oldPen);
+        }
+        m_oldPen = 0;
+        if (m_oldBrush)
+        {
+//            ::SelectObject((HDC) dc, (HBRUSH) m_oldBrush);
+        }
+        m_oldBrush = 0;
+        if (m_oldFont)
+        {
+//            ::SelectObject((HDC) dc, (HFONT) m_oldFont);
+        }
+        m_oldFont = 0;
+        if (m_oldPalette)
+        {
+//            ::SelectPalette((HDC) dc, (HPALETTE) m_oldPalette, TRUE);
+        }
+        m_oldPalette = 0;
+    }
+
+    m_brush = wxNullBrush;
+    m_pen = wxNullPen;
+    m_palette = wxNullPalette;
+    m_font = wxNullFont;
+    m_backgroundBrush = wxNullBrush;
+    m_selectedBitmap = wxNullBitmap;
+}
+
+// ---------------------------------------------------------------------------
+// clipping
+// ---------------------------------------------------------------------------
+
+void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
+{
+   // TODO
+}
+
+void wxDC::DoSetClippingRegion( wxCoord x, wxCoord y
+                               ,wxCoord width, wxCoord height
+                              )
+{
+   // TODO
+}
+
+void wxDC::DoClipping(WXHDC dc)
+{
+    if (m_clipping && dc)
+    {
+//      TODO:
+//      IntersectClipRect((HDC) dc, XLOG2DEV(m_clipX1), YLOG2DEV(m_clipY1),
+//                                  XLOG2DEV(m_clipX2), YLOG2DEV(m_clipY2));
+    }
+}
 
-void wxDC::DrawIcon( const wxIcon &WXUNUSED(icon), long WXUNUSED(x), long WXUNUSED(y), bool WXUNUSED(useMask) )
+void wxDC::DestroyClippingRegion(void)
 {
+    // TODO:
 };
 
-void wxDC::DrawPoint( wxPoint& point ) 
-{ 
-  DrawPoint( point.x, point.y ); 
-};
+// ---------------------------------------------------------------------------
+// query capabilities
+// ---------------------------------------------------------------------------
 
-void wxDC::DrawPolygon( wxList *list, long xoffset, long yoffset, int fillStyle )
+bool wxDC::CanDrawBitmap() const
 {
-  int n = list->Number();
-  wxPoint *points = new wxPoint[n];
+    return TRUE;
+}
 
-  int i = 0;
-  for( wxNode *node = list->First(); node; node = node->Next() )
-  {
-    wxPoint *point = (wxPoint *)node->Data();
-    points[i].x = point->x;
-    points[i++].y = point->y;
-  };
-  DrawPolygon( n, points, xoffset, yoffset, fillStyle );
-  delete[] points;
-};
+bool wxDC::CanGetTextExtent() const
+{
+    // What sort of display is it?
+    int technology = 0; // TODO:  ::GetDeviceCaps(GetHdc(), TECHNOLOGY);
+
+    // TODO: return (technology == DT_RASDISPLAY) || (technology == DT_RASPRINTER);
+    return FALSE;
+}
 
-void wxDC::DrawLines( wxList *list, long xoffset, long yoffset )
+int wxDC::GetDepth() const
 {
-  int n = list->Number();
-  wxPoint *points = new wxPoint[n];
+   // TODO:
+   return (1);
+}
 
-  int i = 0;
-  for( wxNode *node = list->First(); node; node = node->Next() ) 
-  {
-    wxPoint *point = (wxPoint *)node->Data();
-    points[i].x = point->x;
-    points[i++].y = point->y;
-  };
-  DrawLines( n, points, xoffset, yoffset );
-  delete []points;
-};
+// ---------------------------------------------------------------------------
+// drawing
+// ---------------------------------------------------------------------------
 
-void wxDC::DrawSpline( long x1, long y1, long x2, long y2, long x3, long y3 )
-{
-  wxList list;
-  list.Append( (wxObject*)new wxPoint(x1, y1) );
-  list.Append( (wxObject*)new wxPoint(x2, y2) );
-  list.Append( (wxObject*)new wxPoint(x3, y3) );
-  DrawSpline(&list);
-  wxNode *node = list.First();
-  while (node)
-  {
-    wxPoint *p = (wxPoint*)node->Data();
-    delete p;
-    node = node->Next();
-  };
-};
+void wxDC::Clear()
+{
+   // TODO
+}
 
-void wxDC::DrawSpline( int n, wxPoint points[] )
+void wxDC::DoFloodFill( wxCoord x
+                       ,wxCoord y
+                       ,const wxColour& col
+                       ,int style
+                      )
 {
-  wxList list;
-  for (int i = 0; i < n; i++) list.Append( (wxObject*)&points[i] );
-  DrawSpline( &list );
-};
+   // TODO
+}
 
-void wxDC::SetClippingRegion( long x, long y, long width, long height )
+bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
 {
-  m_clipping = TRUE;
-  m_clipX1 = x;
-  m_clipY1 = y;
-  m_clipX2 = x + width;
-  m_clipY2 = y + height;
-};
+   // TODO
+   return(TRUE);
+}
 
-void wxDC::DestroyClippingRegion(void)
+void wxDC::DoCrossHair(wxCoord x, wxCoord y)
 {
-  m_clipping = FALSE;
-};
+   // TODO
+}
 
-void wxDC::GetClippingBox( long *x, long *y, long *width, long *height ) const
-{
-  if (m_clipping)
-  {
-    if (x) *x = m_clipX1;
-    if (y) *y = m_clipY1;
-    if (width) *width = (m_clipX2 - m_clipX1);
-    if (height) *height = (m_clipY2 - m_clipY1);
-  }
-  else
-   *x = *y = *width = *height = 0;
-};
+void wxDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
+{
+   // TODO
+}
 
-void wxDC::GetSize( int* width, int* height ) const
+void wxDC::DoDrawArc( wxCoord x1, wxCoord y1
+                     ,wxCoord x2, wxCoord y2
+                     ,wxCoord xc, wxCoord yc
+                    )
 {
-  *width = m_maxX-m_minX;
-  *height = m_maxY-m_minY;
-};
+   // TODO
+}
 
-void wxDC::GetSizeMM( long* width, long* height ) const
+void wxDC::DoDrawPoint(wxCoord x, wxCoord y)
 {
-  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
+}
 
-void wxDC::SetTextForeground( const wxColour &col )
+void wxDC::DoDrawPolygon(int n, wxPoint points[]
+                         ,wxCoord xoffset, wxCoord yoffset
+                         ,int fillStyle
+                        )
 {
-  if (!Ok()) return;
-  m_textForegroundColour = col;
-};
+   // TODO
+}
 
-void wxDC::SetTextBackground( const wxColour &col )
+void wxDC::DoDrawLines( int n, wxPoint points[]
+                       ,wxCoord xoffset, wxCoord yoffset
+                      )
 {
-  if (!Ok()) return;
-  m_textBackgroundColour = col;
-};
+   // TODO
+}
 
-void wxDC::SetMapMode( int mode )
+void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+{
+   // TODO
+}
+
+void wxDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y
+                                  ,wxCoord width, wxCoord height
+                                  ,double radius
+                                 )
+{
+   // TODO
+}
+
+void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+{
+   // TODO
+}
+
+void wxDC::DoDrawEllipticArc( wxCoord x
+                             ,wxCoord y
+                             ,wxCoord w
+                             ,wxCoord h
+                             ,double sa
+                             ,double ea
+                            )
+{
+   // TODO
+}
+
+void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
+{
+   // TODO
+}
+
+void wxDC::DoDrawBitmap( const wxBitmap &bmp
+                        ,wxCoord x, wxCoord y
+                        ,bool useMask
+                       )
 {
-  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;
+   // TODO
+}
+
+void wxDC::DoDrawText(const wxString& text, wxCoord x, wxCoord y)
+{
+   // TODO
+}
+
+void wxDC::DoDrawRotatedText(const wxString& text,
+                             wxCoord x, wxCoord y,
+                             double angle)
+{
+   // 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::SetPalette(const wxPalette& palette)
+{
+   // TODO
+}
+
+void wxDC::SetFont(const wxFont& font)
+{
+   // TODO
+}
+
+void wxDC::SetPen(const wxPen& pen)
+{
+   // TODO
+}
+void wxDC::SetBrush(const wxBrush& brush)
+{
+   // TODO
+}
+
+void wxDC::SetBackground(const wxBrush& brush)
+{
+   // TODO
+}
+
+void wxDC::SetBackgroundMode(int mode)
+{
+   // TODO
+}
+
+void wxDC::SetLogicalFunction(int function)
+{
+   // TODO
+}
+
+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:
-    case wxMM_TEXT:
-      SetLogicalScale( 1.0, 1.0 );
-      break;
-  };
-  if (mode != wxMM_TEXT)
-  {
-    m_needComputeScaleX = TRUE;
-    m_needComputeScaleY = TRUE;
-  };
-};
+//      c_rop = R2_COPYPEN;
+        break;
+    }
+//    SetROP2((HDC) dc, c_rop);
+}
 
-void wxDC::SetUserScale( double x, double y )
+bool wxDC::StartDoc(const wxString& message)
 {
-  // allow negative ? -> no
-  m_userScaleX = x;
-  m_userScaleY = y;
-  ComputeScaleAndOrigin();
-};
+    // We might be previewing, so return TRUE to let it continue.
+    return TRUE;
+}
 
-void wxDC::GetUserScale( double *x, double *y )
+void wxDC::EndDoc()
 {
-  if (x) *x = m_userScaleX;
-  if (y) *y = m_userScaleY;
-};
+}
 
-void wxDC::SetLogicalScale( double x, double y )
+void wxDC::StartPage()
 {
-  // allow negative ?
-  m_logicalScaleX = x;
-  m_logicalScaleY = y;
-  ComputeScaleAndOrigin();
-};
+}
 
-void wxDC::GetLogicalScale( double *x, double *y )
+void wxDC::EndPage()
 {
-  if (x) *x = m_logicalScaleX;
-  if (y) *y = m_logicalScaleY;
-};
+}
 
-void wxDC::SetLogicalOrigin( long x, long y )
+// ---------------------------------------------------------------------------
+// text metrics
+// ---------------------------------------------------------------------------
+
+wxCoord wxDC::GetCharHeight() const
 {
-  m_logicalOriginX = x * m_signX;   // is this still correct ?
-  m_logicalOriginY = y * m_signY;
-  ComputeScaleAndOrigin();
-};
+    // TODO
+    return(1);
+}
 
-void wxDC::GetLogicalOrigin( long *x, long *y )
+wxCoord wxDC::GetCharWidth() const
 {
-  if (x) *x = m_logicalOriginX;
-  if (y) *y = m_logicalOriginY;
-};
+    // TODO
+    return(1);
+}
 
-void wxDC::SetDeviceOrigin( long x, long y )
+void wxDC::DoGetTextExtent( const wxString& string
+                           ,wxCoord* x
+                           ,wxCoord* y
+                           ,wxCoord* decent
+                           ,wxCoord* externalLeading
+                           ,wxFont* theFont
+                          ) const
 {
-  m_externalDeviceOriginX = x;
-  m_externalDeviceOriginY = y;
-  ComputeScaleAndOrigin();
+   // TODO:
+}
+
+void wxDC::SetMapMode( int mode )
+{
+    // TODO:
 };
 
-void wxDC::GetDeviceOrigin( long *x, long *y )
+void wxDC::SetUserScale(double x, double y)
+{
+    m_userScaleX = x;
+    m_userScaleY = y;
+
+    SetMapMode(m_mappingMode);
+}
+
+void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
 {
-//  if (x) *x = m_externalDeviceOriginX;
-//  if (y) *y = m_externalDeviceOriginY;
-  if (x) *x = m_deviceOriginX;
-  if (y) *y = m_deviceOriginY;
+    m_signX = xLeftRight ? 1 : -1;
+    m_signY = yBottomUp ? -1 : 1;
+
+    SetMapMode(m_mappingMode);
+}
+
+void wxDC::SetSystemScale(double x, double y)
+{
+    m_scaleX = x;
+    m_scaleY = y;
+
+    SetMapMode(m_mappingMode);
+}
+
+void wxDC::SetLogicalOrigin( wxCoord x, wxCoord y )
+{
+    // TODO:
 };
 
-void wxDC::SetInternalDeviceOrigin( long x, long y )
+void wxDC::SetDeviceOrigin( wxCoord x, wxCoord y )
 {
-  m_internalDeviceOriginX = x;
-  m_internalDeviceOriginY = y;
-  ComputeScaleAndOrigin();
+    // TODO:
 };
 
-void wxDC::GetInternalDeviceOrigin( long *x, long *y )
+// ---------------------------------------------------------------------------
+// coordinates transformations
+// ---------------------------------------------------------------------------
+
+wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
 {
-  if (x) *x = m_internalDeviceOriginX;
-  if (y) *y = m_internalDeviceOriginY;
+    wxCoord new_x = x - m_deviceOriginX;
+    if (new_x > 0)
+        return (wxCoord)((double)(new_x) / m_scaleX + 0.5) * m_signX + m_logicalOriginX;
+    else
+        return (wxCoord)((double)(new_x) / m_scaleX - 0.5) * m_signX + m_logicalOriginX;
 };
 
-void wxDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
+wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
 {
-  m_signX = (xLeftRight ?  1 : -1);
-  m_signY = (yBottomUp  ? -1 :  1);
-  ComputeScaleAndOrigin();
+    if (x > 0)
+        return (wxCoord)((double)(x) / m_scaleX + 0.5);
+    else
+        return (wxCoord)((double)(x) / m_scaleX - 0.5);
 };
 
-long wxDC::DeviceToLogicalX(long x) const
+wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
 {
-  return XDEV2LOG(x);
+    wxCoord new_y = y - m_deviceOriginY;
+    if (new_y > 0)
+        return (wxCoord)((double)(new_y) / m_scaleY + 0.5) * m_signY + m_logicalOriginY;
+    else
+        return (wxCoord)((double)(new_y) / m_scaleY - 0.5) * m_signY + m_logicalOriginY;
 };
 
-long wxDC::DeviceToLogicalY(long y) const
+wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
 {
-  return YDEV2LOG(y);
+    if (y > 0)
+        return (wxCoord)((double)(y) / m_scaleY + 0.5);
+    else
+        return (wxCoord)((double)(y) / m_scaleY - 0.5);
 };
 
-long wxDC::DeviceToLogicalXRel(long x) const
+wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
 {
-  return XDEV2LOGREL(x);
+    wxCoord new_x = x - m_logicalOriginX;
+    if (new_x > 0)
+        return (wxCoord)((double)(new_x) * m_scaleX + 0.5) * m_signX + m_deviceOriginX;
+    else
+    return (wxCoord)((double)(new_x) * m_scaleX - 0.5) * m_signX + m_deviceOriginX;
 };
 
-long wxDC::DeviceToLogicalYRel(long y) const
+wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
 {
-  return YDEV2LOGREL(y);
+    if (x > 0)
+        return (wxCoord)((double)(x) * m_scaleX + 0.5);
+    else
+        return (wxCoord)((double)(x) * m_scaleX - 0.5);
 };
 
-long wxDC::LogicalToDeviceX(long x) const
+wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
 {
-  return XLOG2DEV(x);
+    wxCoord new_y = y - m_logicalOriginY;
+    if (new_y > 0)
+        return (wxCoord)((double)(new_y) * m_scaleY + 0.5) * m_signY + m_deviceOriginY;
+    else
+        return (wxCoord)((double)(new_y) * m_scaleY - 0.5) * m_signY + m_deviceOriginY;
 };
 
-long wxDC::LogicalToDeviceY(long y) const
+wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
 {
-  return YLOG2DEV(y);
+    if (y > 0)
+        return (wxCoord)((double)(y) * m_scaleY + 0.5);
+    else
+        return (wxCoord)((double)(y) * m_scaleY - 0.5);
 };
 
-long wxDC::LogicalToDeviceXRel(long x) const
+// ---------------------------------------------------------------------------
+// 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::DoGetSize( int* width, int* height ) const
 {
-  return XLOG2DEVREL(x);
+    // TODO:
 };
 
-long wxDC::LogicalToDeviceYRel(long y) const
+void wxDC::DoGetSizeMM( int* width, int* height ) const
 {
-  return YLOG2DEVREL(y);
+    // TODO:
 };
-    
-void wxDC::CalcBoundingBox( long x, long y )
+
+wxSize wxDC::GetPPI() const
+{
+   int x = 1;
+   int y = 1;
+   // TODO:
+   return (wxSize(x,y));
+}
+
+void wxDC::SetLogicalScale( double x, double y )
 {
-  if (x < m_minX) m_minX = x;
-  if (y < m_minY) m_minY = y;
-  if (x > m_maxX) m_maxX = x;
-  if (y > m_maxY) m_maxY = y;
+    // TODO:
 };
 
-void wxDC::ComputeScaleAndOrigin(void)
+#if WXWIN_COMPATIBILITY
+void wxDC::DoGetTextExtent(const wxString& string, float *x, float *y,
+                         float *descent, float *externalLeading,
+                         wxFont *theFont, bool use16bit) const
 {
-  // CMB: copy scale to see if it changes
-  double origScaleX = m_scaleX;
-  double origScaleY = m_scaleY;
+    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
 
-  m_scaleX = m_logicalScaleX * m_userScaleX;
-  m_scaleY = m_logicalScaleY * m_userScaleY;
+// ---------------------------------------------------------------------------
+// spline drawing code
+// ---------------------------------------------------------------------------
 
-  m_deviceOriginX = m_internalDeviceOriginX + m_externalDeviceOriginX;
-  m_deviceOriginY = m_internalDeviceOriginY + m_externalDeviceOriginY;
+#if wxUSE_SPLINES
 
-  // 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);
-  }
+class wxSpline: public wxObject
+{
+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);
+}
+
+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()
+{
+    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 wxSpline::DeletePoints()
+{
+    for(wxNode *node = points->First(); node; node = points->First())
+    {
+        wxPoint *point = (wxPoint *)node->Data();
+        delete point;
+        delete node;
+    }
+    delete points;
+}
+
+
+#endif // wxUSE_SPLINES
+