If zero time is specified, don't try to sleep when using a timer.

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

diff --git a/src/msw/dc.cpp b/src/msw/dc.cpp
index f4aeebe02b04bc93e42b8494708019cc977e86dd..63eadae25369f269c5436476baf88eb52017c971 100644 (file)
--- a/src/msw/dc.cpp
+++ b/src/msw/dc.cpp
@@ -43,6 +43,7 @@
 #include "wx/sysopt.h"
 #include "wx/dcprint.h"
 #include "wx/module.h"
 #include "wx/sysopt.h"
 #include "wx/dcprint.h"
 #include "wx/module.h"

+#include "wx/dynload.h"

 
 #include <string.h>
 #include <math.h>
 
 #include <string.h>
 #include <math.h>


@@ -57,6 +58,11 @@
     #include <print.h>
 #endif
 
     #include <print.h>
 #endif
 

+/* Quaternary raster codes */
+#ifndef MAKEROP4
+#define MAKEROP4(fore,back) (DWORD)((((back) << 8) & 0xFF000000) | (fore))
+#endif
+

 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxDCBase)
 
 // ---------------------------------------------------------------------------
 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxDCBase)
 
 // ---------------------------------------------------------------------------


@@ -127,6 +133,30 @@ private:
     bool m_changed;
 };
 
     bool m_changed;
 };
 

+// this class saves the old stretch blit mode during its life time
+class StretchBltModeChanger
+{
+public:
+    StretchBltModeChanger(HDC hdc, int mode)
+        : m_hdc(hdc)
+    {
+        m_modeOld = ::SetStretchBltMode(m_hdc, mode);
+        if ( !m_modeOld )
+            wxLogLastError(_T("SetStretchBltMode"));
+    }
+
+    ~StretchBltModeChanger()
+    {
+        if ( !::SetStretchBltMode(m_hdc, m_modeOld) )
+            wxLogLastError(_T("SetStretchBltMode"));
+    }
+
+private:
+    const HDC m_hdc;
+
+    int m_modeOld;
+};
+

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


@@ -137,7 +167,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);


@@ -242,10 +273,12 @@ void wxDC::SelectOldObjects(WXHDC dc)
         if (m_oldBitmap)
         {
             ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);
         if (m_oldBitmap)
         {
             ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);

+#ifdef __WXDEBUG__

             if (m_selectedBitmap.Ok())
             {
                 m_selectedBitmap.SetSelectedInto(NULL);
             }
             if (m_selectedBitmap.Ok())
             {
                 m_selectedBitmap.SetSelectedInto(NULL);
             }

+#endif

         }
         m_oldBitmap = 0;
         if (m_oldPen)
         }
         m_oldBitmap = 0;
         if (m_oldPen)


@@ -467,16 +500,17 @@ void wxDC::Clear()
     ::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
 }
 
     ::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
 }
 

-void wxDC::DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, int style)
+bool wxDC::DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, int style)

 {
 #ifdef __WXMICROWIN__
 {
 #ifdef __WXMICROWIN__

-    if (!GetHDC()) return;
+    if (!GetHDC()) return FALSE;

 #endif
 
 #endif
 

-    if ( !::ExtFloodFill(GetHdc(), XLOG2DEV(x), YLOG2DEV(y),
+    bool success = (0 != ::ExtFloodFill(GetHdc(), XLOG2DEV(x), YLOG2DEV(y),

                          col.GetPixel(),
                          style == wxFLOOD_SURFACE ? FLOODFILLSURFACE
                          col.GetPixel(),
                          style == wxFLOOD_SURFACE ? FLOODFILLSURFACE

-                                                  : FLOODFILLBORDER) )
+                                                  : FLOODFILLBORDER) ) ;
+    if (!success)

     {
         // quoting from the MSDN docs:
         //
     {
         // quoting from the MSDN docs:
         //


@@ -494,6 +528,8 @@ void wxDC::DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, int style)
     }
 
     CalcBoundingBox(x, y);
     }
 
     CalcBoundingBox(x, y);

+    
+    return success;

 }
 
 bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
 }
 
 bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const


@@ -906,6 +942,65 @@ void wxDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask
     HPALETTE oldPal = 0;
 #endif // wxUSE_PALETTE
 
     HPALETTE oldPal = 0;
 #endif // wxUSE_PALETTE
 

+    // do we have AlphaBlend() and company in the headers?
+#ifdef AC_SRC_OVER
+    if ( bmp.HasAlpha() )
+    {
+        // yes, now try to see if we have it during run-time
+
+        typedef BOOL (WINAPI *AlphaBlend_t)(HDC,int,int,int,int,
+                                            HDC,int,int,int,int,
+                                            BLENDFUNCTION);
+
+        // bitmaps can be drawn only from GUI thread so there is no need to
+        // protect this static variable from multiple threads
+        static bool s_triedToLoad = FALSE;
+        static AlphaBlend_t pfnAlphaBlend = NULL;
+        if ( !s_triedToLoad )
+        {
+            s_triedToLoad = TRUE;
+
+            wxDynamicLibrary dll(_T("msimg32.dll"));
+            if ( dll.IsLoaded() )
+            {
+                pfnAlphaBlend = (AlphaBlend_t)dll.GetSymbol(_T("AlphaBlend"));
+                if ( pfnAlphaBlend )
+                {
+                    // we must keep the DLL loaded if we want to be able to
+                    // call AlphaBlend() so just never unload it at all
+                    dll.Detach();
+                }
+            }
+        }
+
+        if ( pfnAlphaBlend )
+        {
+            MemoryHDC hdcMem;
+            SelectInHDC select(hdcMem, GetHbitmapOf(bmp));
+
+#ifndef AC_SRC_ALPHA
+    #define AC_SRC_ALPHA 1
+#endif
+
+            BLENDFUNCTION bf;
+            bf.BlendOp = AC_SRC_OVER;
+            bf.BlendFlags = 0;
+            bf.SourceConstantAlpha = 0xff;
+            bf.AlphaFormat = AC_SRC_ALPHA;
+
+            if ( !pfnAlphaBlend(GetHdc(), x, y, width, height,
+                                hdcMem, 0, 0, width, height,
+                                bf) )
+            {
+                wxLogLastError(_T("AlphaBlend"));
+            }
+
+            return;
+        }
+        //else: AlphaBlend() not available
+    }
+#endif // defined(AC_SRC_OVER)
+

     if ( useMask )
     {
         wxMask *mask = bmp.GetMask();
     if ( useMask )
     {
         wxMask *mask = bmp.GetMask();


@@ -939,7 +1034,7 @@ void wxDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask
             wxPalette *pal = bmp.GetPalette();
             if ( pal && ::GetDeviceCaps(cdc,BITSPIXEL) <= 8 )
             {
             wxPalette *pal = bmp.GetPalette();
             if ( pal && ::GetDeviceCaps(cdc,BITSPIXEL) <= 8 )
             {

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

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


@@ -994,7 +1089,7 @@ void wxDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask
         wxPalette *pal = bmp.GetPalette();
         if ( pal && ::GetDeviceCaps(cdc,BITSPIXEL) <= 8 )
         {
         wxPalette *pal = bmp.GetPalette();
         if ( pal && ::GetDeviceCaps(cdc,BITSPIXEL) <= 8 )
         {

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

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


@@ -1125,13 +1220,13 @@ void wxDC::DoDrawRotatedText(const wxString& text,
 
         // "upper left" and "upper right"
         CalcBoundingBox(x, y);
 
         // "upper left" and "upper right"
         CalcBoundingBox(x, y);

-        CalcBoundingBox(x + w*cos(rad), y - h*sin(rad));
+        CalcBoundingBox(x + wxCoord(w*cos(rad)), y - wxCoord(h*sin(rad)));

 
         // "bottom left" and "bottom right"
         x += (wxCoord)(h*sin(rad));
         y += (wxCoord)(h*cos(rad));
         CalcBoundingBox(x, y);
 
         // "bottom left" and "bottom right"
         x += (wxCoord)(h*sin(rad));
         y += (wxCoord)(h*cos(rad));
         CalcBoundingBox(x, y);

-        CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
+        CalcBoundingBox(x + wxCoord(h*sin(rad)), y + wxCoord(h*cos(rad)));

     }
 #endif
 }
     }
 #endif
 }


@@ -1142,7 +1237,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;


@@ -1156,28 +1251,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);
+    }
+}
+
+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();

 
 

-        ::RealizePalette(GetHdc());
+            // turn on MSW translation for this palette
+            DoSelectPalette();
+        }

     }
 }
 
     }
 }
 


@@ -1783,10 +1894,16 @@ bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
         if (wxSystemOptions::GetOptionInt(wxT("no-maskblt")) == 0)
 #endif
         {
         if (wxSystemOptions::GetOptionInt(wxT("no-maskblt")) == 0)
 #endif
         {

-           success = ::MaskBlt(GetHdc(), xdest, ydest, width, height,
-                            GetHdcOf(*source), xsrc, ysrc,
-                            (HBITMAP)mask->GetMaskBitmap(), xsrcMask, ysrcMask,
-                            MAKEROP4(dwRop, DSTCOPY)) != 0;
+           success = ::MaskBlt
+                       (
+                            GetHdc(),
+                            xdest, ydest, width, height,
+                            GetHdcOf(*source),
+                            xsrc, ysrc,
+                            (HBITMAP)mask->GetMaskBitmap(),
+                            xsrcMask, ysrcMask,
+                            MAKEROP4(dwRop, DSTCOPY)
+                        ) != 0;

         }
 
         if ( !success )
         }
 
         if ( !success )


@@ -1876,14 +1993,39 @@ bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
     }
     else // no mask, just BitBlt() it
     {
     }
     else // no mask, just BitBlt() it
     {

-        success = ::BitBlt(GetHdc(), xdest, ydest,
-                           (int)width, (int)height,
-                           GetHdcOf(*source), xsrc, ysrc, dwRop) != 0;
+        // use StretchBlt() if available
+        if ( ::GetDeviceCaps(GetHdc(), RASTERCAPS) & RC_STRETCHBLT )
+        {
+            StretchBltModeChanger changeMode(GetHdc(), COLORONCOLOR);
+
+            success = ::StretchBlt
+                        (
+                            GetHdc(),
+                            xdest, ydest, width, height,
+                            GetHdcOf(*source),
+                            xsrc, ysrc, width, height,
+                            dwRop
+                        ) != 0;
+        }
+        else
+        {
+            success = ::BitBlt
+                        (
+                            GetHdc(),
+                            xdest, ydest,
+                            (int)width, (int)height,
+                            GetHdcOf(*source),
+                            xsrc, ysrc,
+                            dwRop
+                        ) != 0;
+        }
+

         if ( !success )
         {
         if ( !success )
         {

-            wxLogLastError(wxT("BitBlt"));
+            wxLogLastError(wxT("BitBlt/StretchBlt"));

         }
     }
         }
     }

+

     ::SetTextColor(GetHdc(), old_textground);
     ::SetBkColor(GetHdc(), old_background);
 
     ::SetTextColor(GetHdc(), old_textground);
     ::SetBkColor(GetHdc(), old_background);
 


@@ -1906,8 +2048,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


@@ -1933,25 +2097,6 @@ void wxDC::SetLogicalScale(double x, double y)
     m_logicalScaleY = y;
 }
 
     m_logicalScaleY = y;
 }
 

-#if WXWIN_COMPATIBILITY
-void wxDC::DoGetTextExtent(const wxString& string, float *x, float *y,
-                         float *descent, float *externalLeading,
-                         wxFont *theFont, bool use16bit) const
-{
-#ifdef __WXMICROWIN__
-    if (!GetHDC()) return;
-#endif
-
-    wxCoord x1, y1, descent1, externalLeading1;
-    GetTextExtent(string, & x1, & y1, & descent1, & externalLeading1, theFont, use16bit);
-    *x = x1; *y = y1;
-    if (descent)
-        *descent = descent1;
-    if (externalLeading)
-        *externalLeading = externalLeading1;
-}
-#endif
-

 #if wxUSE_DC_CACHEING
 
 /*
 #if wxUSE_DC_CACHEING
 
 /*


@@ -2066,12 +2211,12 @@ void wxDC::AddToDCCache(wxDCCacheEntry* entry)
 
 void wxDC::ClearCache()
 {
 
 void wxDC::ClearCache()
 {

-    sm_bitmapCache.DeleteContents(TRUE);
-    sm_bitmapCache.Clear();
-    sm_bitmapCache.DeleteContents(FALSE);

     sm_dcCache.DeleteContents(TRUE);
     sm_dcCache.Clear();
     sm_dcCache.DeleteContents(FALSE);
     sm_dcCache.DeleteContents(TRUE);
     sm_dcCache.Clear();
     sm_dcCache.DeleteContents(FALSE);

+    sm_bitmapCache.DeleteContents(TRUE);
+    sm_bitmapCache.Clear();
+    sm_bitmapCache.DeleteContents(FALSE);

 }
 
 // Clean up cache at app exit
 }
 
 // Clean up cache at app exit