ok, it does work - it's just that wxGTK doesn't

[wxWidgets.git] / src / os2 / dc.cpp

diff --git a/src/os2/dc.cpp b/src/os2/dc.cpp
index 8983710b325038683f759ba39ccb5eeab09328c1..5ddf11b13b7a53488142ebf7ad1128c67d3d74f8 100644 (file)
--- a/src/os2/dc.cpp
+++ b/src/os2/dc.cpp
@@ -31,9 +31,7 @@
 
 #include "wx/os2/private.h"
 
 
 #include "wx/os2/private.h"
 

-#if !USE_SHARED_LIBRARY

     IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
     IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)

-#endif

 
 // ---------------------------------------------------------------------------
 // constants
 
 // ---------------------------------------------------------------------------
 // constants


@@ -44,6 +42,87 @@ static const int VIEWPORT_EXTENT = 1000;
 static const int MM_POINTS = 9;
 static const int MM_METRIC = 10;
 
 static const int MM_POINTS = 9;
 static const int MM_METRIC = 10;
 

+// usually this is defined in math.h
+#ifndef M_PI
+    static const double M_PI = 3.14159265358979323846;
+#endif // M_PI
+
+// ---------------------------------------------------------------------------
+// private functions
+// ---------------------------------------------------------------------------
+
+// convert degrees to radians
+static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
+
+int SetTextColor(
+  HPS                               hPS
+, int                               nForegroundColour
+)
+{
+    CHARBUNDLE                      vCbnd;
+
+    vCbnd.lColor =  nForegroundColour;
+    ::GpiSetAttrs( hPS       // presentation-space handle
+                  ,PRIM_CHAR // Char primitive.
+                  ,CBB_COLOR // sets color.
+                  ,0         //
+                  ,&vCbnd    // buffer for attributes.
+                 );
+    return 0;
+}
+
+int QueryTextBkColor(
+  HPS                               hPS
+)
+{
+    CHARBUNDLE                      vCbnd;
+
+    ::GpiQueryAttrs( hPS            // presentation-space handle
+                    ,PRIM_CHAR      // Char primitive.
+                    ,CBB_BACK_COLOR // Background color.
+                    ,&vCbnd         // buffer for attributes.
+                   );
+    return vCbnd.lBackColor;
+}
+
+
+int SetTextBkColor(
+  HPS                               hPS
+, int                               nBackgroundColour
+)
+{
+    CHARBUNDLE                      vCbnd;
+    int                             rc;
+
+    rc =  QueryTextBkColor(hPS);
+
+    vCbnd.lBackColor = nBackgroundColour;
+    ::GpiSetAttrs(hPS,            // presentation-space handle
+                  PRIM_CHAR,      // Char primitive.
+                  CBB_BACK_COLOR, // sets color.
+                  0,
+                  &vCbnd          // buffer for attributes.
+                 );
+    return rc;
+}
+
+int SetBkMode(
+  HPS                               hPS
+, int                               nBackgroundMode
+)
+{
+    if(nBackgroundMode == wxTRANSPARENT)
+        ::GpiSetBackMix( hPS
+                        ,BM_LEAVEALONE
+                       );
+    else
+        // the background of the primitive takes  over whatever is underneath.
+        ::GpiSetBackMix( hPS
+                        ,BM_OVERPAINT
+                        );
+    return 0;
+}
+

 // ===========================================================================
 // implementation
 // ===========================================================================
 // ===========================================================================
 // implementation
 // ===========================================================================


@@ -54,17 +133,20 @@ static const int MM_METRIC = 10;
 
 wxDC::wxDC(void)
 {
 
 wxDC::wxDC(void)
 {

-    m_canvas  = NULL;
+    m_pCanvas      = NULL;

 
 

-    m_oldBitmap  = 0;
-    m_oldPen     = 0;
-    m_oldBrush   = 0;
-    m_oldFont    = 0;
-    m_oldPalette = 0;
+    m_hOldBitmap   = 0;
+    m_hOldPen      = 0;
+    m_hOldBrush    = 0;
+    m_hOldFont     = 0;
+    m_hOldPalette  = 0;

 
 

-    m_bOwnsDC = FALSE;
-    m_hDC        = 0;
-    m_hDCCount   = 0;
+    m_bOwnsDC      = FALSE;
+    m_hDC          = 0;
+    m_nDCCount     = 0;
+    m_hOldPS       = NULL;
+    m_hPS          = NULL;
+    m_bIsPaintTime = FALSE;// True at Paint Time

 };
 
 wxDC::~wxDC(void)
 };
 
 wxDC::~wxDC(void)


@@ -79,52 +161,59 @@ void wxDC::SelectOldObjects(WXHDC dc)
 {
     if (dc)
     {
 {
     if (dc)
     {

-        if (m_oldBitmap)
+        if (m_hOldBitmap)

         {
 //            ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);
         {
 //            ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);

-            if (m_selectedBitmap.Ok())
+            if (m_vSelectedBitmap.Ok())

             {
             {

-                m_selectedBitmap.SetSelectedInto(NULL);
+                m_vSelectedBitmap.SetSelectedInto(NULL);

             }
         }
             }
         }

-        m_oldBitmap = 0;
-        if (m_oldPen)
+        m_hOldBitmap = 0;
+        if (m_hOldPen)

         {
 //            ::SelectObject((HDC) dc, (HPEN) m_oldPen);
         }
         {
 //            ::SelectObject((HDC) dc, (HPEN) m_oldPen);
         }

-        m_oldPen = 0;
-        if (m_oldBrush)
+        m_hOldPen = 0;
+        if (m_hOldBrush)

         {
 //            ::SelectObject((HDC) dc, (HBRUSH) m_oldBrush);
         }
         {
 //            ::SelectObject((HDC) dc, (HBRUSH) m_oldBrush);
         }

-        m_oldBrush = 0;
-        if (m_oldFont)
+        m_hOldBrush = 0;
+        if (m_hOldFont)

         {
 //            ::SelectObject((HDC) dc, (HFONT) m_oldFont);
         }
         {
 //            ::SelectObject((HDC) dc, (HFONT) m_oldFont);
         }

-        m_oldFont = 0;
-        if (m_oldPalette)
+        m_hOldFont = 0;
+        if (m_hOldPalette)

         {
 //            ::SelectPalette((HDC) dc, (HPALETTE) m_oldPalette, TRUE);
         }
         {
 //            ::SelectPalette((HDC) dc, (HPALETTE) m_oldPalette, TRUE);
         }

-        m_oldPalette = 0;
+        m_hOldPalette = 0;

     }
 
     }
 

-    m_brush = wxNullBrush;
-    m_pen = wxNullPen;
-    m_palette = wxNullPalette;
-    m_font = wxNullFont;
+    m_brush           = wxNullBrush;
+    m_pen             = wxNullPen;
+    m_palette         = wxNullPalette;
+    m_font            = wxNullFont;

     m_backgroundBrush = wxNullBrush;
     m_backgroundBrush = wxNullBrush;

-    m_selectedBitmap = wxNullBitmap;
+    m_vSelectedBitmap = wxNullBitmap;

 }
 
 // ---------------------------------------------------------------------------
 // clipping
 // ---------------------------------------------------------------------------
 
 }
 
 // ---------------------------------------------------------------------------
 // clipping
 // ---------------------------------------------------------------------------
 

-void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
-{
-   // TODO
+#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
 }
 
 void wxDC::DoSetClippingRegion( wxCoord x, wxCoord y


@@ -134,14 +223,9 @@ void wxDC::DoSetClippingRegion( wxCoord x, wxCoord y
    // TODO
 }
 
    // TODO
 }
 

-void wxDC::DoClipping(WXHDC dc)
+void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)

 {
 {

-    if (m_clipping && dc)
-    {
-//      TODO:
-//      IntersectClipRect((HDC) dc, XLOG2DEV(m_clipX1), YLOG2DEV(m_clipY1),
-//                                  XLOG2DEV(m_clipX2), YLOG2DEV(m_clipY2));
-    }
+   // TODO

 }
 
 void wxDC::DestroyClippingRegion(void)
 }
 
 void wxDC::DestroyClippingRegion(void)


@@ -202,9 +286,22 @@ void wxDC::DoCrossHair(wxCoord x, wxCoord y)
    // TODO
 }
 
    // TODO
 }
 

-void wxDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
-{
-   // TODO
+void wxDC::DoDrawLine(
+  wxCoord                           vX1
+, wxCoord                           vY1
+, wxCoord                           vX2
+, wxCoord                           vY2
+)
+{
+    POINTL                          vPoint[2];
+
+    vPoint[0].x = vX1;
+    vPoint[0].y = vY1;
+    vPoint[1].x = vX2;
+    vPoint[1].y = vY2;
+    // ::GpiSetColor(m_hPS,CLR_RED); //DEbug
+    ::GpiMove(m_hPS, &vPoint[0]);
+    ::GpiLine(m_hPS, &vPoint[1]);

 }
 
 void wxDC::DoDrawArc( wxCoord x1, wxCoord y1
 }
 
 void wxDC::DoDrawArc( wxCoord x1, wxCoord y1


@@ -215,6 +312,12 @@ void wxDC::DoDrawArc( wxCoord x1, wxCoord y1
    // TODO
 }
 
    // TODO
 }
 

+void wxDC::DoDrawCheckMark(wxCoord x1, wxCoord y1,
+                           wxCoord width, wxCoord height)
+{
+    // TODO
+}
+

 void wxDC::DoDrawPoint(wxCoord x, wxCoord y)
 {
    // TODO
 void wxDC::DoDrawPoint(wxCoord x, wxCoord y)
 {
    // TODO


@@ -235,17 +338,51 @@ void wxDC::DoDrawLines( int n, wxPoint points[]
    // TODO
 }
 
    // TODO
 }
 

-void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
-{
-   // TODO
+void wxDC::DoDrawRectangle(
+  wxCoord                           vX
+, wxCoord                           vY
+, wxCoord                           vWidth
+, wxCoord                           vHeight
+)
+{
+    POINTL                          vPoint[2];
+
+    vPoint[0].x = vX;
+    vPoint[0].y = vY;
+    vPoint[1].x = vX + vWidth;
+    vPoint[1].y = vY - vHeight;      //mustdie !!! ??
+
+    ::GpiMove(m_hPS, &vPoint[0]);
+    ::GpiBox( m_hPS       // handle to a presentation space
+             ,DRO_OUTLINE // draw the box outline ? or ?
+             ,&vPoint[1]  // address of the corner
+             ,0L          // horizontal corner radius
+             ,0L          // vertical corner radius
+            );

 }
 
 }
 

-void wxDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y
-                                  ,wxCoord width, wxCoord height
-                                  ,double radius
-                                 )
-{
-   // TODO
+void wxDC::DoDrawRoundedRectangle(
+  wxCoord                           vX
+, wxCoord                           vY
+, wxCoord                           vWidth
+, wxCoord                           vHeight
+, double                            dRadius
+)
+{
+    POINTL                          vPoint[2];
+
+    vPoint[0].x = vX;
+    vPoint[0].y = vY;
+    vPoint[1].x = vX + vWidth;
+    vPoint[1].y = vY + vHeight;      //or -height aka mustdie !!! ??
+
+    ::GpiMove(m_hPS, &vPoint[0]);
+    ::GpiBox( m_hPS         // handle to a presentation space
+             ,DRO_OUTLINE   // draw the box outline ? or ?
+             ,&vPoint[1]    // address of the corner
+             ,(LONG)dRadius // horizontal corner radius
+             ,(LONG)dRadius // vertical corner radius
+            );

 }
 
 void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 }
 
 void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)


@@ -277,15 +414,93 @@ void wxDC::DoDrawBitmap( const wxBitmap &bmp
    // TODO
 }
 
    // TODO
 }
 

-void wxDC::DoDrawText(const wxString& text, wxCoord x, wxCoord y)
+void wxDC::DoDrawText(
+  const wxString&                   rsText
+, wxCoord                           vX
+, wxCoord                           vY
+)

 {
 {

-   // TODO
+    DrawAnyText( rsText
+                ,vX
+                ,vY
+               );

 }
 
 }
 

-void wxDC::DoDrawRotatedText(const wxString& text,
-                             wxCoord x, wxCoord y,
-                             double angle)
+void wxDC::DrawAnyText(
+  const wxString&                   rsText
+, wxCoord                           vX
+, wxCoord                           vY
+)

 {
 {

+    int                             nOldBackground = 0;
+    POINTL                          vPtlStart;
+    LONG                            lHits;
+
+    //
+    // prepare for drawing the text
+    //
+
+    //
+    // Set text color attributes
+    //
+    if (m_textForegroundColour.Ok())
+    {
+        SetTextColor( m_hPS
+                     ,(int)m_textForegroundColour.GetPixel()
+                    );
+    }
+
+    if (m_textBackgroundColour.Ok())
+    {
+        nOldBackground = SetTextBkColor( m_hPS
+                                        ,(int)m_textBackgroundColour.GetPixel()
+                                       );
+    }
+    SetBkMode( m_hPS
+              ,m_backgroundMode
+             );
+    vPtlStart.x = vX;
+    vPtlStart.y = vY;
+
+    lHits = ::GpiCharStringAt( m_hPS
+                              ,&vPtlStart
+                              ,rsText.length()
+                              ,(PCH)rsText.c_str()
+                             );
+    if (lHits != GPI_OK)
+    {
+        wxLogLastError(wxT("TextOut"));
+    }
+
+    //
+    // Restore the old parameters (text foreground colour may be left because
+    // it never is set to anything else, but background should remain
+    // transparent even if we just drew an opaque string)
+    //
+    if (m_textBackgroundColour.Ok())
+            SetTextBkColor( m_hPS
+                           ,nOldBackground
+                          );
+    SetBkMode( m_hPS
+              ,wxTRANSPARENT
+             );
+}
+
+void wxDC::DoDrawRotatedText(
+  const wxString&                   rsText
+, wxCoord                           vX
+, wxCoord                           vY
+, double                            dAngle
+)
+{
+    if (dAngle == 0.0)
+    {
+        DoDrawText( rsText
+                   ,vX
+                   ,vY
+                  );
+    }
+

    // TODO:
    /*
     if ( angle == 0.0 )
    // TODO:
    /*
     if ( angle == 0.0 )


@@ -347,15 +562,74 @@ void wxDC::SetPalette(const wxPalette& palette)
    // TODO
 }
 
    // TODO
 }
 

-void wxDC::SetFont(const wxFont& font)
+void wxDC::SetFont(
+  const wxFont&                     rFont
+)

 {
 {

-   // TODO
+    //
+    // 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)
+void wxDC::SetPen(
+  const wxPen&                      rPen
+)

 {
 {

-   // TODO
+    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+
+    if (m_pen == rPen)
+        return;
+    m_pen = rPen;
+    if (!m_pen.Ok())
+        return;
+
+    int                             nWidth = m_pen.GetWidth();
+
+    if (nWidth <= 0)
+    {
+        nWidth = 1;
+    }
+    else
+    {
+        double                      dW = 0.5 +
+                                       ( fabs((double) XLOG2DEVREL(nWidth)) +
+                                         fabs((double) YLOG2DEVREL(nWidth))
+                                       ) / 2.0;
+        nWidth = (int)dW;
+    }
+    wxColour                        vColor = m_pen.GetColour();
+
+    ::GpiSetColor( m_hPS
+                  ,vColor.GetPixel()
+                 ); //DEbug ??

 }
 }

+

 void wxDC::SetBrush(const wxBrush& brush)
 {
    // TODO
 void wxDC::SetBrush(const wxBrush& brush)
 {
    // TODO


@@ -366,9 +640,11 @@ void wxDC::SetBackground(const wxBrush& brush)
    // TODO
 }
 
    // TODO
 }
 

-void wxDC::SetBackgroundMode(int mode)
+void wxDC::SetBackgroundMode(
+  int                               nMode
+)

 {
 {

-   // TODO
+    m_backgroundMode = nMode;

 }
 
 void wxDC::SetLogicalFunction(int function)
 }
 
 void wxDC::SetLogicalFunction(int function)


@@ -433,24 +709,78 @@ void wxDC::EndPage()
 wxCoord wxDC::GetCharHeight() const
 {
     // TODO
 wxCoord wxDC::GetCharHeight() const
 {
     // TODO

-    return(1);
+    return(8);

 }
 
 wxCoord wxDC::GetCharWidth() const
 {
     // TODO
 }
 
 wxCoord wxDC::GetCharWidth() const
 {
     // TODO

-    return(1);
+    return(8);

 }
 
 }
 

-void wxDC::DoGetTextExtent( const wxString& string
-                           ,wxCoord* x
-                           ,wxCoord* y
-                           ,wxCoord* decent
-                           ,wxCoord* externalLeading
-                           ,wxFont* theFont
-                          ) const
-{
-   // TODO:
+void wxDC::DoGetTextExtent(
+  const wxString&                   rsString
+, wxCoord*                          pvX
+, wxCoord*                          pvY
+, wxCoord*                          pvDescent
+, wxCoord*                          pvExternalLeading
+, wxFont*                           pTheFont
+) const
+{
+    POINTL                          avPoint[TXTBOX_COUNT];
+    POINTL                          vPtMin;
+    POINTL                          vPtMax;
+    int                             i;
+    int                             l;
+    FONTMETRICS                     vFM; // metrics structure
+    BOOL                            bRc;
+    char*                           pStr;
+    ERRORID                         vErrorCode; // last error id code
+    wxFont*                         pFontToUse = (wxFont*)pTheFont;
+
+    if (!pFontToUse)
+        pFontToUse = (wxFont*)&m_font;
+    l = rsString.length();
+    pStr = (PCH) rsString.c_str();
+
+    //
+    // In world coordinates.
+    //
+    bRc = ::GpiQueryTextBox( m_hPS
+                            ,l
+                            ,pStr
+                            ,TXTBOX_COUNT // return maximum information
+                            ,avPoint      // array of coordinates points
+                           );
+    if(!bRc)
+    {
+       vErrorCode = ::WinGetLastError(wxGetInstance());
+    }
+
+    vPtMin.x = avPoint[0].x;
+    vPtMax.x = avPoint[0].x;
+    vPtMin.y = avPoint[0].y;
+    vPtMax.y = avPoint[0].y;
+    for (i = 1; i < 4; i++)
+    {
+        if(vPtMin.x > avPoint[i].x) vPtMin.x = avPoint[i].x;
+        if(vPtMin.y > avPoint[i].y) vPtMin.y = avPoint[i].y;
+        if(vPtMax.x < avPoint[i].x) vPtMax.x = avPoint[i].x;
+        if(vPtMax.y < avPoint[i].y) vPtMax.y = avPoint[i].y;
+    }
+    ::GpiQueryFontMetrics( m_hPS
+                          ,sizeof(FONTMETRICS)
+                          ,&vFM
+                         );
+
+    if (pvX)
+        *pvX = (wxCoord)(vPtMax.x - vPtMin.x + 1);
+    if (pvY)
+        *pvY = (wxCoord)(vPtMax.y - vPtMin.y + 1);
+    if (pvDescent)
+        *pvDescent = vFM.lMaxDescender;
+    if (pvExternalLeading)
+        *pvExternalLeading = vFM.lExternalLeading;

 }
 
 void wxDC::SetMapMode( int mode )
 }
 
 void wxDC::SetMapMode( int mode )


@@ -498,71 +828,43 @@ void wxDC::SetDeviceOrigin( wxCoord x, wxCoord y )
 
 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
 {
 
 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
 {

-    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;
-};
+    return (wxCoord) (((x) - m_deviceOriginX)/(m_logicalScaleX*m_userScaleX*m_signX*m_scaleX) - m_logicalOriginX);
+}

 
 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
 {
 
 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
 {

-    if (x > 0)
-        return (wxCoord)((double)(x) / m_scaleX + 0.5);
-    else
-        return (wxCoord)((double)(x) / m_scaleX - 0.5);
-};
+    return (wxCoord) ((x)/(m_logicalScaleX*m_userScaleX*m_signX*m_scaleX));
+}

 
 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
 {
 
 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
 {

-    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;
-};
+    return (wxCoord) (((y) - m_deviceOriginY)/(m_logicalScaleY*m_userScaleY*m_signY*m_scaleY) - m_logicalOriginY);
+}

 
 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
 {
 
 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
 {

-    if (y > 0)
-        return (wxCoord)((double)(y) / m_scaleY + 0.5);
-    else
-        return (wxCoord)((double)(y) / m_scaleY - 0.5);
-};
+    return (wxCoord) ((y)/(m_logicalScaleY*m_userScaleY*m_signY*m_scaleY));
+}

 
 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
 {
 
 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
 {

-    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;
-};
+    return (wxCoord) ((x - m_logicalOriginX)*m_logicalScaleX*m_userScaleX*m_signX*m_scaleX + m_deviceOriginX);
+}

 
 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
 {
 
 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
 {

-    if (x > 0)
-        return (wxCoord)((double)(x) * m_scaleX + 0.5);
-    else
-        return (wxCoord)((double)(x) * m_scaleX - 0.5);
-};
+    return (wxCoord) (x*m_logicalScaleX*m_userScaleX*m_signX*m_scaleX);
+}

 
 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
 {
 
 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
 {

-    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;
-};
+    return (wxCoord) ((y - m_logicalOriginY)*m_logicalScaleY*m_userScaleY*m_signY*m_scaleY + m_deviceOriginY);
+}

 
 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
 {
 
 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
 {

-    if (y > 0)
-        return (wxCoord)((double)(y) * m_scaleY + 0.5);
-    else
-        return (wxCoord)((double)(y) * m_scaleY - 0.5);
-};
+    return (wxCoord) (y*m_logicalScaleY*m_userScaleY*m_signY*m_scaleY);
+}

 
 // ---------------------------------------------------------------------------
 // bit blit
 
 // ---------------------------------------------------------------------------
 // bit blit