]> git.saurik.com Git - wxWidgets.git/blobdiff - src/os2/dc.cpp
Add missing WXK constants for the control keys
[wxWidgets.git] / src / os2 / dc.cpp
index 2347161e0e38be1378c0f3e75ebfe47de1c3bdbc..b13314253a08739cc580bd976af32dcbd8269941 100644 (file)
 
 #include <string.h>
 
+#include "wx/os2/dc.h"
+#include "wx/os2/dcclient.h"
 #include "wx/os2/private.h"
 
-IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
+IMPLEMENT_ABSTRACT_CLASS(wxPMDCImpl, wxDCImpl)
 
 //
 // wxWidgets uses the Microsoft convention that the origin is the UPPER left.
@@ -156,8 +158,8 @@ int SetBkMode(
 // wxDCCacheEntry
 // ---------------------------------------------------------------------------
 
-wxList wxDC::m_svBitmapCache;
-wxList wxDC::m_svDCCache;
+wxList wxPMDCImpl::m_svBitmapCache;
+wxList wxPMDCImpl::m_svDCCache;
 
 wxDCCacheEntry::wxDCCacheEntry(
   WXHBITMAP                         hBitmap
@@ -193,7 +195,7 @@ wxDCCacheEntry::~wxDCCacheEntry()
         ::GpiDestroyPS(m_hPS);
 } // end of wxDCCacheEntry::~wxDCCacheEntry
 
-wxDCCacheEntry* wxDC::FindBitmapInCache(
+wxDCCacheEntry* wxPMDCImpl::FindBitmapInCache(
   HPS                               hPS
 , int                               nWidth
 , int                               nHeight
@@ -260,7 +262,7 @@ wxDCCacheEntry* wxDC::FindBitmapInCache(
     return pEntry;
 } // end of FindBitmapInCache
 
-wxDCCacheEntry* wxDC::FindDCInCache(
+wxDCCacheEntry* wxPMDCImpl::FindDCInCache(
   wxDCCacheEntry*                   pNotThis
 , HPS                               hPS
 )
@@ -289,23 +291,23 @@ wxDCCacheEntry* wxDC::FindDCInCache(
                                                                );
     AddToDCCache(pEntry);
     return pEntry;
-} // end of wxDC::FindDCInCache
+} // end of wxPMDCImpl::FindDCInCache
 
-void wxDC::AddToBitmapCache(
+void wxPMDCImpl::AddToBitmapCache(
   wxDCCacheEntry*                   pEntry
 )
 {
     m_svBitmapCache.Append(pEntry);
-} // end of wxDC::AddToBitmapCache
+} // end of wxPMDCImpl::AddToBitmapCache
 
-void wxDC::AddToDCCache(
+void wxPMDCImpl::AddToDCCache(
   wxDCCacheEntry*                   pEntry
 )
 {
     m_svDCCache.Append(pEntry);
-} // end of wxDC::AddToDCCache
+} // end of wxPMDCImpl::AddToDCCache
 
-void wxDC::ClearCache()
+void wxPMDCImpl::ClearCache()
 {
     m_svBitmapCache.DeleteContents(true);
     m_svBitmapCache.Clear();
@@ -313,14 +315,14 @@ void wxDC::ClearCache()
     m_svDCCache.DeleteContents(true);
     m_svDCCache.Clear();
     m_svDCCache.DeleteContents(false);
-} // end of wxDC::ClearCache
+} // end of wxPMDCImpl::ClearCache
 
 // Clean up cache at app exit
 class wxDCModule : public wxModule
 {
 public:
     virtual bool OnInit() { return true; }
-    virtual void OnExit() { wxDC::ClearCache(); }
+    virtual void OnExit() { wxPMDCImpl::ClearCache(); }
 
 private:
     DECLARE_DYNAMIC_CLASS(wxDCModule)
@@ -334,28 +336,14 @@ IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
 // wxDC
 // ---------------------------------------------------------------------------
 
-wxDC::wxDC(void)
+wxPMDCImpl::wxPMDCImpl( wxDC *owner, WXHDC hDC ) :
+    wxDCImpl( owner )
 {
-    m_pCanvas      = NULL;
+    Init();
+    m_hDC          = hDC;
+} // end of wxPMDCImpl::wxPMDCImpl
 
-    m_hOldBitmap   = 0;
-    m_hOldPen      = 0;
-    m_hOldBrush    = 0;
-    m_hOldFont     = 0;
-    m_hOldPalette  = 0;
-
-    m_bOwnsDC      = false;
-    m_hDC          = 0;
-    m_hOldPS       = NULL;
-    m_hPS          = NULL;
-    m_bIsPaintTime = false; // True at Paint Time
-
-    m_pen.SetColour(*wxBLACK);
-    m_brush.SetColour(*wxWHITE);
-
-} // end of wxDC::wxDC
-
-wxDC::~wxDC(void)
+wxPMDCImpl::~wxPMDCImpl()
 {
     if ( m_hDC != 0 )
     {
@@ -384,12 +372,12 @@ wxDC::~wxDC(void)
             }
         }
     }
-} // end of wxDC::~wxDC
+} // end of wxPMDCImpl::~wxDC
 
 // This will select current objects out of the DC,
 // which is what you have to do before deleting the
 // DC.
-void wxDC::SelectOldObjects(
+void wxPMDCImpl::SelectOldObjects(
   WXHDC                             hPS
 )
 {
@@ -398,7 +386,7 @@ void wxDC::SelectOldObjects(
         if (m_hOldBitmap)
         {
             ::GpiSetBitmap(hPS, (HBITMAP) m_hOldBitmap);
-            if (m_vSelectedBitmap.Ok())
+            if (m_vSelectedBitmap.IsOk())
             {
                 m_vSelectedBitmap.SetSelectedInto(NULL);
             }
@@ -419,7 +407,7 @@ void wxDC::SelectOldObjects(
     m_font            = wxNullFont;
     m_backgroundBrush = wxNullBrush;
     m_vSelectedBitmap = wxNullBitmap;
-} // end of wxDC::SelectOldObjects
+} // end of wxPMDCImpl::SelectOldObjects
 
 // ---------------------------------------------------------------------------
 // clipping
@@ -437,7 +425,7 @@ void wxDC::SelectOldObjects(
     m_clipY2 = (wxCoord) YDEV2LOG(rect.yBottom); \
 }
 
-void wxDC::DoSetClippingRegion(
+void wxPMDCImpl::DoSetClippingRegion(
   wxCoord                           vX
 , wxCoord                           vY
 , wxCoord                           vWidth
@@ -454,9 +442,9 @@ void wxDC::DoSetClippingRegion(
     vRect.yBottom = vY;
     ::GpiIntersectClipRectangle(m_hPS, &vRect);
     DO_SET_CLIPPING_BOX()
-} // end of wxDC::DoSetClippingRegion
+} // end of wxPMDCImpl::DoSetClippingRegion
 
-void wxDC::DoSetClippingRegionAsRegion(
+void wxPMDCImpl::DoSetDeviceClippingRegion(
   const wxRegion&                   rRegion
 )
 {
@@ -469,9 +457,9 @@ void wxDC::DoSetClippingRegionAsRegion(
                         ,&hRgnOld
                        );
     DO_SET_CLIPPING_BOX()
-} // end of wxDC::DoSetClippingRegionAsRegion
+} // end of wxPMDCImpl::DoSetDeviceClippingRegion
 
-void wxDC::DestroyClippingRegion(void)
+void wxPMDCImpl::DestroyClippingRegion()
 {
     if (m_clipping && m_hPS)
     {
@@ -492,46 +480,46 @@ void wxDC::DestroyClippingRegion(void)
          ::GpiSetClipRegion(m_hPS, hRgn, &hRgnOld);
      }
     ResetClipping();
-} // end of wxDC::DestroyClippingRegion
+} // end of wxPMDCImpl::DestroyClippingRegion
 
 // ---------------------------------------------------------------------------
 // query capabilities
 // ---------------------------------------------------------------------------
 
-bool wxDC::CanDrawBitmap() const
+bool wxPMDCImpl::CanDrawBitmap() const
 {
     return true;
 }
 
-bool wxDC::CanGetTextExtent() const
+bool wxPMDCImpl::CanGetTextExtent() const
 {
     LONG                            lTechnology = 0L;
 
     ::DevQueryCaps(GetHDC(), CAPS_TECHNOLOGY, 1L, &lTechnology);
     return (lTechnology == CAPS_TECH_RASTER_DISPLAY) || (lTechnology == CAPS_TECH_RASTER_PRINTER);
-} // end of wxDC::CanGetTextExtent
+} // end of wxPMDCImpl::CanGetTextExtent
 
-int wxDC::GetDepth() const
+int wxPMDCImpl::GetDepth() const
 {
-    LONG                            lArray[CAPS_COLOR_BITCOUNT];
+    LONG                            lCapsColorBitcount;
     int                             nBitsPerPixel = 0;
 
     if(::DevQueryCaps( GetHDC()
-                      ,CAPS_FAMILY
                       ,CAPS_COLOR_BITCOUNT
-                      ,lArray
+                      ,1L
+                      ,&lCapsColorBitcount
                      ))
     {
-        nBitsPerPixel = (int)lArray[CAPS_COLOR_BITCOUNT];
+        nBitsPerPixel = (int)lCapsColorBitcount;
     }
     return nBitsPerPixel;
-} // end of wxDC::GetDepth
+} // end of wxPMDCImpl::GetDepth
 
 // ---------------------------------------------------------------------------
 // drawing
 // ---------------------------------------------------------------------------
 
-void wxDC::Clear()
+void wxPMDCImpl::Clear()
 {
     //
     // If this is a canvas DC then just fill with the background color
@@ -546,13 +534,13 @@ void wxDC::Clear()
     }
     else
     ::GpiErase(m_hPS);
-} // end of wxDC::Clear
+} // end of wxPMDCImpl::Clear
 
-bool wxDC::DoFloodFill(
+bool wxPMDCImpl::DoFloodFill(
   wxCoord                           vX
 , wxCoord                           vY
 , const wxColour&                   rCol
-, int                               nStyle
+, wxFloodFillStyle                  nStyle
 )
 {
     POINTL                          vPtlPos;
@@ -573,9 +561,9 @@ bool wxDC::DoFloodFill(
         bSuccess = true;
 
     return bSuccess;
-} // end of wxDC::DoFloodFill
+} // end of wxPMDCImpl::DoFloodFill
 
-bool wxDC::DoGetPixel(
+bool wxPMDCImpl::DoGetPixel(
   wxCoord                           vX
 , wxCoord                           vY
 , wxColour*                         pCol
@@ -597,9 +585,9 @@ bool wxDC::DoGetPixel(
                   ,GetBValue(lColor)
                  );
     return true;
-} // end of wxDC::DoGetPixel
+} // end of wxPMDCImpl::DoGetPixel
 
-void wxDC::DoCrossHair(
+void wxPMDCImpl::DoCrossHair(
   wxCoord                           vX
 , wxCoord                           vY
 )
@@ -631,9 +619,9 @@ void wxDC::DoCrossHair(
     ::GpiLine(m_hPS, &vPoint[3]);
     CalcBoundingBox(vX1, vY1);
     CalcBoundingBox(vX2, vY2);
-} // end of wxDC::DoCrossHair
+} // end of wxPMDCImpl::DoCrossHair
 
-void wxDC::DoDrawLine(
+void wxPMDCImpl::DoDrawLine(
   wxCoord                           vX1
 , wxCoord                           vY1
 , wxCoord                           vX2
@@ -656,7 +644,7 @@ void wxDC::DoDrawLine(
     }
     else
     {
-        if (m_vSelectedBitmap != wxNullBitmap)
+        if (m_vSelectedBitmap.IsOk())
         {
             m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
             m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
@@ -668,7 +656,7 @@ void wxDC::DoDrawLine(
     vPoint[0].y = vY1;
     vPoint[1].x = vX2;
     vPoint[1].y = vY2;
-    if (m_pen.Ok())
+    if (m_pen.IsOk())
     {
         vColor = m_pen.GetColour().GetPixel();
     }
@@ -677,7 +665,7 @@ void wxDC::DoDrawLine(
     ::GpiLine(m_hPS, &vPoint[1]);
     CalcBoundingBox(vX1, vY1);
     CalcBoundingBox(vX2, vY2);
-} // end of wxDC::DoDrawLine
+} // end of wxPMDCImpl::DoDrawLine
 
 //////////////////////////////////////////////////////////////////////////////
 // Draws an arc of a circle, centred on (xc, yc), with starting point (x1, y1)
@@ -685,7 +673,7 @@ void wxDC::DoDrawLine(
 // current brush for filling the shape. The arc is drawn in an anticlockwise
 // direction from the start point to the end point.
 //////////////////////////////////////////////////////////////////////////////
-void wxDC::DoDrawArc(
+void wxPMDCImpl::DoDrawArc(
   wxCoord                           vX1
 , wxCoord                           vY1
 , wxCoord                           vX2
@@ -775,9 +763,9 @@ void wxDC::DoDrawArc(
     CalcBoundingBox( (wxCoord)(vXc + dRadius)
                     ,(wxCoord)(vYc + dRadius)
                    );
-} // end of wxDC::DoDrawArc
+} // end of wxPMDCImpl::DoDrawArc
 
-void wxDC::DoDrawCheckMark(
+void wxPMDCImpl::DoDrawCheckMark(
   wxCoord                           vX1
 , wxCoord                           vY1
 , wxCoord                           vWidth
@@ -824,9 +812,9 @@ void wxDC::DoDrawCheckMark(
     CalcBoundingBox( vX2
                     ,vY2
                    );
-} // end of wxDC::DoDrawCheckMark
+} // end of wxPMDCImpl::DoDrawCheckMark
 
-void wxDC::DoDrawPoint(
+void wxPMDCImpl::DoDrawPoint(
   wxCoord                           vX
 , wxCoord                           vY
 )
@@ -834,7 +822,7 @@ void wxDC::DoDrawPoint(
     POINTL                          vPoint;
     COLORREF                        vColor = 0x00ffffff;
 
-    if (m_pen.Ok())
+    if (m_pen.IsOk())
     {
         vColor = m_pen.GetColour().GetPixel();
     }
@@ -845,13 +833,13 @@ void wxDC::DoDrawPoint(
     CalcBoundingBox( vX
                     ,vY
                    );
-} // end of wxDC::DoDrawPoint
+} // end of wxPMDCImpl::DoDrawPoint
 
-void wxDC::DoDrawPolygon( int n,
+void wxPMDCImpl::DoDrawPolygon( int n,
                           wxPoint vPoints[],
                           wxCoord vXoffset,
                           wxCoord vYoffset,
-                          int nFillStyle )
+                          wxPolygonFillMode nFillStyle )
 {
     ULONG     ulCount = 1;    // Number of polygons.
     POLYGON   vPlgn;          // polygon.
@@ -911,9 +899,9 @@ void wxDC::DoDrawPolygon( int n,
     ::GpiMove(m_hPS, &vPlgn.aPointl[0]);
     lHits = ::GpiPolygons(m_hPS, ulCount, &vPlgn, flOptions, flModel);
     free(vPlgn.aPointl);
-} // end of wxDC::DoDrawPolygon
+} // end of wxPMDCImpl::DoDrawPolygon
 
-void wxDC::DoDrawLines(
+void wxPMDCImpl::DoDrawLines(
   int                               n
 , wxPoint                           vPoints[]
 , wxCoord                           vXoffset
@@ -922,7 +910,7 @@ void wxDC::DoDrawLines(
 {
     POINTL                          vPoint;
 
-    if (vXoffset != 0L || vXoffset != 0L)
+    if (vXoffset != 0L || vYoffset != 0L)
     {
         int                             i;
 
@@ -961,9 +949,9 @@ void wxDC::DoDrawLines(
             ::GpiLine(m_hPS, &vPoint);
         }
     }
-} // end of wxDC::DoDrawLines
+} // end of wxPMDCImpl::DoDrawLines
 
-void wxDC::DoDrawRectangle(
+void wxPMDCImpl::DoDrawRectangle(
   wxCoord                           vX
 , wxCoord                           vY
 , wxCoord                           vWidth
@@ -986,7 +974,7 @@ void wxDC::DoDrawRectangle(
         vY = OS2Y(vY,vHeight);
     else
     {
-        if (m_vSelectedBitmap != wxNullBitmap)
+        if (m_vSelectedBitmap.IsOk())
         {
             m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
             m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
@@ -1050,9 +1038,9 @@ void wxDC::DoDrawRectangle(
     }
     CalcBoundingBox(vX, vY);
     CalcBoundingBox(vX2, vY2);
-} // end of wxDC::DoDrawRectangle
+} // end of wxPMDCImpl::DoDrawRectangle
 
-void wxDC::DoDrawRoundedRectangle(
+void wxPMDCImpl::DoDrawRoundedRectangle(
   wxCoord                           vX
 , wxCoord                           vY
 , wxCoord                           vWidth
@@ -1076,7 +1064,7 @@ void wxDC::DoDrawRoundedRectangle(
         vY = OS2Y(vY,vHeight);
     else
     {
-        if (m_vSelectedBitmap != wxNullBitmap)
+        if (m_vSelectedBitmap.IsOk())
         {
             m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
             m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
@@ -1143,10 +1131,10 @@ void wxDC::DoDrawRoundedRectangle(
 
     CalcBoundingBox(vX, vY);
     CalcBoundingBox(vX2, vY2);
-} // end of wxDC::DoDrawRoundedRectangle
+} // end of wxPMDCImpl::DoDrawRoundedRectangle
 
 // Draw Ellipse within box (x,y) - (x+width, y+height)
-void wxDC::DoDrawEllipse(
+void wxPMDCImpl::DoDrawEllipse(
   wxCoord                           vX
 , wxCoord                           vY
 , wxCoord                           vWidth
@@ -1186,9 +1174,9 @@ void wxDC::DoDrawEllipse(
 
     CalcBoundingBox(vX, vY);
     CalcBoundingBox(vX2, vY2);
-} // end of wxDC::DoDrawEllipse
+} // end of wxPMDCImpl::DoDrawEllipse
 
-void wxDC::DoDrawEllipticArc(
+void wxPMDCImpl::DoDrawEllipticArc(
   wxCoord                           vX
 , wxCoord                           vY
 , wxCoord                           vWidth
@@ -1245,9 +1233,9 @@ void wxDC::DoDrawEllipticArc(
 
     CalcBoundingBox(vX, vY);
     CalcBoundingBox(vX2, vY2);
-} // end of wxDC::DoDrawEllipticArc
+} // end of wxPMDCImpl::DoDrawEllipticArc
 
-void wxDC::DoDrawIcon(
+void wxPMDCImpl::DoDrawIcon(
   const wxIcon&                     rIcon
 , wxCoord                           vX
 , wxCoord                           vY
@@ -1270,9 +1258,9 @@ void wxDC::DoDrawIcon(
     }
     CalcBoundingBox(vX, vY);
     CalcBoundingBox(vX + rIcon.GetWidth(), vY + rIcon.GetHeight());
-} // end of wxDC::DoDrawIcon
+} // end of wxPMDCImpl::DoDrawIcon
 
-void wxDC::DoDrawBitmap(
+void wxPMDCImpl::DoDrawBitmap(
   const wxBitmap&                   rBmp
 , wxCoord                           vX
 , wxCoord                           vY
@@ -1365,13 +1353,13 @@ void wxDC::DoDrawBitmap(
                 //
                 // Need to get a background color for mask blitting
                 //
-                if (IsKindOf(CLASSINFO(wxWindowDC)))
+                if (IsKindOf(CLASSINFO(wxWindowDCImpl)))
                 {
-                    wxWindowDC*             pWindowDC = wxDynamicCast(this, wxWindowDC);
+                    wxWindowDCImpl*  pWindowDC = wxDynamicCast(this, wxWindowDCImpl);
 
                     lColor = pWindowDC->m_pCanvas->GetBackgroundColour().GetPixel();
                 }
-                else if (GetBrush().Ok())
+                else if (GetBrush().IsOk())
                     lColor = GetBrush().GetColour().GetPixel();
                 else
                     lColor = m_textBackgroundColour.GetPixel();
@@ -1538,13 +1526,13 @@ void wxDC::DoDrawBitmap(
             ULONG                       lOldForeGround = ::GpiQueryColor((HPS)GetHPS());
             ULONG                       lOldBackGround = ::GpiQueryBackColor((HPS)GetHPS());
 
-            if (m_textForegroundColour.Ok())
+            if (m_textForegroundColour.IsOk())
             {
                 ::GpiSetColor( (HPS)GetHPS()
                                ,m_textForegroundColour.GetPixel()
                               );
             }
-            if (m_textBackgroundColour.Ok())
+            if (m_textBackgroundColour.IsOk())
             {
                 ::GpiSetBackColor( (HPS)GetHPS()
                                   ,m_textBackgroundColour.GetPixel()
@@ -1591,6 +1579,7 @@ void wxDC::DoDrawBitmap(
                 {
                     vError = ::WinGetLastError(vHabmain);
                     sError = wxPMErrorToStr(vError);
+                    delete [] pucBits;
                     return;
                 }
                 if ((lScans = ::GpiQueryBitmapBits( hPS
@@ -1602,6 +1591,7 @@ void wxDC::DoDrawBitmap(
                 {
                     vError = ::WinGetLastError(vHabmain);
                     sError = wxPMErrorToStr(vError);
+                    delete [] pucBits;
                     return;
                 }
                 unsigned char           cOldRedFore   = (unsigned char)(lOldForeGround >> 16);
@@ -1675,9 +1665,9 @@ void wxDC::DoDrawBitmap(
             ::GpiSetBackColor((HPS)GetHPS(), lOldBackGround);
         }
     }
-} // end of wxDC::DoDrawBitmap
+} // end of wxPMDCImpl::DoDrawBitmap
 
-void wxDC::DoDrawText(
+void wxPMDCImpl::DoDrawText(
   const wxString&                   rsText
 , wxCoord                           vX
 , wxCoord                           vY
@@ -1692,11 +1682,11 @@ void wxDC::DoDrawText(
                );
 
     CalcBoundingBox(vX, vY);
-    GetTextExtent(rsText, &vWidth, &vHeight);
+    GetOwner()->GetTextExtent(rsText, &vWidth, &vHeight);
     CalcBoundingBox((vX + vWidth), (vY + vHeight));
-} // end of wxDC::DoDrawText
+} // end of wxPMDCImpl::DoDrawText
 
-void wxDC::DrawAnyText( const wxString& rsText,
+void wxPMDCImpl::DrawAnyText( const wxString& rsText,
                         wxCoord vX,
                         wxCoord vY )
 {
@@ -1713,14 +1703,14 @@ void wxDC::DrawAnyText( const wxString& rsText,
     //
     // Set text color attributes
     //
-    if (m_textForegroundColour.Ok())
+    if (m_textForegroundColour.IsOk())
     {
         SetTextColor( m_hPS
                      ,(int)m_textForegroundColour.GetPixel()
                     );
     }
 
-    if (m_textBackgroundColour.Ok())
+    if (m_textBackgroundColour.IsOk())
     {
         nOldBackground = SetTextBkColor( m_hPS
                                         ,(int)m_textBackgroundColour.GetPixel()
@@ -1729,10 +1719,10 @@ void wxDC::DrawAnyText( const wxString& rsText,
     SetBkMode( m_hPS
               ,m_backgroundMode
              );
-    GetTextExtent( rsText
-                  ,&vTextX
-                  ,&vTextY
-                 );
+    GetOwner()->GetTextExtent( rsText
+                              ,&vTextX
+                              ,&vTextY
+                             );
     vPtlStart.x = vX;
     if (!(m_vRclPaint.yTop == 0 &&
           m_vRclPaint.yBottom == 0 &&
@@ -1743,7 +1733,7 @@ void wxDC::DrawAnyText( const wxString& rsText,
     }
     else
     {
-        if (m_vSelectedBitmap != wxNullBitmap)
+        if (m_vSelectedBitmap.IsOk())
         {
             m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
             m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
@@ -1753,12 +1743,10 @@ void wxDC::DrawAnyText( const wxString& rsText,
             vPtlStart.y = vY;
     }
 
-    PCH pzStr = (PCH)rsText.c_str();
-
     ::GpiMove(m_hPS, &vPtlStart);
     lHits = ::GpiCharString( m_hPS
                             ,rsText.length()
-                            ,pzStr
+                            ,rsText.char_str()
                            );
     if (lHits != GPI_OK)
     {
@@ -1770,7 +1758,7 @@ void wxDC::DrawAnyText( const wxString& rsText,
     // it never is set to anything else, but background should remain
     // transparent even if we just drew an opaque string)
     //
-    if (m_textBackgroundColour.Ok())
+    if (m_textBackgroundColour.IsOk())
             SetTextBkColor( m_hPS
                            ,nOldBackground
                           );
@@ -1779,7 +1767,7 @@ void wxDC::DrawAnyText( const wxString& rsText,
              );
 }
 
-void wxDC::DoDrawRotatedText(
+void wxPMDCImpl::DoDrawRotatedText(
   const wxString&                   rsText
 , wxCoord                           vX
 , wxCoord                           vY
@@ -1850,7 +1838,7 @@ void wxDC::DoDrawRotatedText(
 // set GDI objects
 // ---------------------------------------------------------------------------
 
-void wxDC::DoSelectPalette( bool WXUNUSED(bRealize) )
+void wxPMDCImpl::DoSelectPalette( bool WXUNUSED(bRealize) )
 {
     //
     // Set the old object temporarily, in case the assignment deletes an object
@@ -1861,7 +1849,7 @@ void wxDC::DoSelectPalette( bool WXUNUSED(bRealize) )
         m_hOldPalette = 0;
     }
 
-    if (m_palette.Ok())
+    if (m_palette.IsOk())
     {
         HPALETTE                    hOldPal;
 
@@ -1869,9 +1857,9 @@ void wxDC::DoSelectPalette( bool WXUNUSED(bRealize) )
         if (!m_hOldPalette)
             m_hOldPalette = (WXHPALETTE)hOldPal;
     }
-} // end of wxDC::DoSelectPalette
+} // end of wxPMDCImpl::DoSelectPalette
 
-void wxDC::InitializePalette()
+void wxPMDCImpl::InitializePalette()
 {
     if (wxDisplayDepth() <= 8 )
     {
@@ -1892,9 +1880,9 @@ void wxDC::InitializePalette()
             DoSelectPalette();
         }
     }
-} // end of wxDC::InitializePalette
+} // end of wxPMDCImpl::InitializePalette
 
-void wxDC::SetPalette(
+void wxPMDCImpl::SetPalette(
   const wxPalette&                  rPalette
 )
 {
@@ -1903,7 +1891,7 @@ void wxDC::SetPalette(
         m_hOldFont = 0;
     }
     m_palette = rPalette;
-    if (!rPalette.Ok())
+    if (!rPalette.IsOk())
     {
         if (m_hOldFont)
         {
@@ -1913,9 +1901,9 @@ void wxDC::SetPalette(
     HPALETTE                    hOldPal = ::GpiSelectPalette((HDC) m_hPS, (HPALETTE) m_palette.GetHPALETTE());
     if (!m_hOldPalette)
         m_hOldPalette = (WXHPALETTE)hOldPal;
-} // end of wxDC::SetPalette
+} // end of wxPMDCImpl::SetPalette
 
-void wxDC::SetFont(
+void wxPMDCImpl::SetFont(
   const wxFont&                     rFont
 )
 {
@@ -1928,42 +1916,40 @@ void wxDC::SetFont(
         m_hOldFont = 0;
     }
     m_font = rFont;
-    if (!rFont.Ok())
+    if (!rFont.IsOk())
     {
         m_hOldFont = 0;
     }
 
     m_font.SetPS(m_hPS); // this will realize the font
 
-    if (m_font.Ok())
+    if (m_font.IsOk())
     {
         HFONT                       hFont = m_font.GetResourceHandle();
         if (hFont == (HFONT) NULL)
         {
-            wxLogDebug(wxT("::SelectObject failed in wxDC::SetFont."));
+            wxLogDebug(wxT("::SelectObject failed in wxPMDCImpl::SetFont."));
         }
         if (!m_hOldFont)
             m_hOldFont = (WXHFONT) hFont;
     }
-} // end of wxDC::SetFont
+} // end of wxPMDCImpl::SetFont
 
-void wxDC::SetPen(
+void wxPMDCImpl::SetPen(
   const wxPen&                      rPen
 )
 {
-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
-
     if (m_pen == rPen)
         return;
     m_pen = rPen;
-    if (!m_pen.Ok())
+    if (!m_pen.IsOk())
         return;
 
     if (m_hOldPen)
         m_hOldPen = 0L;
     m_pen = rPen;
 
-    if (!m_pen.Ok())
+    if (!m_pen.IsOk())
     {
         if (m_hOldPen)
         {
@@ -1972,7 +1958,7 @@ void wxDC::SetPen(
         m_hOldPen = 0L;
     }
 
-    if (m_pen.Ok())
+    if (m_pen.IsOk())
     {
         if (m_pen.GetResourceHandle())
         {
@@ -1984,23 +1970,21 @@ void wxDC::SetPen(
     }
 }
 
-void wxDC::SetBrush(
+void wxPMDCImpl::SetBrush(
   const wxBrush&                    rBrush
 )
 {
-    wxCHECK_RET( Ok(), wxT("invalid window dc") );
-
     if (m_hOldBrush)
         m_hOldBrush = 0L;
     m_brush = rBrush;
-    if (!m_brush.Ok())
+    if (!m_brush.IsOk())
     if (m_brush == rBrush)
         return;
-    if (!m_brush.Ok())
+    if (!m_brush.IsOk())
         if (m_hOldBrush)
             m_hOldBrush = 0L;
 
-    if (!m_brush.Ok())
+    if (!m_brush.IsOk())
     {
         if (m_hOldBrush)
         {
@@ -2009,7 +1993,7 @@ void wxDC::SetBrush(
         m_hOldBrush = 0L;
     }
 
-    if (m_brush.Ok())
+    if (m_brush.IsOk())
     {
         if (m_brush.GetResourceHandle())
         {
@@ -2018,30 +2002,30 @@ void wxDC::SetBrush(
                 m_hOldBrush = (WXHWND)m_brush.GetPS();
         }
     }
-} // end of wxDC::SetBrush
+} // end of wxPMDCImpl::SetBrush
 
-void wxDC::SetBackground(const wxBrush& rBrush)
+void wxPMDCImpl::SetBackground(const wxBrush& rBrush)
 {
     m_backgroundBrush = rBrush;
 
-    if (m_backgroundBrush.Ok())
+    if (m_backgroundBrush.IsOk())
     {
         (void)::GpiSetBackColor((HPS)m_hPS, m_backgroundBrush.GetColour().GetPixel());
     }
-} // end of wxDC::SetBackground
+} // end of wxPMDCImpl::SetBackground
 
-void wxDC::SetBackgroundMode(int nMode)
+void wxPMDCImpl::SetBackgroundMode(int nMode)
 {
     m_backgroundMode = nMode;
-} // end of wxDC::SetBackgroundMode
+} // end of wxPMDCImpl::SetBackgroundMode
 
-void wxDC::SetLogicalFunction(int nFunction)
+void wxPMDCImpl::SetLogicalFunction(wxRasterOperationMode nFunction)
 {
     m_logicalFunction = nFunction;
     SetRop((WXHDC)m_hDC);
-} // wxDC::SetLogicalFunction
+} // wxPMDCImpl::SetLogicalFunction
 
-void wxDC::SetRop(WXHDC hDC)
+void wxPMDCImpl::SetRop(WXHDC hDC)
 {
     if (!hDC || m_logicalFunction < 0)
         return;
@@ -2101,31 +2085,31 @@ void wxDC::SetRop(WXHDC hDC)
             break;
     }
     ::GpiSetMix((HPS)hDC, lCRop);
-} // end of wxDC::SetRop
+} // end of wxPMDCImpl::SetRop
 
-bool wxDC::StartDoc( const wxString& WXUNUSED(rsMessage) )
+bool wxPMDCImpl::StartDoc( const wxString& WXUNUSED(rsMessage) )
 {
     // We might be previewing, so return true to let it continue.
     return true;
-} // end of wxDC::StartDoc
+} // end of wxPMDCImpl::StartDoc
 
-void wxDC::EndDoc()
+void wxPMDCImpl::EndDoc()
 {
-} // end of wxDC::EndDoc
+} // end of wxPMDCImpl::EndDoc
 
-void wxDC::StartPage()
+void wxPMDCImpl::StartPage()
 {
-} // end of wxDC::StartPage
+} // end of wxPMDCImpl::StartPage
 
-void wxDC::EndPage()
+void wxPMDCImpl::EndPage()
 {
-} // end of wxDC::EndPage
+} // end of wxPMDCImpl::EndPage
 
 // ---------------------------------------------------------------------------
 // text metrics
 // ---------------------------------------------------------------------------
 
-wxCoord wxDC::GetCharHeight() const
+wxCoord wxPMDCImpl::GetCharHeight() const
 {
     FONTMETRICS                     vFM; // metrics structure
 
@@ -2136,7 +2120,7 @@ wxCoord wxDC::GetCharHeight() const
     return YDEV2LOGREL(vFM.lXHeight);
 }
 
-wxCoord wxDC::GetCharWidth() const
+wxCoord wxPMDCImpl::GetCharWidth() const
 {
     FONTMETRICS                     vFM; // metrics structure
 
@@ -2147,13 +2131,13 @@ wxCoord wxDC::GetCharWidth() const
     return XDEV2LOGREL(vFM.lAveCharWidth);
 }
 
-void wxDC::DoGetTextExtent(
+void wxPMDCImpl::DoGetTextExtent(
   const wxString&                   rsString
 , wxCoord*                          pvX
 , wxCoord*                          pvY
 , wxCoord*                          pvDescent
 , wxCoord*                          pvExternalLeading
-, wxFont*                           pTheFont
+, const wxFont*                     pTheFont
 ) const
 {
     POINTL                          avPoint[TXTBOX_COUNT];
@@ -2176,9 +2160,17 @@ void wxDC::DoGetTextExtent(
     //
     // In world coordinates.
     //
+    if (!m_hPS)
+    {
+    (void)wxMessageBox( wxT("wxWidgets core library")
+                ,"Using uninitialized DC for measuring text!\n"
+                ,wxICON_INFORMATION
+                );
+    }
+
     bRc = ::GpiQueryTextBox( m_hPS
                             ,l
-                            ,(PCH)rsString.c_str()
+                            ,rsString.char_str()
                             ,TXTBOX_COUNT // return maximum information
                             ,avPoint      // array of coordinates points
                            );
@@ -2187,8 +2179,8 @@ void wxDC::DoGetTextExtent(
        vErrorCode = ::WinGetLastError(wxGetInstance());
        sError = wxPMErrorToStr(vErrorCode);
        // DEBUG
-       wxSprintf(zMsg, _T("GpiQueryTextBox for %s: failed with Error: %lx - %s"), rsString.c_str(), vErrorCode, sError.c_str());
-       (void)wxMessageBox( _T("wxWidgets Menu sample")
+       wxSprintf(zMsg, wxT("GpiQueryTextBox for %s: failed with Error: %lx - %s"), rsString.c_str(), vErrorCode, sError.c_str());
+       (void)wxMessageBox( wxT("wxWidgets core library")
                           ,zMsg
                           ,wxICON_INFORMATION
                          );
@@ -2220,21 +2212,21 @@ void wxDC::DoGetTextExtent(
         *pvExternalLeading = vFM.lExternalLeading;
 }
 
-void wxDC::SetMapMode(
-  int                               nMode
+void wxPMDCImpl::SetMapMode(
+  wxMappingMode                     nMode
 )
 {
     int                             nPixelWidth = 0;
     int                             nPixelHeight = 0;
     int                             nMmWidth = 1;
     int                             nMmHeight = 1;
-    LONG                            lArray[CAPS_VERTICAL_RESOLUTION];
+    LONG                            lArray[CAPS_VERTICAL_RESOLUTION+1];
 
     m_mappingMode = nMode;
 
     if(::DevQueryCaps( m_hDC
-                      ,CAPS_FAMILY
-                      ,CAPS_VERTICAL_RESOLUTION
+                      ,CAPS_FAMILY                  // id of first item
+                      ,CAPS_VERTICAL_RESOLUTION+1   // number of items wanted
                       ,lArray
                      ))
     {
@@ -2246,15 +2238,15 @@ void wxDC::SetMapMode(
         lHorzRes  = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
         lVertRes  = lArray[CAPS_VERTICAL_RESOLUTION];   // returns pel/meter
         nMmWidth  = (lHorzRes/1000) * nPixelWidth;
-        nMmWidth = (lVertRes/1000) * nPixelHeight;
+        nMmHeight = (lVertRes/1000) * nPixelHeight;
     }
     if ((nPixelWidth == 0) || (nPixelHeight == 0) || (nMmWidth == 0) || (nMmHeight == 0))
     {
         return;
     }
 
-    double                          dMm2pixelsX = nPixelWidth/nMmWidth;
-    double                          dMm2pixelsY = nPixelHeight/nMmHeight;
+    double dMm2pixelsX = nPixelWidth/(double)nMmWidth;
+    double dMm2pixelsY = nPixelHeight/(double)nMmHeight;
 
     switch (nMode)
     {
@@ -2284,6 +2276,7 @@ void wxDC::SetMapMode(
             m_logicalScaleY = 1.0;
             break;
     }
+
     SIZEL                           vSize;
     ULONG                           ulOptions;
 
@@ -2293,41 +2286,29 @@ void wxDC::SetMapMode(
         ulOptions = PU_ARBITRARY | GPIF_DEFAULT;
         ::GpiSetPS(m_hPS, &vSize, ulOptions);
     }
-    m_nWindowExtX = (int)MS_XDEV2LOG(VIEWPORT_EXTENT);
-    m_nWindowExtY = (int)MS_YDEV2LOG(VIEWPORT_EXTENT);
-    // ????
-}; // end of wxDC::SetMapMode
+    ComputeScaleAndOrigin();
+
+}; // end of wxPMDCImpl::SetMapMode
 
-void wxDC::SetUserScale( double dX,
+void wxPMDCImpl::SetUserScale( double dX,
                          double dY )
 {
     m_userScaleX = dX;
     m_userScaleY = dY;
 
     SetMapMode(m_mappingMode);
-} // end of wxDC::SetUserScale
+} // end of wxPMDCImpl::SetUserScale
 
-void wxDC::SetAxisOrientation( bool bXLeftRight,
+void wxPMDCImpl::SetAxisOrientation( bool bXLeftRight,
                                bool bYBottomUp )
 {
     m_signX = bXLeftRight ? 1 : -1;
     m_signY = bYBottomUp ? -1 : 1;
 
     SetMapMode(m_mappingMode);
-} // end of wxDC::SetAxisOrientation
-
-void wxDC::SetSystemScale(
-  double                            dX
-, double                            dY
-)
-{
-    m_scaleX = dX;
-    m_scaleY = dY;
+} // end of wxPMDCImpl::SetAxisOrientation
 
-    SetMapMode(m_mappingMode);
-} // end of wxDC::SetSystemScale
-
-void wxDC::SetLogicalOrigin(
+void wxPMDCImpl::SetLogicalOrigin(
   wxCoord                           vX
 , wxCoord                           vY
 )
@@ -2344,9 +2325,9 @@ void wxDC::SetLogicalOrigin(
     ::GpiSetPageViewport( m_hPS
                          ,&vRect
                         );
-}; // end of wxDC::SetLogicalOrigin
+}; // end of wxPMDCImpl::SetLogicalOrigin
 
-void wxDC::SetDeviceOrigin(
+void wxPMDCImpl::SetDeviceOrigin(
   wxCoord                           vX
 , wxCoord                           vY
 )
@@ -2365,68 +2346,20 @@ void wxDC::SetDeviceOrigin(
     ::GpiSetPageViewport( m_hPS
                          ,&vRect
                         );
-}; // end of wxDC::SetDeviceOrigin
-
-// ---------------------------------------------------------------------------
-// coordinates transformations
-// ---------------------------------------------------------------------------
-
-wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
-{
-    return (wxCoord) (((x) - m_deviceOriginX)/(m_logicalScaleX*m_userScaleX*m_signX*m_scaleX) - m_logicalOriginX);
-}
-
-wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
-{
-    // axis orientation is not taken into account for conversion of a distance
-    return (wxCoord) ((x)/(m_logicalScaleX*m_userScaleX*m_scaleX));
-}
-
-wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
-{
-    return (wxCoord) (((y) - m_deviceOriginY)/(m_logicalScaleY*m_userScaleY*m_signY*m_scaleY) - m_logicalOriginY);
-}
-
-wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
-{
-    // axis orientation is not taken into account for conversion of a distance
-    return (wxCoord) ((y)/(m_logicalScaleY*m_userScaleY*m_scaleY));
-}
-
-wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
-{
-    return (wxCoord) ((x - m_logicalOriginX)*m_logicalScaleX*m_userScaleX*m_signX*m_scaleX + m_deviceOriginX);
-}
-
-wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
-{
-    // axis orientation is not taken into account for conversion of a distance
-    return (wxCoord) (x*m_logicalScaleX*m_userScaleX*m_scaleX);
-}
-
-wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
-{
-    return (wxCoord) ((y - m_logicalOriginY)*m_logicalScaleY*m_userScaleY*m_signY*m_scaleY + m_deviceOriginY);
-}
-
-wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
-{
-    // axis orientation is not taken into account for conversion of a distance
-    return (wxCoord) (y*m_logicalScaleY*m_userScaleY*m_scaleY);
-}
+}; // end of wxPMDCImpl::SetDeviceOrigin
 
 // ---------------------------------------------------------------------------
 // bit blit
 // ---------------------------------------------------------------------------
 
-bool wxDC::DoBlit( wxCoord vXdest,
+bool wxPMDCImpl::DoBlit( wxCoord vXdest,
                    wxCoord vYdest,
                    wxCoord vWidth,
                    wxCoord vHeight,
                    wxDC*   pSource,
                    wxCoord vXsrc,
                    wxCoord vYsrc,
-                   int     nRop,
+                   wxRasterOperationMode     nRop,
                    bool    bUseMask,
                    wxCoord WXUNUSED(vXsrcMask),
                    wxCoord WXUNUSED(vYsrcMask) )
@@ -2436,12 +2369,21 @@ bool wxDC::DoBlit( wxCoord vXdest,
     COLORREF                        vOldTextColor;
     COLORREF                        vOldBackground = ::GpiQueryBackColor(m_hPS);
 
+    wxDCImpl *impl = pSource->GetImpl();
+    wxPMDCImpl *pm_impl = wxDynamicCast( impl, wxPMDCImpl );
+    if (!pm_impl)
+    {
+        // TODO: Do we want to be able to blit
+        //       from other DCs too?
+        return false;
+    }
+
     if (bUseMask)
     {
-        const wxBitmap&             rBmp = pSource->m_vSelectedBitmap;
+        const wxBitmap&             rBmp = pm_impl->GetSelectedBitmap();
 
         pMask = rBmp.GetMask();
-        if (!(rBmp.Ok() && pMask && pMask->GetMaskBitmap()))
+        if (!(rBmp.IsOk() && pMask && pMask->GetMaskBitmap()))
         {
             bUseMask = false;
         }
@@ -2454,7 +2396,7 @@ bool wxDC::DoBlit( wxCoord vXdest,
                    );
     vOldTextColor = (COLORREF)vCbnd.lColor;
 
-    if (m_textForegroundColour.Ok())
+    if (m_textForegroundColour.IsOk())
     {
         vCbnd.lColor = (LONG)m_textForegroundColour.GetPixel();
         ::GpiSetAttrs( m_hPS           // presentation-space handle
@@ -2464,7 +2406,7 @@ bool wxDC::DoBlit( wxCoord vXdest,
                       ,&vCbnd          // buffer for attributes.
                      );
     }
-    if (m_textBackgroundColour.Ok())
+    if (m_textBackgroundColour.IsOk())
     {
         ::GpiSetBackColor(m_hPS, (LONG)m_textBackgroundColour.GetPixel());
     }
@@ -2528,7 +2470,7 @@ bool wxDC::DoBlit( wxCoord vXdest,
             // create a temp buffer bitmap and DCs to access it and the mask
             //
             wxDCCacheEntry*         pDCCacheEntry1    = FindDCInCache( NULL
-                                                                      ,pSource->GetHPS()
+                                                                      ,pm_impl->GetHPS()
                                                                      );
             wxDCCacheEntry*         pDCCacheEntry2    = FindDCInCache( pDCCacheEntry1
                                                                       ,GetHPS()
@@ -2689,7 +2631,7 @@ bool wxDC::DoBlit( wxCoord vXdest,
                                                     };
 
         bSuccess = (::GpiBitBlt( m_hPS
-                                ,pSource->GetHPS()
+                                ,pm_impl->GetHPS()
                                 ,4L
                                 ,aPoint
                                 ,lRop
@@ -2711,58 +2653,62 @@ bool wxDC::DoBlit( wxCoord vXdest,
     return bSuccess;
 }
 
-void wxDC::DoGetSize( int* pnWidth,
-                      int* pnHeight ) const
+void wxPMDCImpl::DoGetSize( int* pnWidth,
+                            int* pnHeight ) const
 {
-    LONG lArray[CAPS_HEIGHT];
+    LONG lArray[CAPS_HEIGHT+1];
 
     if(::DevQueryCaps( m_hDC
                       ,CAPS_FAMILY
-                      ,CAPS_HEIGHT
+                      ,CAPS_HEIGHT+1
                       ,lArray
                      ))
     {
-        *pnWidth  = lArray[CAPS_WIDTH];
-        *pnHeight = lArray[CAPS_HEIGHT];
+        if (pnWidth)
+            *pnWidth  = lArray[CAPS_WIDTH];
+        if (pnHeight)
+            *pnHeight = lArray[CAPS_HEIGHT];
     }
-}; // end of wxDC::DoGetSize(
+}; // end of wxPMDCImpl::DoGetSize(
 
-void wxDC::DoGetSizeMM( int* pnWidth,
+void wxPMDCImpl::DoGetSizeMM( int* pnWidth,
                         int* pnHeight ) const
 {
-    LONG                            lArray[CAPS_VERTICAL_RESOLUTION];
+    LONG                            lArray[CAPS_VERTICAL_RESOLUTION+1];
 
     if(::DevQueryCaps( m_hDC
                       ,CAPS_FAMILY
-                      ,CAPS_VERTICAL_RESOLUTION
+                      ,CAPS_VERTICAL_RESOLUTION+1
                       ,lArray
                      ))
     {
         if(pnWidth)
         {
-            int nWidth = lArray[CAPS_WIDTH];
-            int nHorzRes  = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
-            *pnWidth  = (nHorzRes/1000) * nWidth;
+            int nWidth   = lArray[CAPS_WIDTH];
+            int nHorzRes = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
+            // use fp to avoid returning 0 if nHorzRes < 1000
+            *pnWidth  = (int)((nHorzRes/1000.0) * nWidth);
         }
 
         if(pnHeight)
         {
-            int nHeight   = lArray[CAPS_HEIGHT];
+            int nHeight  = lArray[CAPS_HEIGHT];
             int nVertRes = lArray[CAPS_VERTICAL_RESOLUTION];   // returns pel/meter
-            *pnHeight = (nVertRes/1000) * nHeight;
+            // use fp to avoid returning 0 if nVertRes < 1000
+            *pnHeight = (int)((nVertRes/1000.0) * nHeight);
         }
     }
-}; // end of wxDC::DoGetSizeMM
+}; // end of wxPMDCImpl::DoGetSizeMM
 
-wxSize wxDC::GetPPI() const
+wxSize wxPMDCImpl::GetPPI() const
 {
-    LONG                            lArray[CAPS_VERTICAL_RESOLUTION];
+    LONG                            lArray[CAPS_VERTICAL_RESOLUTION+1];
     int                             nWidth = 0;
     int                             nHeight = 0;
 
     if(::DevQueryCaps( m_hDC
                       ,CAPS_FAMILY
-                      ,CAPS_VERTICAL_RESOLUTION
+                      ,CAPS_VERTICAL_RESOLUTION+1
                       ,lArray
                      ))
     {
@@ -2780,10 +2726,10 @@ wxSize wxDC::GetPPI() const
     }
     wxSize ppisize(nWidth, nHeight);
     return ppisize;
-} // end of wxDC::GetPPI
+} // end of wxPMDCImpl::GetPPI
 
-void wxDC::SetLogicalScale( double dX, double dY )
+void wxPMDCImpl::SetLogicalScale( double dX, double dY )
 {
     m_logicalScaleX = dX;
     m_logicalScaleY = dY;
-}; // end of wxDC::SetLogicalScale
+}; // end of wxPMDCImpl::SetLogicalScale