]> git.saurik.com Git - wxWidgets.git/blobdiff - src/msw/dc.cpp
Filter index wasn't being set for multiple file dialog
[wxWidgets.git] / src / msw / dc.cpp
index c153967b61f0ad8622bc82238a0529ac9dcdfa54..f7200155db24ffded446ed38990df16195398767 100644 (file)
@@ -17,7 +17,7 @@
 // headers
 // ---------------------------------------------------------------------------
 
 // headers
 // ---------------------------------------------------------------------------
 
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
     #pragma implementation "dc.h"
 #endif
 
     #pragma implementation "dc.h"
 #endif
 
     #include "wx/icon.h"
 #endif
 
     #include "wx/icon.h"
 #endif
 
+#include "wx/msw/private.h" // needs to be before #include <commdlg.h>
+
 #include "wx/sysopt.h"
 #include "wx/dcprint.h"
 #include "wx/module.h"
 #include "wx/dynload.h"
 #include "wx/sysopt.h"
 #include "wx/dcprint.h"
 #include "wx/module.h"
 #include "wx/dynload.h"
+
+#ifdef wxHAVE_RAW_BITMAP
 #include "wx/rawbmp.h"
 #include "wx/rawbmp.h"
+#endif
 
 #include <string.h>
 #include <math.h>
 
 
 #include <string.h>
 #include <math.h>
 
-#include "wx/msw/private.h" // needs to be before #include <commdlg.h>
-
 #if wxUSE_COMMON_DIALOGS && !defined(__WXMICROWIN__)
     #include <commdlg.h>
 #endif
 #if wxUSE_COMMON_DIALOGS && !defined(__WXMICROWIN__)
     #include <commdlg.h>
 #endif
@@ -114,9 +117,24 @@ static const int MM_METRIC = 10;
 // convert degrees to radians
 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
 
 // convert degrees to radians
 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
 
+// call AlphaBlend() to blit contents of hdcSrc to hdcDst using alpha
+//
+// NB: bmpSrc is the bitmap selected in hdcSrc, it is not really needed
+//     to pass it to this function but as we already have it at the point
+//     of call anyhow we do
+//
+// return true if we could draw the bitmap in one way or the other, false
+// otherwise
+static bool AlphaBlt(HDC hdcDst,
+                     int x, int y, int w, int h,
+                     HDC hdcSrc,
+                     const wxBitmap& bmpSrc);
+
+#ifdef wxHAVE_RAW_BITMAP
 // our (limited) AlphaBlend() replacement
 static void
 // our (limited) AlphaBlend() replacement
 static void
-wxAlphaBlend(wxDC& dc, int x, int y, int w, int h, const wxBitmap& bmp);
+wxAlphaBlend(HDC hdcDst, int x, int y, int w, int h, const wxBitmap& bmp);
+#endif
 
 // ----------------------------------------------------------------------------
 // private classes
 
 // ----------------------------------------------------------------------------
 // private classes
@@ -140,6 +158,8 @@ private:
     COLORREF m_colFgOld, m_colBgOld;
 
     bool m_changed;
     COLORREF m_colFgOld, m_colBgOld;
 
     bool m_changed;
+
+    DECLARE_NO_COPY_CLASS(wxColourChanger)
 };
 
 // this class saves the old stretch blit mode during its life time
 };
 
 // this class saves the old stretch blit mode during its life time
@@ -149,21 +169,27 @@ public:
     StretchBltModeChanger(HDC hdc, int mode)
         : m_hdc(hdc)
     {
     StretchBltModeChanger(HDC hdc, int mode)
         : m_hdc(hdc)
     {
+#ifndef __WXWINCE__
         m_modeOld = ::SetStretchBltMode(m_hdc, mode);
         if ( !m_modeOld )
             wxLogLastError(_T("SetStretchBltMode"));
         m_modeOld = ::SetStretchBltMode(m_hdc, mode);
         if ( !m_modeOld )
             wxLogLastError(_T("SetStretchBltMode"));
+#endif
     }
 
     ~StretchBltModeChanger()
     {
     }
 
     ~StretchBltModeChanger()
     {
+#ifndef __WXWINCE__
         if ( !::SetStretchBltMode(m_hdc, m_modeOld) )
             wxLogLastError(_T("SetStretchBltMode"));
         if ( !::SetStretchBltMode(m_hdc, m_modeOld) )
             wxLogLastError(_T("SetStretchBltMode"));
+#endif
     }
 
 private:
     const HDC m_hdc;
 
     int m_modeOld;
     }
 
 private:
     const HDC m_hdc;
 
     int m_modeOld;
+
+    DECLARE_NO_COPY_CLASS(StretchBltModeChanger)
 };
 
 // ===========================================================================
 };
 
 // ===========================================================================
@@ -356,7 +382,7 @@ void wxDC::SetClippingHrgn(WXHRGN hrgn)
     // 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)
     // 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__
+#if defined(__WIN16__) || defined(__WXWINCE__)
     RECT rectClip;
     if ( !::GetClipBox(GetHdc(), &rectClip) )
         return;
     RECT rectClip;
     if ( !::GetClipBox(GetHdc(), &rectClip) )
         return;
@@ -492,7 +518,9 @@ void wxDC::Clear()
         rect.bottom = m_selectedBitmap.GetHeight();
     }
 
         rect.bottom = m_selectedBitmap.GetHeight();
     }
 
+#ifndef __WXWINCE__
     (void) ::SetMapMode(GetHdc(), MM_TEXT);
     (void) ::SetMapMode(GetHdc(), MM_TEXT);
+#endif
 
     DWORD colour = ::GetBkColor(GetHdc());
     HBRUSH brush = ::CreateSolidBrush(colour);
 
     DWORD colour = ::GetBkColor(GetHdc());
     HBRUSH brush = ::CreateSolidBrush(colour);
@@ -502,15 +530,22 @@ void wxDC::Clear()
     int width = DeviceToLogicalXRel(VIEWPORT_EXTENT)*m_signX,
         height = DeviceToLogicalYRel(VIEWPORT_EXTENT)*m_signY;
 
     int width = DeviceToLogicalXRel(VIEWPORT_EXTENT)*m_signX,
         height = DeviceToLogicalYRel(VIEWPORT_EXTENT)*m_signY;
 
+#ifndef __WXWINCE__
     ::SetMapMode(GetHdc(), MM_ANISOTROPIC);
     ::SetMapMode(GetHdc(), MM_ANISOTROPIC);
+
     ::SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);
     ::SetWindowExtEx(GetHdc(), width, height, NULL);
     ::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
     ::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
     ::SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);
     ::SetWindowExtEx(GetHdc(), width, height, NULL);
     ::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
     ::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
+#endif
 }
 
 bool wxDC::DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, int style)
 {
 }
 
 bool wxDC::DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, int style)
 {
+#ifdef __WXWINCE__
+    return FALSE;
+#else
+
 #ifdef __WXMICROWIN__
     if (!GetHDC()) return FALSE;
 #endif
 #ifdef __WXMICROWIN__
     if (!GetHDC()) return FALSE;
 #endif
@@ -537,8 +572,9 @@ bool wxDC::DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, int style)
     }
 
     CalcBoundingBox(x, y);
     }
 
     CalcBoundingBox(x, y);
-    
+
     return success;
     return success;
+#endif
 }
 
 bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
 }
 
 bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
@@ -568,11 +604,8 @@ void wxDC::DoCrossHair(wxCoord x, wxCoord y)
     wxCoord x2 = x+VIEWPORT_EXTENT;
     wxCoord y2 = y+VIEWPORT_EXTENT;
 
     wxCoord x2 = x+VIEWPORT_EXTENT;
     wxCoord y2 = y+VIEWPORT_EXTENT;
 
-    (void)MoveToEx(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y), NULL);
-    (void)LineTo(GetHdc(), XLOG2DEV(x2), YLOG2DEV(y));
-
-    (void)MoveToEx(GetHdc(), XLOG2DEV(x), YLOG2DEV(y1), NULL);
-    (void)LineTo(GetHdc(), XLOG2DEV(x), YLOG2DEV(y2));
+    wxDrawLine(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y));
+    wxDrawLine(GetHdc(), XLOG2DEV(x), YLOG2DEV(y1), XLOG2DEV(x), YLOG2DEV(y2));
 
     CalcBoundingBox(x1, y1);
     CalcBoundingBox(x2, y2);
 
     CalcBoundingBox(x1, y1);
     CalcBoundingBox(x2, y2);
@@ -584,8 +617,7 @@ void wxDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
     if (!GetHDC()) return;
 #endif
 
     if (!GetHDC()) return;
 #endif
 
-    (void)MoveToEx(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y1), NULL);
-    (void)LineTo(GetHdc(), XLOG2DEV(x2), YLOG2DEV(y2));
+    wxDrawLine(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2));
 
     CalcBoundingBox(x1, y1);
     CalcBoundingBox(x2, y2);
 
     CalcBoundingBox(x1, y1);
     CalcBoundingBox(x2, y2);
@@ -597,6 +629,15 @@ void wxDC::DoDrawArc(wxCoord x1, wxCoord y1,
                      wxCoord x2, wxCoord y2,
                      wxCoord xc, wxCoord yc)
 {
                      wxCoord x2, wxCoord y2,
                      wxCoord xc, wxCoord yc)
 {
+#ifdef __WXWINCE__
+    // Slower emulation since WinCE doesn't support Pie and Arc
+    double r = sqrt( (x1-xc)*(x1-xc) + (y1-yc)*(y1-yc) );
+    double sa = acos((x1-xc)/r)/M_PI*180; // between 0 and 180
+    if( y1>yc ) sa = -sa; // below center
+    double ea = atan2(yc-y2, x2-xc)/M_PI*180;
+    DoDrawEllipticArcRot( xc-r, yc-r, 2*r, 2*r, sa, ea );
+#else
+
 #ifdef __WXMICROWIN__
     if (!GetHDC()) return;
 #endif
 #ifdef __WXMICROWIN__
     if (!GetHDC()) return;
 #endif
@@ -644,6 +685,7 @@ void wxDC::DoDrawArc(wxCoord x1, wxCoord y1,
 
     CalcBoundingBox(xc - r, yc - r);
     CalcBoundingBox(xc + r, yc + r);
 
     CalcBoundingBox(xc - r, yc - r);
     CalcBoundingBox(xc + r, yc + r);
+#endif
 }
 
 void wxDC::DoDrawCheckMark(wxCoord x1, wxCoord y1,
 }
 
 void wxDC::DoDrawCheckMark(wxCoord x1, wxCoord y1,
@@ -656,14 +698,18 @@ void wxDC::DoDrawCheckMark(wxCoord x1, wxCoord y1,
     wxCoord x2 = x1 + width,
             y2 = y1 + height;
 
     wxCoord x2 = x1 + width,
             y2 = y1 + height;
 
-#if defined(__WIN32__) && !defined(__SC__) && !defined(__WXMICROWIN__)
+#if defined(__WIN32__) && !defined(__SYMANTEC__) && !defined(__WXMICROWIN__)
     RECT rect;
     rect.left   = x1;
     rect.top    = y1;
     rect.right  = x2;
     rect.bottom = y2;
 
     RECT rect;
     rect.left   = x1;
     rect.top    = y1;
     rect.right  = x2;
     rect.bottom = y2;
 
+#ifdef __WXWINCE__
+    DrawFrameControl(GetHdc(), &rect, DFC_BUTTON, DFCS_BUTTONCHECK);
+#else
     DrawFrameControl(GetHdc(), &rect, DFC_MENU, DFCS_MENUCHECK);
     DrawFrameControl(GetHdc(), &rect, DFC_MENU, DFCS_MENUCHECK);
+#endif
 #else // Win16
     // In WIN16, draw a cross
     HPEN blackPen = ::CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
 #else // Win16
     // In WIN16, draw a cross
     HPEN blackPen = ::CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
@@ -722,9 +768,13 @@ void wxDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffs
 
             CalcBoundingBox(cpoints[i].x, cpoints[i].y);
         }
 
             CalcBoundingBox(cpoints[i].x, cpoints[i].y);
         }
+#ifndef __WXWINCE__
         int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
         int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
+#endif
         (void)Polygon(GetHdc(), cpoints, n);
         (void)Polygon(GetHdc(), cpoints, n);
+#ifndef __WXWINCE__
         SetPolyFillMode(GetHdc(),prev);
         SetPolyFillMode(GetHdc(),prev);
+#endif
         delete[] cpoints;
     }
     else
         delete[] cpoints;
     }
     else
@@ -733,9 +783,13 @@ void wxDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffs
         for (i = 0; i < n; i++)
             CalcBoundingBox(points[i].x, points[i].y);
 
         for (i = 0; i < n; i++)
             CalcBoundingBox(points[i].x, points[i].y);
 
+#ifndef __WXWINCE__
         int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
         int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
+#endif
         (void)Polygon(GetHdc(), (POINT*) points, n);
         (void)Polygon(GetHdc(), (POINT*) points, n);
+#ifndef __WXWINCE__
         SetPolyFillMode(GetHdc(),prev);
         SetPolyFillMode(GetHdc(),prev);
+#endif
     }
 }
 
     }
 }
 
@@ -824,11 +878,7 @@ void wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord h
 
     if (radius < 0.0)
     {
 
     if (radius < 0.0)
     {
-        double smallest = 0.0;
-        if (width < height)
-            smallest = width;
-        else
-            smallest = height;
+        double smallest = (width < height) ? width : height;
         radius = (- radius * smallest);
     }
 
         radius = (- radius * smallest);
     }
 
@@ -871,6 +921,10 @@ void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 // Chris Breeze 20/5/98: first implementation of DrawEllipticArc on Windows
 void wxDC::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea)
 {
 // Chris Breeze 20/5/98: first implementation of DrawEllipticArc on Windows
 void wxDC::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea)
 {
+#ifdef __WXWINCE__
+    DoDrawEllipticArcRot( x, y, w, h, sa, ea );
+#else
+
 #ifdef __WXMICROWIN__
     if (!GetHDC()) return;
 #endif
 #ifdef __WXMICROWIN__
     if (!GetHDC()) return;
 #endif
@@ -914,6 +968,7 @@ void wxDC::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,d
 
     CalcBoundingBox(x, y);
     CalcBoundingBox(x2, y2);
 
     CalcBoundingBox(x, y);
     CalcBoundingBox(x2, y2);
+#endif
 }
 
 void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
 }
 
 void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
@@ -951,68 +1006,14 @@ 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() )
     {
     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);
+        MemoryHDC hdcMem;
+        SelectInHDC select(hdcMem, GetHbitmapOf(bmp));
 
 
-        // 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;
-
-            // don't give errors about the DLL being unavailable, we're
-            // prepared to handle this
-            wxLogNull nolog;
-
-            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, not a
-                    // big deal
-                    dll.Detach();
-                }
-            }
-        }
-
-        if ( pfnAlphaBlend )
-        {
-            MemoryHDC hdcMem;
-            SelectInHDC select(hdcMem, GetHbitmapOf(bmp));
-
-            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"));
-            }
-        }
-        else // use our own (probably much slower) implementation
-        {
-            wxAlphaBlend(*this, x, y, width, height, bmp);
-        }
-
-        return;
+        if ( AlphaBlt(GetHdc(), x, y, width, height, hdcMem, bmp) )
+            return;
     }
     }
-#endif // defined(AC_SRC_OVER)
 
     if ( useMask )
     {
 
     if ( useMask )
     {
@@ -1158,11 +1159,19 @@ void wxDC::DrawAnyText(const wxString& text, wxCoord x, wxCoord y)
     SetBkMode(GetHdc(), m_backgroundMode == wxTRANSPARENT ? TRANSPARENT
                                                           : OPAQUE);
 
     SetBkMode(GetHdc(), m_backgroundMode == wxTRANSPARENT ? TRANSPARENT
                                                           : OPAQUE);
 
+#ifdef __WXWINCE__
+    if ( ::ExtTextOut(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), 0, NULL,
+                   text.c_str(), text.length(), NULL) == 0 )
+    {
+        wxLogLastError(wxT("TextOut"));
+    }
+#else
     if ( ::TextOut(GetHdc(), XLOG2DEV(x), YLOG2DEV(y),
                    text.c_str(), text.length()) == 0 )
     {
         wxLogLastError(wxT("TextOut"));
     }
     if ( ::TextOut(GetHdc(), XLOG2DEV(x), YLOG2DEV(y),
                    text.c_str(), text.length()) == 0 )
     {
         wxLogLastError(wxT("TextOut"));
     }
+#endif
 
     // restore the old parameters (text foreground colour may be left because
     // it never is set to anything else, but background should remain
 
     // restore the old parameters (text foreground colour may be left because
     // it never is set to anything else, but background should remain
@@ -1419,8 +1428,7 @@ void wxDC::SetBrush(const wxBrush& brush)
 
         if ( m_brush.GetResourceHandle() )
         {
 
         if ( m_brush.GetResourceHandle() )
         {
-            HBRUSH b = 0;
-            b = (HBRUSH) ::SelectObject(GetHdc(), (HBRUSH)m_brush.GetResourceHandle());
+            HBRUSH b = (HBRUSH) ::SelectObject(GetHdc(), (HBRUSH)m_brush.GetResourceHandle());
             if (!m_oldBrush)
                 m_oldBrush = (WXHBRUSH) b;
         }
             if (!m_oldBrush)
                 m_oldBrush = (WXHBRUSH) b;
         }
@@ -1435,40 +1443,9 @@ void wxDC::SetBackground(const wxBrush& brush)
 
     m_backgroundBrush = brush;
 
 
     m_backgroundBrush = brush;
 
-    if (!m_backgroundBrush.Ok())
-        return;
-
-    if (m_canvas)
+    if ( m_backgroundBrush.Ok() )
     {
     {
-        bool customColours = TRUE;
-        // If we haven't specified wxUSER_COLOURS, don't allow the panel/dialog box to
-        // change background colours from the control-panel specified colours.
-        if (m_canvas->IsKindOf(CLASSINFO(wxWindow)) && ((m_canvas->GetWindowStyleFlag() & wxUSER_COLOURS) != wxUSER_COLOURS))
-            customColours = FALSE;
-
-        if (customColours)
-        {
-            if (m_backgroundBrush.GetStyle()==wxTRANSPARENT)
-            {
-                m_canvas->SetTransparent(TRUE);
-            }
-            else
-            {
-                // New behaviour, 10/2/99: setting the background brush of a DC
-                // doesn't affect the window background colour. However,
-                // I'm leaving in the transparency setting because it's needed by
-                // various controls (e.g. wxStaticText) to determine whether to draw
-                // transparently or not. TODO: maybe this should be a new function
-                // wxWindow::SetTransparency(). Should that apply to the child itself, or the
-                // parent?
-                //        m_canvas->SetBackgroundColour(m_backgroundBrush.GetColour());
-                m_canvas->SetTransparent(FALSE);
-            }
-        }
-    }
-    COLORREF new_color = m_backgroundBrush.GetColour().GetPixel();
-    {
-        (void)SetBkColor(GetHdc(), new_color);
+        (void)SetBkColor(GetHdc(), m_backgroundBrush.GetColour().GetPixel());
     }
 }
 
     }
 }
 
@@ -1651,8 +1628,8 @@ void wxDC::SetMapMode(int mode)
             return;
         }
 
             return;
         }
 
-        double mm2pixelsX = pixel_width / mm_width,
-               mm2pixelsY = pixel_height / mm_height;
+        double mm2pixelsX = (double)pixel_width / mm_width,
+               mm2pixelsY = (double)pixel_height / mm_height;
 
         switch (mode)
         {
 
         switch (mode)
         {
@@ -1684,6 +1661,7 @@ void wxDC::SetMapMode(int mode)
     // 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!)
     // 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!)
+#ifndef __WXWINCE__
     ::SetMapMode(GetHdc(), MM_ANISOTROPIC);
 
     int width = DeviceToLogicalXRel(VIEWPORT_EXTENT)*m_signX,
     ::SetMapMode(GetHdc(), MM_ANISOTROPIC);
 
     int width = DeviceToLogicalXRel(VIEWPORT_EXTENT)*m_signX,
@@ -1694,6 +1672,7 @@ void wxDC::SetMapMode(int mode)
 
     ::SetViewportOrgEx(GetHdc(), m_deviceOriginX, m_deviceOriginY, NULL);
     ::SetWindowOrgEx(GetHdc(), m_logicalOriginX, m_logicalOriginY, NULL);
 
     ::SetViewportOrgEx(GetHdc(), m_deviceOriginX, m_deviceOriginY, NULL);
     ::SetWindowOrgEx(GetHdc(), m_logicalOriginX, m_logicalOriginY, NULL);
+#endif
 }
 
 void wxDC::SetUserScale(double x, double y)
 }
 
 void wxDC::SetUserScale(double x, double y)
@@ -1702,6 +1681,7 @@ void wxDC::SetUserScale(double x, double y)
     if (!GetHDC()) return;
 #endif
 
     if (!GetHDC()) return;
 #endif
 
+#ifndef __WXWINCE__
     if ( x == m_userScaleX && y == m_userScaleY )
         return;
 
     if ( x == m_userScaleX && y == m_userScaleY )
         return;
 
@@ -1709,6 +1689,7 @@ void wxDC::SetUserScale(double x, double y)
     m_userScaleY = y;
 
     SetMapMode(m_mappingMode);
     m_userScaleY = y;
 
     SetMapMode(m_mappingMode);
+#endif
 }
 
 void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
 }
 
 void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
@@ -1717,6 +1698,7 @@ void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
     if (!GetHDC()) return;
 #endif
 
     if (!GetHDC()) return;
 #endif
 
+#ifndef __WXWINCE__
     int signX = xLeftRight ? 1 : -1,
         signY = yBottomUp ? -1 : 1;
 
     int signX = xLeftRight ? 1 : -1,
         signY = yBottomUp ? -1 : 1;
 
@@ -1727,6 +1709,7 @@ void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
 
         SetMapMode(m_mappingMode);
     }
 
         SetMapMode(m_mappingMode);
     }
+#endif
 }
 
 void wxDC::SetSystemScale(double x, double y)
 }
 
 void wxDC::SetSystemScale(double x, double y)
@@ -1735,6 +1718,7 @@ void wxDC::SetSystemScale(double x, double y)
     if (!GetHDC()) return;
 #endif
 
     if (!GetHDC()) return;
 #endif
 
+#ifndef __WXWINCE__
     if ( x == m_scaleX && y == m_scaleY )
         return;
 
     if ( x == m_scaleX && y == m_scaleY )
         return;
 
@@ -1742,6 +1726,7 @@ void wxDC::SetSystemScale(double x, double y)
     m_scaleY = y;
 
     SetMapMode(m_mappingMode);
     m_scaleY = y;
 
     SetMapMode(m_mappingMode);
+#endif
 }
 
 void wxDC::SetLogicalOrigin(wxCoord x, wxCoord y)
 }
 
 void wxDC::SetLogicalOrigin(wxCoord x, wxCoord y)
@@ -1750,6 +1735,7 @@ void wxDC::SetLogicalOrigin(wxCoord x, wxCoord y)
     if (!GetHDC()) return;
 #endif
 
     if (!GetHDC()) return;
 #endif
 
+#ifndef __WXWINCE__
     if ( x == m_logicalOriginX && y == m_logicalOriginY )
         return;
 
     if ( x == m_logicalOriginX && y == m_logicalOriginY )
         return;
 
@@ -1757,6 +1743,7 @@ void wxDC::SetLogicalOrigin(wxCoord x, wxCoord y)
     m_logicalOriginY = y;
 
     ::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
     m_logicalOriginY = y;
 
     ::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
+#endif
 }
 
 void wxDC::SetDeviceOrigin(wxCoord x, wxCoord y)
 }
 
 void wxDC::SetDeviceOrigin(wxCoord x, wxCoord y)
@@ -1765,6 +1752,7 @@ void wxDC::SetDeviceOrigin(wxCoord x, wxCoord y)
     if (!GetHDC()) return;
 #endif
 
     if (!GetHDC()) return;
 #endif
 
+#ifndef __WXWINCE__
     if ( x == m_deviceOriginX && y == m_deviceOriginY )
         return;
 
     if ( x == m_deviceOriginX && y == m_deviceOriginY )
         return;
 
@@ -1772,6 +1760,7 @@ void wxDC::SetDeviceOrigin(wxCoord x, wxCoord y)
     m_deviceOriginY = y;
 
     ::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
     m_deviceOriginY = y;
 
     ::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
+#endif
 }
 
 // ---------------------------------------------------------------------------
 }
 
 // ---------------------------------------------------------------------------
@@ -1832,11 +1821,19 @@ bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
                   int rop, bool useMask,
                   wxCoord xsrcMask, wxCoord ysrcMask)
 {
                   int rop, bool useMask,
                   wxCoord xsrcMask, wxCoord ysrcMask)
 {
+    wxCHECK_MSG( source, FALSE, _T("wxDC::Blit(): NULL wxDC pointer") );
+
 #ifdef __WXMICROWIN__
     if (!GetHDC()) return FALSE;
 #endif
 
     const wxBitmap& bmpSrc = source->m_selectedBitmap;
 #ifdef __WXMICROWIN__
     if (!GetHDC()) return FALSE;
 #endif
 
     const wxBitmap& bmpSrc = source->m_selectedBitmap;
+    if ( bmpSrc.Ok() && bmpSrc.HasAlpha() )
+    {
+        if ( AlphaBlt(GetHdc(), xdest, ydest, width, height,
+                      GetHdcOf(*source), bmpSrc) )
+            return TRUE;
+    }
 
     wxMask *mask = NULL;
     if ( useMask )
 
     wxMask *mask = NULL;
     if ( useMask )
@@ -1867,7 +1864,7 @@ bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
         ::SetBkColor(GetHdc(), m_textBackgroundColour.GetPixel() );
     }
 
         ::SetBkColor(GetHdc(), m_textBackgroundColour.GetPixel() );
     }
 
-    DWORD dwRop = SRCCOPY;
+    DWORD dwRop;
     switch (rop)
     {
         case wxXOR:          dwRop = SRCINVERT;        break;
     switch (rop)
     {
         case wxXOR:          dwRop = SRCINVERT;        break;
@@ -2009,6 +2006,9 @@ bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
     {
         // if we already have a DIB, draw it using StretchDIBits(), otherwise
         // use StretchBlt() if available and finally fall back to BitBlt()
     {
         // if we already have a DIB, draw it using StretchDIBits(), otherwise
         // use StretchBlt() if available and finally fall back to BitBlt()
+
+        // FIXME: use appropriate WinCE functions
+#ifndef __WXWINCE__
         const int caps = ::GetDeviceCaps(GetHdc(), RASTERCAPS);
         if ( bmpSrc.Ok() && (caps & RC_STRETCHDIB) )
         {
         const int caps = ::GetDeviceCaps(GetHdc(), RASTERCAPS);
         if ( bmpSrc.Ok() && (caps & RC_STRETCHDIB) )
         {
@@ -2042,8 +2042,12 @@ bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
         }
 
         if ( !success && (caps & RC_STRETCHBLT) )
         }
 
         if ( !success && (caps & RC_STRETCHBLT) )
+#endif
+        // __WXWINCE__
         {
         {
+#ifndef __WXWINCE__
             StretchBltModeChanger changeMode(GetHdc(), COLORONCOLOR);
             StretchBltModeChanger changeMode(GetHdc(), COLORONCOLOR);
+#endif
 
             if ( !::StretchBlt
                     (
 
             if ( !::StretchBlt
                     (
@@ -2198,7 +2202,7 @@ wxDCCacheEntry::~wxDCCacheEntry()
 wxDCCacheEntry* wxDC::FindBitmapInCache(WXHDC dc, int w, int h)
 {
     int depth = ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
 wxDCCacheEntry* wxDC::FindBitmapInCache(WXHDC dc, int w, int h)
 {
     int depth = ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
-    wxNode* node = sm_bitmapCache.GetFirst();
+    wxList::compatibility_iterator node = sm_bitmapCache.GetFirst();
     while (node)
     {
         wxDCCacheEntry* entry = (wxDCCacheEntry*) node->GetData();
     while (node)
     {
         wxDCCacheEntry* entry = (wxDCCacheEntry*) node->GetData();
@@ -2234,7 +2238,7 @@ wxDCCacheEntry* wxDC::FindBitmapInCache(WXHDC dc, int w, int h)
 wxDCCacheEntry* wxDC::FindDCInCache(wxDCCacheEntry* notThis, WXHDC dc)
 {
     int depth = ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
 wxDCCacheEntry* wxDC::FindDCInCache(wxDCCacheEntry* notThis, WXHDC dc)
 {
     int depth = ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
-    wxNode* node = sm_dcCache.GetFirst();
+    wxList::compatibility_iterator node = sm_dcCache.GetFirst();
     while (node)
     {
         wxDCCacheEntry* entry = (wxDCCacheEntry*) node->GetData();
     while (node)
     {
         wxDCCacheEntry* entry = (wxDCCacheEntry*) node->GetData();
@@ -2272,12 +2276,8 @@ void wxDC::AddToDCCache(wxDCCacheEntry* entry)
 
 void wxDC::ClearCache()
 {
 
 void wxDC::ClearCache()
 {
-    sm_dcCache.DeleteContents(TRUE);
-    sm_dcCache.Clear();
-    sm_dcCache.DeleteContents(FALSE);
-    sm_bitmapCache.DeleteContents(TRUE);
-    sm_bitmapCache.Clear();
-    sm_bitmapCache.DeleteContents(FALSE);
+    WX_CLEAR_LIST(wxList, sm_dcCache);
+    WX_CLEAR_LIST(wxList, sm_bitmapCache);
 }
 
 // Clean up cache at app exit
 }
 
 // Clean up cache at app exit
@@ -2296,33 +2296,114 @@ IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
 #endif // wxUSE_DC_CACHEING
 
 // ----------------------------------------------------------------------------
 #endif // wxUSE_DC_CACHEING
 
 // ----------------------------------------------------------------------------
-// wxAlphaBlend: our fallback if ::AlphaBlend() is unavailable
+// alpha channel support
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 
+static bool AlphaBlt(HDC hdcDst,
+                     int x, int y, int width, int height,
+                     HDC hdcSrc,
+                     const wxBitmap& bmp)
+{
+    wxASSERT_MSG( bmp.Ok() && bmp.HasAlpha(), _T("AlphaBlt(): invalid bitmap") );
+    wxASSERT_MSG( hdcDst && hdcSrc, _T("AlphaBlt(): invalid HDC") );
+
+    // do we have AlphaBlend() and company in the headers?
+#if defined(AC_SRC_OVER) && wxUSE_DYNLIB_CLASS
+    // 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;
+
+        // don't give errors about the DLL being unavailable, we're
+        // prepared to handle this
+        wxLogNull nolog;
+
+        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, not a
+                // big deal
+                dll.Detach();
+            }
+        }
+    }
+
+    if ( pfnAlphaBlend )
+    {
+        BLENDFUNCTION bf;
+        bf.BlendOp = AC_SRC_OVER;
+        bf.BlendFlags = 0;
+        bf.SourceConstantAlpha = 0xff;
+        bf.AlphaFormat = AC_SRC_ALPHA;
+
+        if ( pfnAlphaBlend(hdcDst, x, y, width, height,
+                           hdcSrc, 0, 0, width, height,
+                           bf) )
+        {
+            // skip wxAlphaBlend() call below
+            return TRUE;
+        }
+
+        wxLogLastError(_T("AlphaBlend"));
+    }
+#endif // defined(AC_SRC_OVER)
+
+    // AlphaBlend() unavailable of failed: use our own (probably much slower)
+    // implementation
+#ifdef wxHAVE_RAW_BITMAP
+    wxAlphaBlend(hdcDst, x, y, width, height, bmp);
+
+    return TRUE;
+#else // !wxHAVE_RAW_BITMAP
+    // no wxAlphaBlend() neither, fall back to using simple BitBlt() (we lose
+    // alpha but at least something will be shown like this)
+    return FALSE;
+#endif // wxHAVE_RAW_BITMAP
+}
+
+
+// wxAlphaBlend: our fallback if ::AlphaBlend() is unavailable
+#ifdef wxHAVE_RAW_BITMAP
+
 static void
 static void
-wxAlphaBlend(wxDC& dc, int xDst, int yDst, int w, int h, const wxBitmap& bmpSrc)
+wxAlphaBlend(HDC hdcDst, int xDst, int yDst, int w, int h, const wxBitmap& bmpSrc)
 {
     // get the destination DC pixels
 {
     // get the destination DC pixels
-    wxBitmap bmpDst(w, h, 32);
+    wxBitmap bmpDst(w, h, 32 /* force creating RGBA DIB */);
     MemoryHDC hdcMem;
     SelectInHDC select(hdcMem, GetHbitmapOf(bmpDst));
 
     MemoryHDC hdcMem;
     SelectInHDC select(hdcMem, GetHbitmapOf(bmpDst));
 
-    if ( !::BitBlt(hdcMem, 0, 0, w, h, GetHdcOf(dc), 0, 0, SRCCOPY) )
+    if ( !::BitBlt(hdcMem, 0, 0, w, h, hdcDst, 0, 0, SRCCOPY) )
     {
         wxLogLastError(_T("BitBlt"));
     }
 
     // combine them with the source bitmap using alpha
     {
         wxLogLastError(_T("BitBlt"));
     }
 
     // combine them with the source bitmap using alpha
-    wxRawBitmapData dataDst(bmpDst),
-                    dataSrc(bmpSrc);
+    wxAlphaPixelData dataDst(bmpDst),
+                     dataSrc((wxBitmap &)bmpSrc);
+
+    wxCHECK_RET( dataDst && dataSrc,
+                    _T("failed to get raw data in wxAlphaBlend") );
 
 
-    wxRawBitmapIterator pDst(dataDst),
-                        pSrc(dataSrc);
+    wxAlphaPixelData::Iterator pDst(dataDst),
+                               pSrc(dataSrc);
 
     for ( int y = 0; y < h; y++ )
     {
 
     for ( int y = 0; y < h; y++ )
     {
-        wxRawBitmapIterator pDstRowStart = pDst,
-                            pSrcRowStart = pSrc;
+        wxAlphaPixelData::Iterator pDstRowStart = pDst,
+                                   pSrcRowStart = pSrc;
 
         for ( int x = 0; x < w; x++ )
         {
 
         for ( int x = 0; x < w; x++ )
         {
@@ -2340,14 +2421,15 @@ wxAlphaBlend(wxDC& dc, int xDst, int yDst, int w, int h, const wxBitmap& bmpSrc)
 
         pDst = pDstRowStart;
         pSrc = pSrcRowStart;
 
         pDst = pDstRowStart;
         pSrc = pSrcRowStart;
-        pDst.OffsetY(1);
-        pSrc.OffsetY(1);
+        pDst.OffsetY(dataDst, 1);
+        pSrc.OffsetY(dataSrc, 1);
     }
 
     // and finally blit them back to the destination DC
     }
 
     // and finally blit them back to the destination DC
-    if ( !::BitBlt(GetHdcOf(dc), xDst, yDst, w, h, hdcMem, 0, 0, SRCCOPY) )
+    if ( !::BitBlt(hdcDst, xDst, yDst, w, h, hdcMem, 0, 0, SRCCOPY) )
     {
         wxLogLastError(_T("BitBlt"));
     }
 }
 
     {
         wxLogLastError(_T("BitBlt"));
     }
 }
 
+#endif // #ifdef wxHAVE_RAW_BITMAP