some wxArtProv docs

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

diff --git a/src/msw/dc.cpp b/src/msw/dc.cpp
index 23c3da77eca43bdec7dd21268312e46e5488bfe3..09d21ad3d03a48040fd1e786f42e600422756cdc 100644 (file)
--- a/src/msw/dc.cpp
+++ b/src/msw/dc.cpp
@@ -49,7 +49,7 @@
 
 #include "wx/msw/private.h" // needs to be before #include <commdlg.h>
 
 
 #include "wx/msw/private.h" // needs to be before #include <commdlg.h>
 

-#if wxUSE_COMMON_DIALOGS
+#if wxUSE_COMMON_DIALOGS && !defined(__WXMICROWIN__)

     #include <commdlg.h>
 #endif
 
     #include <commdlg.h>
 #endif
 


@@ -77,6 +77,25 @@ static const int MM_METRIC = 10;
 // MSDN docs for how this and other numbers in wxDC::Blit() are obtained)
 #define DSTCOPY 0x00AA0029      // a.k.a. NOP operation
 
 // MSDN docs for how this and other numbers in wxDC::Blit() are obtained)
 #define DSTCOPY 0x00AA0029      // a.k.a. NOP operation
 

+// ----------------------------------------------------------------------------
+// macros for logical <-> device coords conversion
+// ----------------------------------------------------------------------------
+
+/*
+   We currently let Windows do all the translations itself so these macros are
+   not really needed (any more) but keep them to enhance readability of the
+   code by allowing to see where are the logical and where are the device
+   coordinates used.
+ */
+
+// logical to device
+#define XLOG2DEV(x) (x)
+#define YLOG2DEV(y) (y)
+
+// device to logical
+#define XDEV2LOG(x) (x)
+#define YDEV2LOG(y) (y)
+

 // ---------------------------------------------------------------------------
 // private functions
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // private functions
 // ---------------------------------------------------------------------------


@@ -118,7 +137,8 @@ private:
 
 wxColourChanger::wxColourChanger(wxDC& dc) : m_dc(dc)
 {
 
 wxColourChanger::wxColourChanger(wxDC& dc) : m_dc(dc)
 {

-    if ( dc.GetBrush().GetStyle() == wxSTIPPLE_MASK_OPAQUE )
+    const wxBrush& brush = dc.GetBrush();
+    if ( brush.Ok() && brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE )

     {
         HDC hdc = GetHdcOf(dc);
         m_colFgOld = ::GetTextColor(hdc);
     {
         HDC hdc = GetHdcOf(dc);
         m_colFgOld = ::GetTextColor(hdc);


@@ -184,12 +204,8 @@ wxDC::wxDC()
 
     m_bOwnsDC = FALSE;
     m_hDC = 0;
 
     m_bOwnsDC = FALSE;
     m_hDC = 0;

-
-    m_windowExtX = VIEWPORT_EXTENT;
-    m_windowExtY = VIEWPORT_EXTENT;

 }
 
 }
 

-

 wxDC::~wxDC()
 {
     if ( m_hDC != 0 )
 wxDC::~wxDC()
 {
     if ( m_hDC != 0 )


@@ -279,7 +295,7 @@ void wxDC::UpdateClipBox()
 #endif
 
     RECT rect;
 #endif
 
     RECT rect;

-    GetClipBox(GetHdc(), &rect);
+    ::GetClipBox(GetHdc(), &rect);

 
     m_clipX1 = (wxCoord) XDEV2LOG(rect.left);
     m_clipY1 = (wxCoord) YDEV2LOG(rect.top);
 
     m_clipX1 = (wxCoord) XDEV2LOG(rect.left);
     m_clipY1 = (wxCoord) YDEV2LOG(rect.top);


@@ -287,14 +303,50 @@ void wxDC::UpdateClipBox()
     m_clipY2 = (wxCoord) YDEV2LOG(rect.bottom);
 }
 
     m_clipY2 = (wxCoord) YDEV2LOG(rect.bottom);
 }
 

-void wxDC::DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
+// common part of DoSetClippingRegion() and DoSetClippingRegionAsRegion()
+void wxDC::SetClippingHrgn(WXHRGN hrgn)

 {
 {

+    wxCHECK_RET( hrgn, wxT("invalid clipping region") );
+

 #ifdef __WXMICROWIN__
 #ifdef __WXMICROWIN__

-    if (!GetHDC()) return;
-#endif
+    if (!GetHdc()) return;
+#endif // __WXMICROWIN__
+
+    // note that we combine the new clipping region with the existing one: this
+    // is compatible with what the other ports do and is the documented
+    // behaviour now (starting with 2.3.3)
+#ifdef __WIN16__
+    RECT rectClip;
+    if ( !::GetClipBox(GetHdc(), &rectClip) )
+        return;
+
+    HRGN hrgnDest = ::CreateRectRgn(0, 0, 0, 0);
+    HRGN hrgnClipOld = ::CreateRectRgn(rectClip.left, rectClip.top,
+                                       rectClip.right, rectClip.bottom);
+
+    if ( ::CombineRgn(hrgnDest, hrgnClipOld, (HRGN)hrgn, RGN_AND) != ERROR )
+    {
+        ::SelectClipRgn(GetHdc(), hrgnDest);
+    }
+
+    ::DeleteObject(hrgnClipOld);
+    ::DeleteObject(hrgnDest);
+#else // Win32
+    if ( ::ExtSelectClipRgn(GetHdc(), (HRGN)hrgn, RGN_AND) == ERROR )
+    {
+        wxLogLastError(_T("ExtSelectClipRgn"));
+
+        return;
+    }
+#endif // Win16/32

 
     m_clipping = TRUE;
 
 
     m_clipping = TRUE;
 

+    UpdateClipBox();
+}
+
+void wxDC::DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
+{

     // the region coords are always the device ones, so do the translation
     // manually
     //
     // the region coords are always the device ones, so do the translation
     // manually
     //


@@ -309,33 +361,15 @@ void wxDC::DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
     }
     else
     {
     }
     else
     {

-        if ( ::SelectClipRgn(GetHdc(), hrgn) == ERROR )
-        {
-            wxLogLastError(_T("SelectClipRgn"));
-        }
-        DeleteObject(hrgn);
+        SetClippingHrgn((WXHRGN)hrgn);

 
 

-        UpdateClipBox();
+        ::DeleteObject(hrgn);

     }
 }
 
 void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
 {
     }
 }
 
 void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
 {

-#ifdef __WXMICROWIN__
-    if (!GetHDC()) return;
-#endif
-
-    wxCHECK_RET( GetHrgnOf(region), wxT("invalid clipping region") );
-
-    m_clipping = TRUE;
-
-#ifdef __WIN16__
-    SelectClipRgn(GetHdc(), GetHrgnOf(region));
-#else // Win32
-    ExtSelectClipRgn(GetHdc(), GetHrgnOf(region), RGN_AND);
-#endif // Win16/32
-
-    UpdateClipBox();
+    SetClippingHrgn(region.GetHRGN());

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


@@ -347,11 +381,12 @@ void wxDC::DestroyClippingRegion()
     if (m_clipping && m_hDC)
     {
         // TODO: this should restore the previous clipping region,
     if (m_clipping && m_hDC)
     {
         // TODO: this should restore the previous clipping region,

-        // so that OnPaint processing works correctly, and the update clipping region
-        // doesn't get destroyed after the first DestroyClippingRegion.
+        //       so that OnPaint processing works correctly, and the update
+        //       clipping region doesn't get destroyed after the first
+        //       DestroyClippingRegion.

         HRGN rgn = CreateRectRgn(0, 0, 32000, 32000);
         HRGN rgn = CreateRectRgn(0, 0, 32000, 32000);

-        SelectClipRgn(GetHdc(), rgn);
-        DeleteObject(rgn);
+        ::SelectClipRgn(GetHdc(), rgn);
+        ::DeleteObject(rgn);

     }
 
     m_clipping = FALSE;
     }
 
     m_clipping = FALSE;


@@ -418,14 +453,17 @@ void wxDC::Clear()
 
     (void) ::SetMapMode(GetHdc(), MM_TEXT);
 
 
     (void) ::SetMapMode(GetHdc(), MM_TEXT);
 

-    DWORD colour = GetBkColor(GetHdc());
-    HBRUSH brush = CreateSolidBrush(colour);
-    FillRect(GetHdc(), &rect, brush);
-    DeleteObject(brush);
+    DWORD colour = ::GetBkColor(GetHdc());
+    HBRUSH brush = ::CreateSolidBrush(colour);
+    ::FillRect(GetHdc(), &rect, brush);
+    ::DeleteObject(brush);
+
+    int width = DeviceToLogicalXRel(VIEWPORT_EXTENT)*m_signX,
+        height = DeviceToLogicalYRel(VIEWPORT_EXTENT)*m_signY;

 
     ::SetMapMode(GetHdc(), MM_ANISOTROPIC);
     ::SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);
 
     ::SetMapMode(GetHdc(), MM_ANISOTROPIC);
     ::SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);

-    ::SetWindowExtEx(GetHdc(), m_windowExtX, m_windowExtY, NULL);
+    ::SetWindowExtEx(GetHdc(), width, height, NULL);

     ::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
     ::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
 }
     ::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
     ::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
 }


@@ -505,10 +543,6 @@ void wxDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
     (void)MoveToEx(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y1), NULL);
     (void)LineTo(GetHdc(), XLOG2DEV(x2), YLOG2DEV(y2));
 
     (void)MoveToEx(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y1), NULL);
     (void)LineTo(GetHdc(), XLOG2DEV(x2), YLOG2DEV(y2));
 

-    // Normalization: Windows doesn't draw the last point of the line.
-    // But apparently neither does GTK+, so we take it out again.
-//    (void)LineTo(GetHdc(), XLOG2DEV(x2) + 1, YLOG2DEV(y2));
-

     CalcBoundingBox(x1, y1);
     CalcBoundingBox(x2, y2);
 }
     CalcBoundingBox(x1, y1);
     CalcBoundingBox(x2, y2);
 }


@@ -886,7 +920,6 @@ void wxDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask
             useMask = FALSE;
         }
     }
             useMask = FALSE;
         }
     }

-

     if ( useMask )
     {
 #ifdef __WIN32__
     if ( useMask )
     {
 #ifdef __WIN32__


@@ -902,13 +935,12 @@ void wxDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask
         {
             HDC cdc = GetHdc();
             HDC hdcMem = ::CreateCompatibleDC(GetHdc());
         {
             HDC cdc = GetHdc();
             HDC hdcMem = ::CreateCompatibleDC(GetHdc());

-            ::SelectObject(hdcMem, GetHbitmapOf(bmp));
-
+            HGDIOBJ hOldBitmap = ::SelectObject(hdcMem, GetHbitmapOf(bmp));

 #if wxUSE_PALETTE
             wxPalette *pal = bmp.GetPalette();
             if ( pal && ::GetDeviceCaps(cdc,BITSPIXEL) <= 8 )
             {
 #if wxUSE_PALETTE
             wxPalette *pal = bmp.GetPalette();
             if ( pal && ::GetDeviceCaps(cdc,BITSPIXEL) <= 8 )
             {

-                oldPal = ::SelectPalette( hdcMem, GetHpalette(pal), FALSE);
+                oldPal = ::SelectPalette(hdcMem, GetHpaletteOf(*pal), FALSE);

                 ::RealizePalette(hdcMem);
             }
 #endif // wxUSE_PALETTE
                 ::RealizePalette(hdcMem);
             }
 #endif // wxUSE_PALETTE


@@ -923,6 +955,7 @@ void wxDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask
                 ::SelectPalette(hdcMem, oldPal, FALSE);
 #endif // wxUSE_PALETTE
 
                 ::SelectPalette(hdcMem, oldPal, FALSE);
 #endif // wxUSE_PALETTE
 

+            ::SelectObject(hdcMem, hOldBitmap);

             ::DeleteDC(hdcMem);
         }
 
             ::DeleteDC(hdcMem);
         }
 


@@ -959,15 +992,15 @@ void wxDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask
         }
 
 #if wxUSE_PALETTE
         }
 
 #if wxUSE_PALETTE

-            wxPalette *pal = bmp.GetPalette();
-            if ( pal && ::GetDeviceCaps(cdc,BITSPIXEL) <= 8 )
-            {
-                oldPal = ::SelectPalette( hdcMem, GetHpalette(pal), FALSE);
-                ::RealizePalette(hdcMem);
-            }
+        wxPalette *pal = bmp.GetPalette();
+        if ( pal && ::GetDeviceCaps(cdc,BITSPIXEL) <= 8 )
+        {
+            oldPal = ::SelectPalette(memdc, GetHpaletteOf(*pal), FALSE);
+            ::RealizePalette(memdc);
+        }

 #endif // wxUSE_PALETTE
 
 #endif // wxUSE_PALETTE
 

-        ::SelectObject( memdc, hbitmap );
+        HGDIOBJ hOldBitmap = ::SelectObject( memdc, hbitmap );

         ::BitBlt( cdc, x, y, width, height, memdc, 0, 0, SRCCOPY);
 
 #if wxUSE_PALETTE
         ::BitBlt( cdc, x, y, width, height, memdc, 0, 0, SRCCOPY);
 
 #if wxUSE_PALETTE


@@ -975,6 +1008,7 @@ void wxDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask
             ::SelectPalette(memdc, oldPal, FALSE);
 #endif // wxUSE_PALETTE
 
             ::SelectPalette(memdc, oldPal, FALSE);
 #endif // wxUSE_PALETTE
 

+        ::SelectObject( memdc, hOldBitmap );

         ::DeleteDC( memdc );
 
         ::SetTextColor(GetHdc(), old_textground);
         ::DeleteDC( memdc );
 
         ::SetTextColor(GetHdc(), old_textground);


@@ -1109,7 +1143,7 @@ void wxDC::DoDrawRotatedText(const wxString& text,
 
 #if wxUSE_PALETTE
 
 
 #if wxUSE_PALETTE
 

-void wxDC::SetPalette(const wxPalette& palette)
+void wxDC::DoSelectPalette(bool realize)

 {
 #ifdef __WXMICROWIN__
     if (!GetHDC()) return;
 {
 #ifdef __WXMICROWIN__
     if (!GetHDC()) return;


@@ -1123,28 +1157,44 @@ void wxDC::SetPalette(const wxPalette& palette)
         m_oldPalette = 0;
     }
 
         m_oldPalette = 0;
     }
 

-    m_palette = palette;
-
-    if (!m_palette.Ok())
+    if ( m_palette.Ok() )

     {
     {

-        // Setting a NULL colourmap is a way of restoring
-        // the original colourmap
-        if (m_oldPalette)
-        {
-            ::SelectPalette(GetHdc(), (HPALETTE) m_oldPalette, FALSE);
-            m_oldPalette = 0;
-        }
+        HPALETTE oldPal = ::SelectPalette(GetHdc(),
+                                          GetHpaletteOf(m_palette),
+                                          FALSE);
+        if (!m_oldPalette)
+            m_oldPalette = (WXHPALETTE) oldPal;

 
 

-        return;
+        if (realize)
+            ::RealizePalette(GetHdc());

     }
     }

+}

 
 

-    if (m_palette.Ok() && m_palette.GetHPALETTE())
+void wxDC::SetPalette(const wxPalette& palette)
+{
+    if ( palette.Ok() )

     {
     {

-        HPALETTE oldPal = ::SelectPalette(GetHdc(), (HPALETTE) m_palette.GetHPALETTE(), FALSE);
-        if (!m_oldPalette)
-            m_oldPalette = (WXHPALETTE) oldPal;
+        m_palette = palette;
+        DoSelectPalette(TRUE);
+    }
+}

 
 

-        ::RealizePalette(GetHdc());
+void wxDC::InitializePalette()
+{
+    if ( wxDisplayDepth() <= 8 )
+    {
+        // look for any window or parent that has a custom palette. If any has
+        // one then we need to use it in drawing operations
+        wxWindow *win = m_canvas->GetAncestorWithCustomPalette();
+
+        m_hasCustomPalette = win && win->HasCustomPalette();
+        if ( m_hasCustomPalette )
+        {
+            m_palette = win->GetPalette();
+
+            // turn on MSW translation for this palette
+            DoSelectPalette();
+        }

     }
 }
 
     }
 }
 


@@ -1249,12 +1299,12 @@ void wxDC::SetBrush(const wxBrush& brush)
         if ( stipple && stipple->Ok() )
         {
 #ifdef __WIN32__
         if ( stipple && stipple->Ok() )
         {
 #ifdef __WIN32__

-               ::SetBrushOrgEx(GetHdc(),
+            ::SetBrushOrgEx(GetHdc(),

                             m_deviceOriginX % stipple->GetWidth(),
                             m_deviceOriginY % stipple->GetHeight(),
                             NULL);  // don't need previous brush origin
 #else
                             m_deviceOriginX % stipple->GetWidth(),
                             m_deviceOriginY % stipple->GetHeight(),
                             NULL);  // don't need previous brush origin
 #else

-               ::SetBrushOrg(GetHdc(),
+            ::SetBrushOrg(GetHdc(),

                             m_deviceOriginX % stipple->GetWidth(),
                             m_deviceOriginY % stipple->GetHeight());
 #endif
                             m_deviceOriginX % stipple->GetWidth(),
                             m_deviceOriginY % stipple->GetHeight());
 #endif


@@ -1325,14 +1375,6 @@ void wxDC::SetBackgroundMode(int mode)
 
     // SetBackgroundColour now only refers to text background
     // and m_backgroundMode is used there
 
     // SetBackgroundColour now only refers to text background
     // and m_backgroundMode is used there

-
-/*
-    if (m_backgroundMode == wxTRANSPARENT)
-        ::SetBkMode(GetHdc(), TRANSPARENT);
-    else
-        ::SetBkMode(GetHdc(), OPAQUE);
-       Last change:  AC   29 Jan 101    8:54 pm
-*/

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


@@ -1412,7 +1454,7 @@ wxCoord wxDC::GetCharHeight() const
 
     GetTextMetrics(GetHdc(), &lpTextMetric);
 
 
     GetTextMetrics(GetHdc(), &lpTextMetric);
 

-    return YDEV2LOGREL(lpTextMetric.tmHeight);
+    return lpTextMetric.tmHeight;

 }
 
 wxCoord wxDC::GetCharWidth() const
 }
 
 wxCoord wxDC::GetCharWidth() const


@@ -1425,7 +1467,7 @@ wxCoord wxDC::GetCharWidth() const
 
     GetTextMetrics(GetHdc(), &lpTextMetric);
 
 
     GetTextMetrics(GetHdc(), &lpTextMetric);
 

-    return XDEV2LOGREL(lpTextMetric.tmAveCharWidth);
+    return lpTextMetric.tmAveCharWidth;

 }
 
 void wxDC::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
 }
 
 void wxDC::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,


@@ -1435,13 +1477,13 @@ void wxDC::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
 #ifdef __WXMICROWIN__
     if (!GetHDC())
     {
 #ifdef __WXMICROWIN__
     if (!GetHDC())
     {

-       if (x) *x = 0;
-       if (y) *y = 0;
-       if (descent) *descent = 0;
-       if (externalLeading) *externalLeading = 0;
-       return;
+        if (x) *x = 0;
+        if (y) *y = 0;
+        if (descent) *descent = 0;
+        if (externalLeading) *externalLeading = 0;
+        return;

     }
     }

-#endif
+#endif // __WXMICROWIN__

 
     HFONT hfontOld;
     if ( font )
 
     HFONT hfontOld;
     if ( font )


@@ -1461,10 +1503,14 @@ void wxDC::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
     GetTextExtentPoint(GetHdc(), string, string.length(), &sizeRect);
     GetTextMetrics(GetHdc(), &tm);
 
     GetTextExtentPoint(GetHdc(), string, string.length(), &sizeRect);
     GetTextMetrics(GetHdc(), &tm);
 

-    if (x) *x = XDEV2LOGREL(sizeRect.cx);
-    if (y) *y = YDEV2LOGREL(sizeRect.cy);
-    if (descent) *descent = tm.tmDescent;
-    if (externalLeading) *externalLeading = tm.tmExternalLeading;
+    if (x)
+        *x = sizeRect.cx;
+    if (y)
+        *y = sizeRect.cy;
+    if (descent)
+        *descent = tm.tmDescent;
+    if (externalLeading)
+        *externalLeading = tm.tmExternalLeading;

 
     if ( hfontOld )
     {
 
     if ( hfontOld )
     {


@@ -1480,68 +1526,67 @@ void wxDC::SetMapMode(int mode)
 
     m_mappingMode = mode;
 
 
     m_mappingMode = mode;
 

-    int pixel_width = 0;
-    int pixel_height = 0;
-    int mm_width = 0;
-    int mm_height = 0;
-
-    pixel_width = GetDeviceCaps(GetHdc(), HORZRES);
-    pixel_height = GetDeviceCaps(GetHdc(), VERTRES);
-    mm_width = GetDeviceCaps(GetHdc(), HORZSIZE);
-    mm_height = GetDeviceCaps(GetHdc(), VERTSIZE);
-
-    if ((pixel_width == 0) || (pixel_height == 0) || (mm_width == 0) || (mm_height == 0))
+    if ( mode == wxMM_TEXT )

     {
     {

-        return;
+        m_logicalScaleX =
+        m_logicalScaleY = 1.0;

     }
     }

-
-    double mm2pixelsX = pixel_width/mm_width;
-    double mm2pixelsY = pixel_height/mm_height;
-
-    switch (mode)
+    else // need to do some calculations

     {
     {

-    case wxMM_TWIPS:
-        {
-            m_logicalScaleX = (twips2mm * mm2pixelsX);
-            m_logicalScaleY = (twips2mm * mm2pixelsY);
-            break;
-        }
-    case wxMM_POINTS:
-        {
-            m_logicalScaleX = (pt2mm * mm2pixelsX);
-            m_logicalScaleY = (pt2mm * mm2pixelsY);
-            break;
-        }
-    case wxMM_METRIC:
-        {
-            m_logicalScaleX = mm2pixelsX;
-            m_logicalScaleY = mm2pixelsY;
-            break;
-        }
-    case wxMM_LOMETRIC:
+        int pixel_width = ::GetDeviceCaps(GetHdc(), HORZRES),
+            pixel_height = ::GetDeviceCaps(GetHdc(), VERTRES),
+            mm_width = ::GetDeviceCaps(GetHdc(), HORZSIZE),
+            mm_height = ::GetDeviceCaps(GetHdc(), VERTSIZE);
+
+        if ( (mm_width == 0) || (mm_height == 0) )

         {
         {

-            m_logicalScaleX = (mm2pixelsX/10.0);
-            m_logicalScaleY = (mm2pixelsY/10.0);
-            break;
+            // we can't calculate mm2pixels[XY] then!
+            return;

         }
         }

-    default:
-    case wxMM_TEXT:
+
+        double mm2pixelsX = pixel_width / mm_width,
+               mm2pixelsY = pixel_height / mm_height;
+
+        switch (mode)

         {
         {

-            m_logicalScaleX = 1.0;
-            m_logicalScaleY = 1.0;
-            break;
+            case wxMM_TWIPS:
+                m_logicalScaleX = twips2mm * mm2pixelsX;
+                m_logicalScaleY = twips2mm * mm2pixelsY;
+                break;
+
+            case wxMM_POINTS:
+                m_logicalScaleX = pt2mm * mm2pixelsX;
+                m_logicalScaleY = pt2mm * mm2pixelsY;
+                break;
+
+            case wxMM_METRIC:
+                m_logicalScaleX = mm2pixelsX;
+                m_logicalScaleY = mm2pixelsY;
+                break;
+
+            case wxMM_LOMETRIC:
+                m_logicalScaleX = mm2pixelsX / 10.0;
+                m_logicalScaleY = mm2pixelsY / 10.0;
+                break;
+
+            default:
+                wxFAIL_MSG( _T("unknown mapping mode in SetMapMode") );

         }
     }
 
         }
     }
 

-    if (::GetMapMode(GetHdc()) != MM_ANISOTROPIC)
-        ::SetMapMode(GetHdc(), MM_ANISOTROPIC);
+    // VZ: it seems very wasteful to always use MM_ANISOTROPIC when in 99% of
+    //     cases we could do with MM_TEXT and in the remaining 0.9% with
+    //     MM_ISOTROPIC (TODO!)
+    ::SetMapMode(GetHdc(), MM_ANISOTROPIC);

 
 

-    SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);
-    m_windowExtX = (int)MS_XDEV2LOGREL(VIEWPORT_EXTENT);
-    m_windowExtY = (int)MS_YDEV2LOGREL(VIEWPORT_EXTENT);
-    ::SetWindowExtEx(GetHdc(), m_windowExtX, m_windowExtY, NULL);
-    ::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
-    ::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
+    int width = DeviceToLogicalXRel(VIEWPORT_EXTENT)*m_signX,
+        height = DeviceToLogicalYRel(VIEWPORT_EXTENT)*m_signY;
+
+    ::SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);
+    ::SetWindowExtEx(GetHdc(), width, height, NULL);
+
+    ::SetViewportOrgEx(GetHdc(), m_deviceOriginX, m_deviceOriginY, NULL);
+    ::SetWindowOrgEx(GetHdc(), m_logicalOriginX, m_logicalOriginY, NULL);

 }
 
 void wxDC::SetUserScale(double x, double y)
 }
 
 void wxDC::SetUserScale(double x, double y)


@@ -1550,6 +1595,9 @@ void wxDC::SetUserScale(double x, double y)
     if (!GetHDC()) return;
 #endif
 
     if (!GetHDC()) return;
 #endif
 

+    if ( x == m_userScaleX && y == m_userScaleY )
+        return;
+

     m_userScaleX = x;
     m_userScaleY = y;
 
     m_userScaleX = x;
     m_userScaleY = y;
 


@@ -1562,10 +1610,16 @@ void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
     if (!GetHDC()) return;
 #endif
 
     if (!GetHDC()) return;
 #endif
 

-    m_signX = xLeftRight ? 1 : -1;
-    m_signY = yBottomUp ? -1 : 1;
+    int signX = xLeftRight ? 1 : -1,
+        signY = yBottomUp ? -1 : 1;

 
 

-    SetMapMode(m_mappingMode);
+    if ( signX != m_signX || signY != m_signY )
+    {
+        m_signX = signX;
+        m_signY = signY;
+
+        SetMapMode(m_mappingMode);
+    }

 }
 
 void wxDC::SetSystemScale(double x, double y)
 }
 
 void wxDC::SetSystemScale(double x, double y)


@@ -1574,6 +1628,9 @@ void wxDC::SetSystemScale(double x, double y)
     if (!GetHDC()) return;
 #endif
 
     if (!GetHDC()) return;
 #endif
 

+    if ( x == m_scaleX && y == m_scaleY )
+        return;
+

     m_scaleX = x;
     m_scaleY = y;
 
     m_scaleX = x;
     m_scaleY = y;
 


@@ -1586,6 +1643,9 @@ void wxDC::SetLogicalOrigin(wxCoord x, wxCoord y)
     if (!GetHDC()) return;
 #endif
 
     if (!GetHDC()) return;
 #endif
 

+    if ( x == m_logicalOriginX && y == m_logicalOriginY )
+        return;
+

     m_logicalOriginX = x;
     m_logicalOriginY = y;
 
     m_logicalOriginX = x;
     m_logicalOriginY = y;
 


@@ -1598,6 +1658,9 @@ void wxDC::SetDeviceOrigin(wxCoord x, wxCoord y)
     if (!GetHDC()) return;
 #endif
 
     if (!GetHDC()) return;
 #endif
 

+    if ( x == m_deviceOriginX && y == m_deviceOriginY )
+        return;
+

     m_deviceOriginX = x;
     m_deviceOriginY = y;
 
     m_deviceOriginX = x;
     m_deviceOriginY = y;
 


@@ -1610,46 +1673,46 @@ void wxDC::SetDeviceOrigin(wxCoord x, wxCoord y)
 
 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
 {
 
 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
 {

-    double xRel = x - m_deviceOriginX;
-    xRel /= m_logicalScaleX*m_userScaleX*m_signX*m_scaleX;
-    return (wxCoord)(xRel + m_logicalOriginX);
+    return DeviceToLogicalXRel(x - m_deviceOriginX)*m_signX + m_logicalOriginX;

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

-    return (wxCoord) ((x)/(m_logicalScaleX*m_userScaleX*m_signX*m_scaleX));
+    // 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
 {
 }
 
 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
 {

-    double yRel = y - m_deviceOriginY;
-    yRel /= m_logicalScaleY*m_userScaleY*m_signY*m_scaleY;
-    return (wxCoord)(yRel + m_logicalOriginY);
+    return DeviceToLogicalYRel(y - m_deviceOriginY)*m_signY + m_logicalOriginY;

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

-    return (wxCoord) ((y)/(m_logicalScaleY*m_userScaleY*m_signY*m_scaleY));
+    // 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
 {
 }
 
 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
 {

-    return (wxCoord) ((x - m_logicalOriginX)*m_logicalScaleX*m_userScaleX*m_signX*m_scaleX + m_deviceOriginX);
+    return LogicalToDeviceXRel(x - m_logicalOriginX)*m_signX + m_deviceOriginX;

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

-    return (wxCoord) (x*m_logicalScaleX*m_userScaleX*m_signX*m_scaleX);
+    // 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
 {
 }
 
 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
 {

-    return (wxCoord) ((y - m_logicalOriginY)*m_logicalScaleY*m_userScaleY*m_signY*m_scaleY + m_deviceOriginY);
+    return LogicalToDeviceYRel(y - m_logicalOriginY)*m_signY + m_deviceOriginY;

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

-    return (wxCoord) (y*m_logicalScaleY*m_userScaleY*m_signY*m_scaleY);
+    // axis orientation is not taken into account for conversion of a distance
+    return (wxCoord) (y*m_logicalScaleY*m_userScaleY*m_scaleY);

 }
 
 // ---------------------------------------------------------------------------
 }
 
 // ---------------------------------------------------------------------------


@@ -1769,8 +1832,8 @@ bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
             dc_buffer = ::CreateCompatibleDC(GetHdc());
             buffer_bmap = ::CreateCompatibleBitmap(GetHdc(), width, height);
 #endif // wxUSE_DC_CACHEING/!wxUSE_DC_CACHEING
             dc_buffer = ::CreateCompatibleDC(GetHdc());
             buffer_bmap = ::CreateCompatibleBitmap(GetHdc(), width, height);
 #endif // wxUSE_DC_CACHEING/!wxUSE_DC_CACHEING

-            ::SelectObject(dc_mask, (HBITMAP) mask->GetMaskBitmap());
-            ::SelectObject(dc_buffer, buffer_bmap);
+            HGDIOBJ hOldMaskBitmap = ::SelectObject(dc_mask, (HBITMAP) mask->GetMaskBitmap());
+            HGDIOBJ hOldBufferBitmap = ::SelectObject(dc_buffer, buffer_bmap);

 
             // copy dest to buffer
             if ( !::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
 
             // copy dest to buffer
             if ( !::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,


@@ -1816,8 +1879,8 @@ bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
             }
 
             // tidy up temporary DCs and bitmap
             }
 
             // tidy up temporary DCs and bitmap

-            ::SelectObject(dc_mask, 0);
-            ::SelectObject(dc_buffer, 0);
+            ::SelectObject(dc_mask, hOldMaskBitmap);
+            ::SelectObject(dc_buffer, hOldBufferBitmap);

 
 #if !wxUSE_DC_CACHEING
             {
 
 #if !wxUSE_DC_CACHEING
             {


@@ -1860,8 +1923,30 @@ void wxDC::DoGetSizeMM(int *w, int *h) const
     if (!GetHDC()) return;
 #endif
 
     if (!GetHDC()) return;
 #endif
 

-    if ( w ) *w = ::GetDeviceCaps(GetHdc(), HORZSIZE);
-    if ( h ) *h = ::GetDeviceCaps(GetHdc(), VERTSIZE);
+    // if we implement it in terms of DoGetSize() instead of directly using the
+    // results returned by GetDeviceCaps(HORZ/VERTSIZE) as was done before, it
+    // will also work for wxWindowDC and wxClientDC even though their size is
+    // not the same as the total size of the screen
+    int wPixels, hPixels;
+    DoGetSize(&wPixels, &hPixels);
+
+    if ( w )
+    {
+        int wTotal = ::GetDeviceCaps(GetHdc(), HORZRES);
+
+        wxCHECK_RET( wTotal, _T("0 width device?") );
+
+        *w = (wPixels * ::GetDeviceCaps(GetHdc(), HORZSIZE)) / wTotal;
+    }
+
+    if ( h )
+    {
+        int hTotal = ::GetDeviceCaps(GetHdc(), VERTRES);
+
+        wxCHECK_RET( hTotal, _T("0 height device?") );
+
+        *h = (hPixels * ::GetDeviceCaps(GetHdc(), VERTSIZE)) / hTotal;
+    }

 }
 
 wxSize wxDC::GetPPI() const
 }
 
 wxSize wxDC::GetPPI() const