src/msw/dc.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/dc.cpp
   3 // Purpose:     wxDC class for MSW port
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ===========================================================================
  13 // declarations
  14 // ===========================================================================
  15
  16 // ---------------------------------------------------------------------------
  17 // headers
  18 // ---------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/msw/wrapcdlg.h"
  29     #include "wx/image.h"
  30     #include "wx/window.h"
  31     #include "wx/utils.h"
  32     #include "wx/dialog.h"
  33     #include "wx/app.h"
  34     #include "wx/bitmap.h"
  35     #include "wx/dcmemory.h"
  36     #include "wx/log.h"
  37     #include "wx/icon.h"
  38     #include "wx/dcprint.h"
  39     #include "wx/module.h"
  40 #endif
  41
  42 #include "wx/msw/dc.h"
  43 #include "wx/sysopt.h"
  44 #include "wx/dynlib.h"
  45
  46 #ifdef wxHAS_RAW_BITMAP
  47     #include "wx/rawbmp.h"
  48 #endif
  49
  50 #include <string.h>
  51
  52 #include "wx/msw/private/dc.h"
  53
  54 using namespace wxMSWImpl;
  55
  56 #ifndef AC_SRC_ALPHA
  57     #define AC_SRC_ALPHA 1
  58 #endif
  59
  60 #ifndef LAYOUT_RTL
  61     #define LAYOUT_RTL 1
  62 #endif
  63
  64 /* Quaternary raster codes */
  65 #ifndef MAKEROP4
  66 #define MAKEROP4(fore,back) (DWORD)((((back) << 8) & 0xFF000000) | (fore))
  67 #endif
  68
  69 // apparently with MicroWindows it is possible that HDC is 0 so we have to
  70 // check for this ourselves
  71 #ifdef __WXMICROWIN__
  72     #define WXMICROWIN_CHECK_HDC if ( !GetHDC() ) return;
  73     #define WXMICROWIN_CHECK_HDC_RET(x) if ( !GetHDC() ) return x;
  74 #else
  75     #define WXMICROWIN_CHECK_HDC
  76     #define WXMICROWIN_CHECK_HDC_RET(x)
  77 #endif
  78
  79 IMPLEMENT_ABSTRACT_CLASS(wxMSWDCImpl, wxDCImpl)
  80
  81 // ---------------------------------------------------------------------------
  82 // constants
  83 // ---------------------------------------------------------------------------
  84
  85 static const int VIEWPORT_EXTENT = 1000;
  86
  87 // ROPs which don't have standard names (see "Ternary Raster Operations" in the
  88 // MSDN docs for how this and other numbers in wxDC::Blit() are obtained)
  89 #define DSTCOPY 0x00AA0029      // a.k.a. NOP operation
  90
  91 // ----------------------------------------------------------------------------
  92 // macros for logical <-> device coords conversion
  93 // ----------------------------------------------------------------------------
  94
  95 /*
  96    We currently let Windows do all the translations itself so these macros are
  97    not really needed (any more) but keep them to enhance readability of the
  98    code by allowing to see where are the logical and where are the device
  99    coordinates used.
 100  */
 101
 102 #ifdef __WXWINCE__
 103     #define XLOG2DEV(x) ((x-m_logicalOriginX)*m_signX)
 104     #define YLOG2DEV(y) ((y-m_logicalOriginY)*m_signY)
 105     #define XDEV2LOG(x) ((x)*m_signX+m_logicalOriginX)
 106     #define YDEV2LOG(y) ((y)*m_signY+m_logicalOriginY)
 107 #else
 108     #define XLOG2DEV(x) (x)
 109     #define YLOG2DEV(y) (y)
 110     #define XDEV2LOG(x) (x)
 111     #define YDEV2LOG(y) (y)
 112 #endif
 113
 114 // ---------------------------------------------------------------------------
 115 // private functions
 116 // ---------------------------------------------------------------------------
 117
 118 // convert degrees to radians
 119 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
 120
 121 // call AlphaBlend() to blit contents of hdcSrc to hdcDst using alpha
 122 //
 123 // NB: bmpSrc is the bitmap selected in hdcSrc, it is not really needed
 124 //     to pass it to this function but as we already have it at the point
 125 //     of call anyhow we do
 126 //
 127 // return true if we could draw the bitmap in one way or the other, false
 128 // otherwise
 129 static bool AlphaBlt(HDC hdcDst,
 130                      int x, int y, int dstWidth, int dstHeight,
 131                      int srcX, int srcY,
 132                      int srcWidth, int srcHeight,
 133                      HDC hdcSrc,
 134                      const wxBitmap& bmp);
 135
 136 #ifdef wxHAS_RAW_BITMAP
 137
 138 // our (limited) AlphaBlend() replacement for Windows versions not providing it
 139 static void
 140 wxAlphaBlend(HDC hdcDst, int xDst, int yDst,
 141              int dstWidth, int dstHeight,
 142              int srcX, int srcY,
 143              int srcWidth, int srcHeight,
 144              const wxBitmap& bmpSrc);
 145
 146 #endif // wxHAS_RAW_BITMAP
 147
 148 // ----------------------------------------------------------------------------
 149 // private classes
 150 // ----------------------------------------------------------------------------
 151
 152 // instead of duplicating the same code which sets and then restores text
 153 // colours in each wxDC method working with wxSTIPPLE_MASK_OPAQUE brushes,
 154 // encapsulate this in a small helper class
 155
 156 // wxBrushAttrsSetter: changes the text colours in the ctor if required and
 157 //                  restores them in the dtor
 158 class wxBrushAttrsSetter : private wxBkModeChanger,
 159                            private wxTextColoursChanger
 160 {
 161 public:
 162     wxBrushAttrsSetter(wxMSWDCImpl& dc);
 163
 164 private:
 165     wxDECLARE_NO_COPY_CLASS(wxBrushAttrsSetter);
 166 };
 167
 168 #ifdef __WXWINCE__
 169
 170 #define SET_STRETCH_BLT_MODE(hdc)
 171
 172 #else // !__WXWINCE__
 173
 174 // this class sets the stretch blit mode to COLORONCOLOR during its lifetime
 175 //
 176 // don't use it directly, use SET_STRETCH_BLT_MODE() macro instead as it
 177 // expands to nothing under WinCE which doesn't have SetStretchBltMode()
 178 class StretchBltModeChanger
 179 {
 180 public:
 181     StretchBltModeChanger(HDC hdc)
 182         : m_hdc(hdc)
 183     {
 184         m_modeOld = ::SetStretchBltMode(m_hdc, COLORONCOLOR);
 185         if ( !m_modeOld )
 186         {
 187             wxLogLastError(wxT("SetStretchBltMode"));
 188         }
 189     }
 190
 191     ~StretchBltModeChanger()
 192     {
 193         if ( !::SetStretchBltMode(m_hdc, m_modeOld) )
 194         {
 195             wxLogLastError(wxT("SetStretchBltMode"));
 196         }
 197     }
 198
 199 private:
 200     const HDC m_hdc;
 201
 202     int m_modeOld;
 203
 204     wxDECLARE_NO_COPY_CLASS(StretchBltModeChanger);
 205 };
 206
 207 #define SET_STRETCH_BLT_MODE(hdc) \
 208     StretchBltModeChanger wxMAKE_UNIQUE_NAME(stretchModeChanger)(hdc)
 209
 210 #endif // __WXWINCE__/!__WXWINCE__
 211
 212 #if wxUSE_DYNLIB_CLASS
 213
 214 // helper class to cache dynamically loaded libraries and not attempt reloading
 215 // them if it fails
 216 class wxOnceOnlyDLLLoader
 217 {
 218 public:
 219     // ctor argument must be a literal string as we don't make a copy of it!
 220     wxOnceOnlyDLLLoader(const wxChar *dllName)
 221         : m_dllName(dllName)
 222     {
 223     }
 224
 225
 226     // return the symbol with the given name or NULL if the DLL not loaded
 227     // or symbol not present
 228     void *GetSymbol(const wxChar *name)
 229     {
 230         // we're prepared to handle errors here
 231         wxLogNull noLog;
 232
 233         if ( m_dllName )
 234         {
 235             m_dll.Load(m_dllName);
 236
 237             // reset the name whether we succeeded or failed so that we don't
 238             // try again the next time
 239             m_dllName = NULL;
 240         }
 241
 242         return m_dll.IsLoaded() ? m_dll.GetSymbol(name) : NULL;
 243     }
 244
 245     void Unload()
 246     {
 247         if ( m_dll.IsLoaded() )
 248         {
 249             m_dll.Unload();
 250         }
 251     }
 252
 253 private:
 254     wxDynamicLibrary m_dll;
 255     const wxChar *m_dllName;
 256 };
 257
 258 static wxOnceOnlyDLLLoader wxMSIMG32DLL(wxT("msimg32"));
 259
 260 // we must ensure that DLLs are unloaded before the static objects cleanup time
 261 // because we may hit the notorious DllMain() dead lock in this case if wx is
 262 // used as a DLL (attempting to unload another DLL from inside DllMain() hangs
 263 // under Windows because it tries to reacquire the same lock)
 264 class wxGDIDLLsCleanupModule : public wxModule
 265 {
 266 public:
 267     virtual bool OnInit() { return true; }
 268     virtual void OnExit() { wxMSIMG32DLL.Unload(); }
 269
 270 private:
 271     DECLARE_DYNAMIC_CLASS(wxGDIDLLsCleanupModule)
 272 };
 273
 274 IMPLEMENT_DYNAMIC_CLASS(wxGDIDLLsCleanupModule, wxModule)
 275
 276 #endif // wxUSE_DYNLIB_CLASS
 277
 278 // ===========================================================================
 279 // implementation
 280 // ===========================================================================
 281
 282 // ----------------------------------------------------------------------------
 283 // wxBrushAttrsSetter
 284 // ----------------------------------------------------------------------------
 285
 286 wxBrushAttrsSetter::wxBrushAttrsSetter(wxMSWDCImpl& dc)
 287                   : wxBkModeChanger(GetHdcOf(dc)),
 288                     wxTextColoursChanger(GetHdcOf(dc))
 289 {
 290     const wxBrush& brush = dc.GetBrush();
 291     if ( brush.IsOk() && brush.GetStyle() == wxBRUSHSTYLE_STIPPLE_MASK_OPAQUE )
 292     {
 293         // note that Windows convention is opposite to wxWidgets one, this is
 294         // why text colour becomes the background one and vice versa
 295         wxTextColoursChanger::Change(dc.GetTextBackground(),
 296                                      dc.GetTextForeground());
 297
 298         wxBkModeChanger::Change(dc.GetBackgroundMode());
 299     }
 300 }
 301
 302 // ----------------------------------------------------------------------------
 303 // wxDC MSW-specific methods
 304 // ----------------------------------------------------------------------------
 305
 306 WXHDC wxDC::GetHDC() const
 307 {
 308     wxMSWDCImpl * const impl = wxDynamicCast(GetImpl(), wxMSWDCImpl);
 309     return impl ? impl->GetHDC() : 0;
 310 }
 311
 312 // ---------------------------------------------------------------------------
 313 // wxMSWDCImpl
 314 // ---------------------------------------------------------------------------
 315
 316 wxMSWDCImpl::wxMSWDCImpl( wxDC *owner, WXHDC hDC ) :
 317     wxDCImpl( owner )
 318 {
 319     Init();
 320     m_hDC = hDC;
 321 }
 322
 323 wxMSWDCImpl::~wxMSWDCImpl()
 324 {
 325     if ( m_hDC != 0 )
 326     {
 327         SelectOldObjects(m_hDC);
 328
 329         // if we own the HDC, we delete it, otherwise we just release it
 330
 331         if ( m_bOwnsDC )
 332         {
 333             ::DeleteDC(GetHdc());
 334         }
 335         else // we don't own our HDC
 336         {
 337             if (m_window)
 338             {
 339                 ::ReleaseDC(GetHwndOf(m_window), GetHdc());
 340             }
 341             else
 342             {
 343                 // Must have been a wxScreenDC
 344                 ::ReleaseDC((HWND) NULL, GetHdc());
 345             }
 346         }
 347     }
 348 }
 349
 350 // This will select current objects out of the DC,
 351 // which is what you have to do before deleting the
 352 // DC.
 353 void wxMSWDCImpl::SelectOldObjects(WXHDC dc)
 354 {
 355     if (dc)
 356     {
 357         if (m_oldBitmap)
 358         {
 359             ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);
 360             if (m_selectedBitmap.IsOk())
 361             {
 362                 m_selectedBitmap.SetSelectedInto(NULL);
 363             }
 364         }
 365         m_oldBitmap = 0;
 366         if (m_oldPen)
 367         {
 368             ::SelectObject((HDC) dc, (HPEN) m_oldPen);
 369         }
 370         m_oldPen = 0;
 371         if (m_oldBrush)
 372         {
 373             ::SelectObject((HDC) dc, (HBRUSH) m_oldBrush);
 374         }
 375         m_oldBrush = 0;
 376         if (m_oldFont)
 377         {
 378             ::SelectObject((HDC) dc, (HFONT) m_oldFont);
 379         }
 380         m_oldFont = 0;
 381
 382 #if wxUSE_PALETTE
 383         if (m_oldPalette)
 384         {
 385             ::SelectPalette((HDC) dc, (HPALETTE) m_oldPalette, FALSE);
 386         }
 387         m_oldPalette = 0;
 388 #endif // wxUSE_PALETTE
 389     }
 390
 391     m_brush = wxNullBrush;
 392     m_pen = wxNullPen;
 393 #if wxUSE_PALETTE
 394     m_palette = wxNullPalette;
 395 #endif // wxUSE_PALETTE
 396     m_font = wxNullFont;
 397     m_backgroundBrush = wxNullBrush;
 398     m_selectedBitmap = wxNullBitmap;
 399 }
 400
 401 // ---------------------------------------------------------------------------
 402 // clipping
 403 // ---------------------------------------------------------------------------
 404
 405 void wxMSWDCImpl::UpdateClipBox()
 406 {
 407     WXMICROWIN_CHECK_HDC
 408
 409     RECT rect;
 410     ::GetClipBox(GetHdc(), &rect);
 411
 412     m_clipX1 = (wxCoord) XDEV2LOG(rect.left);
 413     m_clipY1 = (wxCoord) YDEV2LOG(rect.top);
 414     m_clipX2 = (wxCoord) XDEV2LOG(rect.right);
 415     m_clipY2 = (wxCoord) YDEV2LOG(rect.bottom);
 416 }
 417
 418 void
 419 wxMSWDCImpl::DoGetClippingBox(wxCoord *x, wxCoord *y, wxCoord *w, wxCoord *h) const
 420 {
 421     // check if we should try to retrieve the clipping region possibly not set
 422     // by our SetClippingRegion() but preset by Windows:this can only happen
 423     // when we're associated with an existing HDC usign SetHDC(), see there
 424     if ( m_clipping && !m_clipX1 && !m_clipX2 )
 425     {
 426         wxMSWDCImpl *self = wxConstCast(this, wxMSWDCImpl);
 427         self->UpdateClipBox();
 428
 429         if ( !m_clipX1 && !m_clipX2 )
 430             self->m_clipping = false;
 431     }
 432
 433     wxDCImpl::DoGetClippingBox(x, y, w, h);
 434 }
 435
 436 // common part of DoSetClippingRegion() and DoSetDeviceClippingRegion()
 437 void wxMSWDCImpl::SetClippingHrgn(WXHRGN hrgn)
 438 {
 439     wxCHECK_RET( hrgn, wxT("invalid clipping region") );
 440
 441     WXMICROWIN_CHECK_HDC
 442
 443     // note that we combine the new clipping region with the existing one: this
 444     // is compatible with what the other ports do and is the documented
 445     // behaviour now (starting with 2.3.3)
 446 #if defined(__WXWINCE__)
 447     RECT rectClip;
 448     if ( !::GetClipBox(GetHdc(), &rectClip) )
 449         return;
 450
 451     // GetClipBox returns logical coordinates, so transform to device
 452     rectClip.left = LogicalToDeviceX(rectClip.left);
 453     rectClip.top = LogicalToDeviceY(rectClip.top);
 454     rectClip.right = LogicalToDeviceX(rectClip.right);
 455     rectClip.bottom = LogicalToDeviceY(rectClip.bottom);
 456
 457     HRGN hrgnDest = ::CreateRectRgn(0, 0, 0, 0);
 458     HRGN hrgnClipOld = ::CreateRectRgn(rectClip.left, rectClip.top,
 459                                        rectClip.right, rectClip.bottom);
 460
 461     if ( ::CombineRgn(hrgnDest, hrgnClipOld, (HRGN)hrgn, RGN_AND) != ERROR )
 462     {
 463         ::SelectClipRgn(GetHdc(), hrgnDest);
 464     }
 465
 466     ::DeleteObject(hrgnClipOld);
 467     ::DeleteObject(hrgnDest);
 468 #else // !WinCE
 469     if ( ::ExtSelectClipRgn(GetHdc(), (HRGN)hrgn, RGN_AND) == ERROR )
 470     {
 471         wxLogLastError(wxT("ExtSelectClipRgn"));
 472
 473         return;
 474     }
 475 #endif // WinCE/!WinCE
 476
 477     m_clipping = true;
 478
 479     UpdateClipBox();
 480 }
 481
 482 void wxMSWDCImpl::DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
 483 {
 484     // the region coords are always the device ones, so do the translation
 485     // manually
 486     //
 487     // FIXME: possible +/-1 error here, to check!
 488     HRGN hrgn = ::CreateRectRgn(LogicalToDeviceX(x),
 489                                 LogicalToDeviceY(y),
 490                                 LogicalToDeviceX(x + w),
 491                                 LogicalToDeviceY(y + h));
 492     if ( !hrgn )
 493     {
 494         wxLogLastError(wxT("CreateRectRgn"));
 495     }
 496     else
 497     {
 498         SetClippingHrgn((WXHRGN)hrgn);
 499
 500         ::DeleteObject(hrgn);
 501     }
 502 }
 503
 504 void wxMSWDCImpl::DoSetDeviceClippingRegion(const wxRegion& region)
 505 {
 506     SetClippingHrgn(region.GetHRGN());
 507 }
 508
 509 void wxMSWDCImpl::DestroyClippingRegion()
 510 {
 511     WXMICROWIN_CHECK_HDC
 512
 513     if (m_clipping && m_hDC)
 514     {
 515 #if 1
 516         // On a PocketPC device (not necessarily emulator), resetting
 517         // the clip region as per the old method causes bad display
 518         // problems. In fact setting a null region is probably OK
 519         // on desktop WIN32 also, since the WIN32 docs imply that the user
 520         // clipping region is independent from the paint clipping region.
 521         ::SelectClipRgn(GetHdc(), 0);
 522 #else
 523         // TODO: this should restore the previous clipping region,
 524         //       so that OnPaint processing works correctly, and the update
 525         //       clipping region doesn't get destroyed after the first
 526         //       DestroyClippingRegion.
 527         HRGN rgn = CreateRectRgn(0, 0, 32000, 32000);
 528         ::SelectClipRgn(GetHdc(), rgn);
 529         ::DeleteObject(rgn);
 530 #endif
 531     }
 532
 533     wxDCImpl::DestroyClippingRegion();
 534 }
 535
 536 // ---------------------------------------------------------------------------
 537 // query capabilities
 538 // ---------------------------------------------------------------------------
 539
 540 bool wxMSWDCImpl::CanDrawBitmap() const
 541 {
 542     return true;
 543 }
 544
 545 bool wxMSWDCImpl::CanGetTextExtent() const
 546 {
 547 #ifdef __WXMICROWIN__
 548     // TODO Extend MicroWindows' GetDeviceCaps function
 549     return true;
 550 #else
 551     // What sort of display is it?
 552     int technology = ::GetDeviceCaps(GetHdc(), TECHNOLOGY);
 553
 554     return (technology == DT_RASDISPLAY) || (technology == DT_RASPRINTER);
 555 #endif
 556 }
 557
 558 int wxMSWDCImpl::GetDepth() const
 559 {
 560     WXMICROWIN_CHECK_HDC_RET(16)
 561
 562     return (int)::GetDeviceCaps(GetHdc(), BITSPIXEL);
 563 }
 564
 565 // ---------------------------------------------------------------------------
 566 // drawing
 567 // ---------------------------------------------------------------------------
 568
 569 void wxMSWDCImpl::Clear()
 570 {
 571     WXMICROWIN_CHECK_HDC
 572
 573     RECT rect;
 574     if (m_window)
 575     {
 576         GetClientRect((HWND) m_window->GetHWND(), &rect);
 577     }
 578     else
 579     {
 580         // No, I think we should simply ignore this if printing on e.g.
 581         // a printer DC.
 582         // wxCHECK_RET( m_selectedBitmap.IsOk(), wxT("this DC can't be cleared") );
 583         if (!m_selectedBitmap.IsOk())
 584             return;
 585
 586         rect.left = -m_deviceOriginX; rect.top = -m_deviceOriginY;
 587         rect.right = m_selectedBitmap.GetWidth()-m_deviceOriginX;
 588         rect.bottom = m_selectedBitmap.GetHeight()-m_deviceOriginY;
 589     }
 590
 591 #ifndef __WXWINCE__
 592     (void) ::SetMapMode(GetHdc(), MM_TEXT);
 593 #endif
 594
 595     DWORD colour = ::GetBkColor(GetHdc());
 596     HBRUSH brush = ::CreateSolidBrush(colour);
 597     ::FillRect(GetHdc(), &rect, brush);
 598     ::DeleteObject(brush);
 599
 600     RealizeScaleAndOrigin();
 601 }
 602
 603 bool wxMSWDCImpl::DoFloodFill(wxCoord WXUNUSED_IN_WINCE(x),
 604                        wxCoord WXUNUSED_IN_WINCE(y),
 605                        const wxColour& WXUNUSED_IN_WINCE(col),
 606                        wxFloodFillStyle WXUNUSED_IN_WINCE(style))
 607 {
 608 #ifdef __WXWINCE__
 609     return false;
 610 #else
 611     WXMICROWIN_CHECK_HDC_RET(false)
 612
 613     bool success = (0 != ::ExtFloodFill(GetHdc(), XLOG2DEV(x), YLOG2DEV(y),
 614                          col.GetPixel(),
 615                          style == wxFLOOD_SURFACE ? FLOODFILLSURFACE
 616                                                   : FLOODFILLBORDER) ) ;
 617     if (!success)
 618     {
 619         // quoting from the MSDN docs:
 620         //
 621         //      Following are some of the reasons this function might fail:
 622         //
 623         //      * The filling could not be completed.
 624         //      * The specified point has the boundary color specified by the
 625         //        crColor parameter (if FLOODFILLBORDER was requested).
 626         //      * The specified point does not have the color specified by
 627         //        crColor (if FLOODFILLSURFACE was requested)
 628         //      * The point is outside the clipping region that is, it is not
 629         //        visible on the device.
 630         //
 631         wxLogLastError(wxT("ExtFloodFill"));
 632     }
 633
 634     CalcBoundingBox(x, y);
 635
 636     return success;
 637 #endif
 638 }
 639
 640 bool wxMSWDCImpl::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
 641 {
 642     WXMICROWIN_CHECK_HDC_RET(false)
 643
 644     wxCHECK_MSG( col, false, wxT("NULL colour parameter in wxMSWDCImpl::GetPixel") );
 645
 646     // get the color of the pixel
 647     COLORREF pixelcolor = ::GetPixel(GetHdc(), XLOG2DEV(x), YLOG2DEV(y));
 648
 649     wxRGBToColour(*col, pixelcolor);
 650
 651     return true;
 652 }
 653
 654 void wxMSWDCImpl::DoCrossHair(wxCoord x, wxCoord y)
 655 {
 656     WXMICROWIN_CHECK_HDC
 657
 658     wxCoord x1 = x-VIEWPORT_EXTENT;
 659     wxCoord y1 = y-VIEWPORT_EXTENT;
 660     wxCoord x2 = x+VIEWPORT_EXTENT;
 661     wxCoord y2 = y+VIEWPORT_EXTENT;
 662
 663     wxDrawLine(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y));
 664     wxDrawLine(GetHdc(), XLOG2DEV(x), YLOG2DEV(y1), XLOG2DEV(x), YLOG2DEV(y2));
 665
 666     CalcBoundingBox(x1, y1);
 667     CalcBoundingBox(x2, y2);
 668 }
 669
 670 void wxMSWDCImpl::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
 671 {
 672     WXMICROWIN_CHECK_HDC
 673
 674     wxDrawLine(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2));
 675
 676     CalcBoundingBox(x1, y1);
 677     CalcBoundingBox(x2, y2);
 678 }
 679
 680 // Draws an arc of a circle, centred on (xc, yc), with starting point (x1, y1)
 681 // and ending at (x2, y2)
 682 void wxMSWDCImpl::DoDrawArc(wxCoord x1, wxCoord y1,
 683                      wxCoord x2, wxCoord y2,
 684                      wxCoord xc, wxCoord yc)
 685 {
 686     double dx = xc - x1;
 687     double dy = yc - y1;
 688     wxCoord r = (wxCoord)sqrt(dx*dx + dy*dy);
 689
 690
 691 #ifdef __WXWINCE__
 692     // Slower emulation since WinCE doesn't support Pie and Arc
 693     double sa = acos((x1-xc)/r)/M_PI*180; // between 0 and 180
 694     if( y1>yc )
 695         sa = -sa; // below center
 696     double ea = atan2(yc-y2, x2-xc)/M_PI*180;
 697     DoDrawEllipticArcRot( xc-r, yc-r, 2*r, 2*r, sa, ea );
 698 #else
 699
 700     WXMICROWIN_CHECK_HDC
 701
 702     wxBrushAttrsSetter cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
 703
 704     // treat the special case of full circle separately
 705     if ( x1 == x2 && y1 == y2 )
 706     {
 707         GetOwner()->DrawEllipse(xc - r, yc - r, 2*r, 2*r);
 708         return;
 709     }
 710
 711     wxCoord xx1 = XLOG2DEV(x1);
 712     wxCoord yy1 = YLOG2DEV(y1);
 713     wxCoord xx2 = XLOG2DEV(x2);
 714     wxCoord yy2 = YLOG2DEV(y2);
 715     wxCoord xxc = XLOG2DEV(xc);
 716     wxCoord yyc = YLOG2DEV(yc);
 717     dx = xxc - xx1;
 718     dy = yyc - yy1;
 719     wxCoord ray = (wxCoord)sqrt(dx*dx + dy*dy);
 720
 721     wxCoord xxx1 = (wxCoord) (xxc-ray);
 722     wxCoord yyy1 = (wxCoord) (yyc-ray);
 723     wxCoord xxx2 = (wxCoord) (xxc+ray);
 724     wxCoord yyy2 = (wxCoord) (yyc+ray);
 725
 726     if ( m_brush.IsNonTransparent() )
 727     {
 728         // Have to add 1 to bottom-right corner of rectangle
 729         // to make semi-circles look right (crooked line otherwise).
 730         // Unfortunately this is not a reliable method, depends
 731         // on the size of shape.
 732         // TODO: figure out why this happens!
 733         Pie(GetHdc(),xxx1,yyy1,xxx2+1,yyy2+1, xx1,yy1,xx2,yy2);
 734     }
 735     else
 736     {
 737         Arc(GetHdc(),xxx1,yyy1,xxx2,yyy2, xx1,yy1,xx2,yy2);
 738     }
 739
 740     CalcBoundingBox(xc - r, yc - r);
 741     CalcBoundingBox(xc + r, yc + r);
 742 #endif
 743 }
 744
 745 void wxMSWDCImpl::DoDrawCheckMark(wxCoord x1, wxCoord y1,
 746                            wxCoord width, wxCoord height)
 747 {
 748     // cases when we don't have DrawFrameControl()
 749 #if defined(__SYMANTEC__) || defined(__WXMICROWIN__)
 750     return wxDCBase::DoDrawCheckMark(x1, y1, width, height);
 751 #else // normal case
 752     wxCoord x2 = x1 + width,
 753             y2 = y1 + height;
 754
 755     RECT rect;
 756     rect.left   = x1;
 757     rect.top    = y1;
 758     rect.right  = x2;
 759     rect.bottom = y2;
 760
 761 #ifdef __WXWINCE__
 762     DrawFrameControl(GetHdc(), &rect, DFC_BUTTON, DFCS_BUTTONCHECK | DFCS_CHECKED);
 763 #else
 764     DrawFrameControl(GetHdc(), &rect, DFC_MENU, DFCS_MENUCHECK);
 765 #endif
 766
 767     CalcBoundingBox(x1, y1);
 768     CalcBoundingBox(x2, y2);
 769 #endif // Microwin/Normal
 770 }
 771
 772 void wxMSWDCImpl::DoDrawPoint(wxCoord x, wxCoord y)
 773 {
 774     WXMICROWIN_CHECK_HDC
 775
 776     COLORREF color = 0x00ffffff;
 777     if (m_pen.IsOk())
 778     {
 779         color = m_pen.GetColour().GetPixel();
 780     }
 781
 782     SetPixel(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), color);
 783
 784     CalcBoundingBox(x, y);
 785 }
 786
 787 void wxMSWDCImpl::DoDrawPolygon(int n,
 788                          wxPoint points[],
 789                          wxCoord xoffset,
 790                          wxCoord yoffset,
 791                          wxPolygonFillMode WXUNUSED_IN_WINCE(fillStyle))
 792 {
 793     WXMICROWIN_CHECK_HDC
 794
 795     wxBrushAttrsSetter cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
 796
 797     // Do things less efficiently if we have offsets
 798     if (xoffset != 0 || yoffset != 0)
 799     {
 800         POINT *cpoints = new POINT[n];
 801         int i;
 802         for (i = 0; i < n; i++)
 803         {
 804             cpoints[i].x = (int)(points[i].x + xoffset);
 805             cpoints[i].y = (int)(points[i].y + yoffset);
 806
 807             CalcBoundingBox(cpoints[i].x, cpoints[i].y);
 808         }
 809 #ifndef __WXWINCE__
 810         int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
 811 #endif
 812         (void)Polygon(GetHdc(), cpoints, n);
 813 #ifndef __WXWINCE__
 814         SetPolyFillMode(GetHdc(),prev);
 815 #endif
 816         delete[] cpoints;
 817     }
 818     else
 819     {
 820         int i;
 821         for (i = 0; i < n; i++)
 822             CalcBoundingBox(points[i].x, points[i].y);
 823
 824 #ifndef __WXWINCE__
 825         int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
 826 #endif
 827         (void)Polygon(GetHdc(), (POINT*) points, n);
 828 #ifndef __WXWINCE__
 829         SetPolyFillMode(GetHdc(),prev);
 830 #endif
 831     }
 832 }
 833
 834 void
 835 wxMSWDCImpl::DoDrawPolyPolygon(int n,
 836                         int count[],
 837                         wxPoint points[],
 838                         wxCoord xoffset,
 839                         wxCoord yoffset,
 840                         wxPolygonFillMode fillStyle)
 841 {
 842 #ifdef __WXWINCE__
 843     wxDCImpl::DoDrawPolyPolygon(n, count, points, xoffset, yoffset, fillStyle);
 844 #else
 845     WXMICROWIN_CHECK_HDC
 846
 847     wxBrushAttrsSetter cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
 848     int i, cnt;
 849     for (i = cnt = 0; i < n; i++)
 850         cnt += count[i];
 851
 852     // Do things less efficiently if we have offsets
 853     if (xoffset != 0 || yoffset != 0)
 854     {
 855         POINT *cpoints = new POINT[cnt];
 856         for (i = 0; i < cnt; i++)
 857         {
 858             cpoints[i].x = (int)(points[i].x + xoffset);
 859             cpoints[i].y = (int)(points[i].y + yoffset);
 860
 861             CalcBoundingBox(cpoints[i].x, cpoints[i].y);
 862         }
 863 #ifndef __WXWINCE__
 864         int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
 865 #endif
 866         (void)PolyPolygon(GetHdc(), cpoints, count, n);
 867 #ifndef __WXWINCE__
 868         SetPolyFillMode(GetHdc(),prev);
 869 #endif
 870         delete[] cpoints;
 871     }
 872     else
 873     {
 874         for (i = 0; i < cnt; i++)
 875             CalcBoundingBox(points[i].x, points[i].y);
 876
 877 #ifndef __WXWINCE__
 878         int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
 879 #endif
 880         (void)PolyPolygon(GetHdc(), (POINT*) points, count, n);
 881 #ifndef __WXWINCE__
 882         SetPolyFillMode(GetHdc(),prev);
 883 #endif
 884     }
 885 #endif
 886   // __WXWINCE__
 887 }
 888
 889 void wxMSWDCImpl::DoDrawLines(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset)
 890 {
 891     WXMICROWIN_CHECK_HDC
 892
 893     // Do things less efficiently if we have offsets
 894     if (xoffset != 0 || yoffset != 0)
 895     {
 896         POINT *cpoints = new POINT[n];
 897         int i;
 898         for (i = 0; i < n; i++)
 899         {
 900             cpoints[i].x = (int)(points[i].x + xoffset);
 901             cpoints[i].y = (int)(points[i].y + yoffset);
 902
 903             CalcBoundingBox(cpoints[i].x, cpoints[i].y);
 904         }
 905         (void)Polyline(GetHdc(), cpoints, n);
 906         delete[] cpoints;
 907     }
 908     else
 909     {
 910         int i;
 911         for (i = 0; i < n; i++)
 912             CalcBoundingBox(points[i].x, points[i].y);
 913
 914         (void)Polyline(GetHdc(), (POINT*) points, n);
 915     }
 916 }
 917
 918 void wxMSWDCImpl::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 919 {
 920     WXMICROWIN_CHECK_HDC
 921
 922     wxBrushAttrsSetter cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
 923
 924     wxCoord x2 = x + width;
 925     wxCoord y2 = y + height;
 926
 927     wxCoord x2dev = XLOG2DEV(x2),
 928             y2dev = YLOG2DEV(y2);
 929
 930     // Windows (but not Windows CE) draws the filled rectangles without outline
 931     // (i.e. drawn with a transparent pen) one pixel smaller in both directions
 932     // and we want them to have the same size regardless of which pen is used
 933 #ifndef __WXWINCE__
 934     if ( m_pen.IsTransparent() )
 935     {
 936         x2dev++;
 937         y2dev++;
 938     }
 939 #endif // !__WXWINCE__
 940
 941     (void)Rectangle(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), x2dev, y2dev);
 942
 943     CalcBoundingBox(x, y);
 944     CalcBoundingBox(x2, y2);
 945 }
 946
 947 void wxMSWDCImpl::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius)
 948 {
 949     WXMICROWIN_CHECK_HDC
 950
 951     wxBrushAttrsSetter cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
 952
 953     // Now, a negative radius value is interpreted to mean
 954     // 'the proportion of the smallest X or Y dimension'
 955
 956     if (radius < 0.0)
 957     {
 958         double smallest = (width < height) ? width : height;
 959         radius = (- radius * smallest);
 960     }
 961
 962     wxCoord x2 = (x+width);
 963     wxCoord y2 = (y+height);
 964
 965     // Windows draws the filled rectangles without outline (i.e. drawn with a
 966     // transparent pen) one pixel smaller in both directions and we want them
 967     // to have the same size regardless of which pen is used - adjust
 968     if ( m_pen.IsTransparent() )
 969     {
 970         x2++;
 971         y2++;
 972     }
 973
 974     (void)RoundRect(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2),
 975         YLOG2DEV(y2), (int) (2*XLOG2DEV(radius)), (int)( 2*YLOG2DEV(radius)));
 976
 977     CalcBoundingBox(x, y);
 978     CalcBoundingBox(x2, y2);
 979 }
 980
 981 void wxMSWDCImpl::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 982 {
 983     WXMICROWIN_CHECK_HDC
 984
 985     wxBrushAttrsSetter cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
 986
 987     // +1 below makes the ellipse more similar to other platforms.
 988     // In particular, DoDrawEllipse(x,y,1,1) should draw one point.
 989     wxCoord x2 = x + width + 1;
 990     wxCoord y2 = y + height + 1;
 991
 992     // Problem: Windows GDI Ellipse() with x2-x == y2-y == 3 and transparent
 993     // pen doesn't draw anything. Should we provide a workaround?
 994
 995     ::Ellipse(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
 996
 997     CalcBoundingBox(x, y);
 998     CalcBoundingBox(x2, y2);
 999 }
1000
1001 #if wxUSE_SPLINES && !defined(__WXWINCE__)
1002 void wxMSWDCImpl::DoDrawSpline(const wxPointList *points)
1003 {
1004     // quadratic b-spline to cubic bezier spline conversion
1005     //
1006     // quadratic spline with control points P0,P1,P2
1007     // P(s) = P0*(1-s)^2 + P1*2*(1-s)*s + P2*s^2
1008     //
1009     // bezier spline with control points B0,B1,B2,B3
1010     // B(s) = B0*(1-s)^3 + B1*3*(1-s)^2*s + B2*3*(1-s)*s^2 + B3*s^3
1011     //
1012     // control points of bezier spline calculated from b-spline
1013     // B0 = P0
1014     // B1 = (2*P1 + P0)/3
1015     // B2 = (2*P1 + P2)/3
1016     // B3 = P2
1017
1018     WXMICROWIN_CHECK_HDC
1019
1020     wxASSERT_MSG( points, wxT("NULL pointer to spline points?") );
1021
1022     const size_t n_points = points->GetCount();
1023     wxASSERT_MSG( n_points > 2 , wxT("incomplete list of spline points?") );
1024
1025     const size_t n_bezier_points = n_points * 3 + 1;
1026     POINT *lppt = (POINT *)malloc(n_bezier_points*sizeof(POINT));
1027     size_t bezier_pos = 0;
1028     wxCoord x1, y1, x2, y2, cx1, cy1, cx4, cy4;
1029
1030     wxPointList::compatibility_iterator node = points->GetFirst();
1031     wxPoint *p = node->GetData();
1032     lppt[ bezier_pos ].x = x1 = p->x;
1033     lppt[ bezier_pos ].y = y1 = p->y;
1034     bezier_pos++;
1035     lppt[ bezier_pos ] = lppt[ bezier_pos-1 ];
1036     bezier_pos++;
1037
1038     node = node->GetNext();
1039     p = node->GetData();
1040
1041     x2 = p->x;
1042     y2 = p->y;
1043     cx1 = ( x1 + x2 ) / 2;
1044     cy1 = ( y1 + y2 ) / 2;
1045     lppt[ bezier_pos ].x = XLOG2DEV(cx1);
1046     lppt[ bezier_pos ].y = YLOG2DEV(cy1);
1047     bezier_pos++;
1048     lppt[ bezier_pos ] = lppt[ bezier_pos-1 ];
1049     bezier_pos++;
1050
1051 #if !wxUSE_STL
1052     while ((node = node->GetNext()) != NULL)
1053 #else
1054     while ((node = node->GetNext()))
1055 #endif // !wxUSE_STL
1056     {
1057         p = (wxPoint *)node->GetData();
1058         x1 = x2;
1059         y1 = y2;
1060         x2 = p->x;
1061         y2 = p->y;
1062         cx4 = (x1 + x2) / 2;
1063         cy4 = (y1 + y2) / 2;
1064         // B0 is B3 of previous segment
1065         // B1:
1066         lppt[ bezier_pos ].x = XLOG2DEV((x1*2+cx1)/3);
1067         lppt[ bezier_pos ].y = YLOG2DEV((y1*2+cy1)/3);
1068         bezier_pos++;
1069         // B2:
1070         lppt[ bezier_pos ].x = XLOG2DEV((x1*2+cx4)/3);
1071         lppt[ bezier_pos ].y = YLOG2DEV((y1*2+cy4)/3);
1072         bezier_pos++;
1073         // B3:
1074         lppt[ bezier_pos ].x = XLOG2DEV(cx4);
1075         lppt[ bezier_pos ].y = YLOG2DEV(cy4);
1076         bezier_pos++;
1077         cx1 = cx4;
1078         cy1 = cy4;
1079     }
1080
1081     lppt[ bezier_pos ] = lppt[ bezier_pos-1 ];
1082     bezier_pos++;
1083     lppt[ bezier_pos ].x = XLOG2DEV(x2);
1084     lppt[ bezier_pos ].y = YLOG2DEV(y2);
1085     bezier_pos++;
1086     lppt[ bezier_pos ] = lppt[ bezier_pos-1 ];
1087     bezier_pos++;
1088
1089     ::PolyBezier( GetHdc(), lppt, bezier_pos );
1090
1091     free(lppt);
1092 }
1093 #endif // wxUSE_SPLINES
1094
1095 // Chris Breeze 20/5/98: first implementation of DrawEllipticArc on Windows
1096 void wxMSWDCImpl::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea)
1097 {
1098 #ifdef __WXWINCE__
1099     DoDrawEllipticArcRot( x, y, w, h, sa, ea );
1100 #else
1101
1102     WXMICROWIN_CHECK_HDC
1103
1104     wxBrushAttrsSetter cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
1105
1106     wxCoord x2 = x + w;
1107     wxCoord y2 = y + h;
1108
1109     int rx1 = XLOG2DEV(x+w/2);
1110     int ry1 = YLOG2DEV(y+h/2);
1111     int rx2 = rx1;
1112     int ry2 = ry1;
1113
1114     sa = DegToRad(sa);
1115     ea = DegToRad(ea);
1116
1117     rx1 += (int)(100.0 * abs(w) * cos(sa));
1118     ry1 -= (int)(100.0 * abs(h) * m_signY * sin(sa));
1119     rx2 += (int)(100.0 * abs(w) * cos(ea));
1120     ry2 -= (int)(100.0 * abs(h) * m_signY * sin(ea));
1121
1122     // Swap start and end positions if the end angle is less than the start angle.
1123     if (ea < sa) {
1124         int temp;
1125         temp = rx2;
1126         rx2 = rx1;
1127         rx1 = temp;
1128         temp = ry2;
1129         ry2 = ry1;
1130         ry1 = temp;
1131     }
1132
1133     // draw pie with NULL_PEN first and then outline otherwise a line is
1134     // drawn from the start and end points to the centre
1135     HPEN hpenOld = (HPEN) ::SelectObject(GetHdc(), (HPEN) ::GetStockObject(NULL_PEN));
1136     if (m_signY > 0)
1137     {
1138         (void)Pie(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2)+1, YLOG2DEV(y2)+1,
1139                   rx1, ry1, rx2, ry2);
1140     }
1141     else
1142     {
1143         (void)Pie(GetHdc(), XLOG2DEV(x), YLOG2DEV(y)-1, XLOG2DEV(x2)+1, YLOG2DEV(y2),
1144                   rx1, ry1-1, rx2, ry2-1);
1145     }
1146
1147     ::SelectObject(GetHdc(), hpenOld);
1148
1149     (void)Arc(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2),
1150               rx1, ry1, rx2, ry2);
1151
1152     CalcBoundingBox(x, y);
1153     CalcBoundingBox(x2, y2);
1154 #endif
1155 }
1156
1157 void wxMSWDCImpl::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
1158 {
1159     WXMICROWIN_CHECK_HDC
1160
1161     wxCHECK_RET( icon.IsOk(), wxT("invalid icon in DrawIcon") );
1162
1163 #ifdef __WIN32__
1164     ::DrawIconEx(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), GetHiconOf(icon), icon.GetWidth(), icon.GetHeight(), 0, NULL, DI_NORMAL);
1165 #else
1166     ::DrawIcon(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), GetHiconOf(icon));
1167 #endif
1168
1169     CalcBoundingBox(x, y);
1170     CalcBoundingBox(x + icon.GetWidth(), y + icon.GetHeight());
1171 }
1172
1173 void wxMSWDCImpl::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask )
1174 {
1175     WXMICROWIN_CHECK_HDC
1176
1177     wxCHECK_RET( bmp.IsOk(), wxT("invalid bitmap in wxMSWDCImpl::DrawBitmap") );
1178
1179     int width = bmp.GetWidth(),
1180         height = bmp.GetHeight();
1181
1182     HBITMAP hbmpMask = 0;
1183
1184 #if wxUSE_PALETTE
1185     HPALETTE oldPal = 0;
1186 #endif // wxUSE_PALETTE
1187
1188     if ( bmp.HasAlpha() )
1189     {
1190         MemoryHDC hdcMem;
1191         SelectInHDC select(hdcMem, GetHbitmapOf(bmp));
1192
1193         if ( AlphaBlt(GetHdc(), x, y, width, height, 0, 0, width, height, hdcMem, bmp) )
1194             return;
1195     }
1196
1197     SET_STRETCH_BLT_MODE(GetHdc());
1198
1199     if ( useMask )
1200     {
1201         wxMask *mask = bmp.GetMask();
1202         if ( mask )
1203             hbmpMask = (HBITMAP)mask->GetMaskBitmap();
1204
1205         if ( !hbmpMask )
1206         {
1207             // don't give assert here because this would break existing
1208             // programs - just silently ignore useMask parameter
1209             useMask = false;
1210         }
1211     }
1212     if ( useMask )
1213     {
1214 #ifdef __WIN32__
1215         // use MaskBlt() with ROP which doesn't do anything to dst in the mask
1216         // points
1217         bool ok = false;
1218
1219 #if wxUSE_SYSTEM_OPTIONS
1220         // On some systems, MaskBlt succeeds yet is much much slower
1221         // than the wxWidgets fall-back implementation. So we need
1222         // to be able to switch this on and off at runtime.
1223         //
1224         // NB: don't query the value of the option every time but do it only
1225         //     once as otherwise it can have real (and bad) performance
1226         //     implications (see #11172)
1227         static bool
1228             s_maskBltAllowed = wxSystemOptions::GetOptionInt("no-maskblt") == 0;
1229         if ( s_maskBltAllowed )
1230 #endif // wxUSE_SYSTEM_OPTIONS
1231         {
1232             HDC cdc = GetHdc();
1233             HDC hdcMem = ::CreateCompatibleDC(GetHdc());
1234             HGDIOBJ hOldBitmap = ::SelectObject(hdcMem, GetHbitmapOf(bmp));
1235 #if wxUSE_PALETTE
1236             wxPalette *pal = bmp.GetPalette();
1237             if ( pal && ::GetDeviceCaps(cdc,BITSPIXEL) <= 8 )
1238             {
1239                 oldPal = ::SelectPalette(hdcMem, GetHpaletteOf(*pal), FALSE);
1240                 ::RealizePalette(hdcMem);
1241             }
1242 #endif // wxUSE_PALETTE
1243
1244             ok = ::MaskBlt(cdc, x, y, width, height,
1245                             hdcMem, 0, 0,
1246                             hbmpMask, 0, 0,
1247                             MAKEROP4(SRCCOPY, DSTCOPY)) != 0;
1248
1249 #if wxUSE_PALETTE
1250             if (oldPal)
1251                 ::SelectPalette(hdcMem, oldPal, FALSE);
1252 #endif // wxUSE_PALETTE
1253
1254             ::SelectObject(hdcMem, hOldBitmap);
1255             ::DeleteDC(hdcMem);
1256         }
1257
1258         if ( !ok )
1259 #endif // Win32
1260         {
1261             // Rather than reproduce wxMSWDCImpl::Blit, let's do it at the wxWin API
1262             // level
1263             wxMemoryDC memDC;
1264
1265             memDC.SelectObjectAsSource(bmp);
1266
1267             GetOwner()->Blit(x, y, width, height, &memDC, 0, 0, wxCOPY, useMask);
1268
1269             memDC.SelectObject(wxNullBitmap);
1270         }
1271     }
1272     else // no mask, just use BitBlt()
1273     {
1274         HDC cdc = GetHdc();
1275         HDC memdc = ::CreateCompatibleDC( cdc );
1276         HBITMAP hbitmap = (HBITMAP) bmp.GetHBITMAP( );
1277
1278         wxASSERT_MSG( hbitmap, wxT("bitmap is ok but HBITMAP is NULL?") );
1279
1280         wxTextColoursChanger textCol(GetHdc(), *this);
1281
1282 #if wxUSE_PALETTE
1283         wxPalette *pal = bmp.GetPalette();
1284         if ( pal && ::GetDeviceCaps(cdc,BITSPIXEL) <= 8 )
1285         {
1286             oldPal = ::SelectPalette(memdc, GetHpaletteOf(*pal), FALSE);
1287             ::RealizePalette(memdc);
1288         }
1289 #endif // wxUSE_PALETTE
1290
1291         HGDIOBJ hOldBitmap = ::SelectObject( memdc, hbitmap );
1292         ::BitBlt( cdc, x, y, width, height, memdc, 0, 0, SRCCOPY);
1293
1294 #if wxUSE_PALETTE
1295         if (oldPal)
1296             ::SelectPalette(memdc, oldPal, FALSE);
1297 #endif // wxUSE_PALETTE
1298
1299         ::SelectObject( memdc, hOldBitmap );
1300         ::DeleteDC( memdc );
1301     }
1302 }
1303
1304 void wxMSWDCImpl::DoDrawText(const wxString& text, wxCoord x, wxCoord y)
1305 {
1306     // For compatibility with other ports (notably wxGTK) and because it's
1307     // genuinely useful, we allow passing multiline strings to DrawText().
1308     // However there is no native MSW function to draw them directly so we
1309     // instead reuse the generic DrawLabel() method to render them. Of course,
1310     // DrawLabel() itself will call back to us but with single line strings
1311     // only so there won't be any infinite recursion here.
1312     if ( text.find('\n') != wxString::npos )
1313     {
1314         GetOwner()->DrawLabel(text, wxRect(x, y, 0, 0));
1315         return;
1316     }
1317
1318     WXMICROWIN_CHECK_HDC
1319
1320     DrawAnyText(text, x, y);
1321
1322     // update the bounding box
1323     CalcBoundingBox(x, y);
1324
1325     wxCoord w, h;
1326     GetOwner()->GetTextExtent(text, &w, &h);
1327     CalcBoundingBox(x + w, y + h);
1328 }
1329
1330 void wxMSWDCImpl::DrawAnyText(const wxString& text, wxCoord x, wxCoord y)
1331 {
1332     WXMICROWIN_CHECK_HDC
1333
1334     // prepare for drawing the text
1335     wxTextColoursChanger textCol(GetHdc(), *this);
1336
1337     wxBkModeChanger bkMode(GetHdc(), m_backgroundMode);
1338
1339     if ( ::ExtTextOut(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), 0, NULL,
1340                    text.c_str(), text.length(), NULL) == 0 )
1341     {
1342         wxLogLastError(wxT("TextOut"));
1343     }
1344 }
1345
1346 void wxMSWDCImpl::DoDrawRotatedText(const wxString& text,
1347                              wxCoord x, wxCoord y,
1348                              double angle)
1349 {
1350     WXMICROWIN_CHECK_HDC
1351
1352     // we test that we have some font because otherwise we should still use the
1353     // "else" part below to avoid that DrawRotatedText(angle = 180) and
1354     // DrawRotatedText(angle = 0) use different fonts (we can't use the default
1355     // font for drawing rotated fonts unfortunately)
1356     if ( (angle == 0.0) && m_font.IsOk() )
1357     {
1358         DoDrawText(text, x, y);
1359     }
1360 #ifndef __WXMICROWIN__
1361     else
1362     {
1363         // NB: don't take DEFAULT_GUI_FONT (a.k.a. wxSYS_DEFAULT_GUI_FONT)
1364         //     because it's not TrueType and so can't have non zero
1365         //     orientation/escapement under Win9x
1366         wxFont font = m_font.IsOk() ? m_font : *wxSWISS_FONT;
1367         HFONT hfont = (HFONT)font.GetResourceHandle();
1368         LOGFONT lf;
1369         if ( ::GetObject(hfont, sizeof(lf), &lf) == 0 )
1370         {
1371             wxLogLastError(wxT("GetObject(hfont)"));
1372         }
1373
1374         // GDI wants the angle in tenth of degree
1375         long angle10 = (long)(angle * 10);
1376         lf.lfEscapement = angle10;
1377         lf. lfOrientation = angle10;
1378
1379         hfont = ::CreateFontIndirect(&lf);
1380         if ( !hfont )
1381         {
1382             wxLogLastError(wxT("CreateFont"));
1383         }
1384         else
1385         {
1386             HFONT hfontOld = (HFONT)::SelectObject(GetHdc(), hfont);
1387
1388             DrawAnyText(text, x, y);
1389
1390             (void)::SelectObject(GetHdc(), hfontOld);
1391             (void)::DeleteObject(hfont);
1392         }
1393
1394         // call the bounding box by adding all four vertices of the rectangle
1395         // containing the text to it (simpler and probably not slower than
1396         // determining which of them is really topmost/leftmost/...)
1397         wxCoord w, h;
1398         GetOwner()->GetTextExtent(text, &w, &h);
1399
1400         double rad = DegToRad(angle);
1401
1402         // "upper left" and "upper right"
1403         CalcBoundingBox(x, y);
1404         CalcBoundingBox(x + wxCoord(w*cos(rad)), y - wxCoord(w*sin(rad)));
1405
1406         // "bottom left" and "bottom right"
1407         x += (wxCoord)(h*sin(rad));
1408         y += (wxCoord)(h*cos(rad));
1409         CalcBoundingBox(x, y);
1410         CalcBoundingBox(x + wxCoord(w*cos(rad)), y - wxCoord(w*sin(rad)));
1411     }
1412 #endif
1413 }
1414
1415 // ---------------------------------------------------------------------------
1416 // set GDI objects
1417 // ---------------------------------------------------------------------------
1418
1419 #if wxUSE_PALETTE
1420
1421 void wxMSWDCImpl::DoSelectPalette(bool realize)
1422 {
1423     WXMICROWIN_CHECK_HDC
1424
1425     // Set the old object temporarily, in case the assignment deletes an object
1426     // that's not yet selected out.
1427     if (m_oldPalette)
1428     {
1429         ::SelectPalette(GetHdc(), (HPALETTE) m_oldPalette, FALSE);
1430         m_oldPalette = 0;
1431     }
1432
1433     if ( m_palette.IsOk() )
1434     {
1435         HPALETTE oldPal = ::SelectPalette(GetHdc(),
1436                                           GetHpaletteOf(m_palette),
1437                                           false);
1438         if (!m_oldPalette)
1439             m_oldPalette = (WXHPALETTE) oldPal;
1440
1441         if (realize)
1442             ::RealizePalette(GetHdc());
1443     }
1444 }
1445
1446 void wxMSWDCImpl::SetPalette(const wxPalette& palette)
1447 {
1448     if ( palette.IsOk() )
1449     {
1450         m_palette = palette;
1451         DoSelectPalette(true);
1452     }
1453 }
1454
1455 void wxMSWDCImpl::InitializePalette()
1456 {
1457     if ( wxDisplayDepth() <= 8 )
1458     {
1459         // look for any window or parent that has a custom palette. If any has
1460         // one then we need to use it in drawing operations
1461         wxWindow *win = m_window->GetAncestorWithCustomPalette();
1462
1463         m_hasCustomPalette = win && win->HasCustomPalette();
1464         if ( m_hasCustomPalette )
1465         {
1466             m_palette = win->GetPalette();
1467
1468             // turn on MSW translation for this palette
1469             DoSelectPalette();
1470         }
1471     }
1472 }
1473
1474 #endif // wxUSE_PALETTE
1475
1476 // SetFont/Pen/Brush() really ask to be implemented as a single template
1477 // function... but doing it is not worth breaking OpenWatcom build <sigh>
1478
1479 void wxMSWDCImpl::SetFont(const wxFont& font)
1480 {
1481     WXMICROWIN_CHECK_HDC
1482
1483     if ( font == m_font )
1484         return;
1485
1486     if ( font.IsOk() )
1487     {
1488         HGDIOBJ hfont = ::SelectObject(GetHdc(), GetHfontOf(font));
1489         if ( hfont == HGDI_ERROR )
1490         {
1491             wxLogLastError(wxT("SelectObject(font)"));
1492         }
1493         else // selected ok
1494         {
1495             if ( !m_oldFont )
1496                 m_oldFont = (WXHFONT)hfont;
1497
1498             m_font = font;
1499         }
1500     }
1501     else // invalid font, reset the current font
1502     {
1503         if ( m_oldFont )
1504         {
1505             if ( ::SelectObject(GetHdc(), (HPEN) m_oldFont) == HGDI_ERROR )
1506             {
1507                 wxLogLastError(wxT("SelectObject(old font)"));
1508             }
1509
1510             m_oldFont = 0;
1511         }
1512
1513         m_font = wxNullFont;
1514     }
1515 }
1516
1517 void wxMSWDCImpl::SetPen(const wxPen& pen)
1518 {
1519     WXMICROWIN_CHECK_HDC
1520
1521     if ( pen == m_pen )
1522         return;
1523
1524     if ( pen.IsOk() )
1525     {
1526         HGDIOBJ hpen = ::SelectObject(GetHdc(), GetHpenOf(pen));
1527         if ( hpen == HGDI_ERROR )
1528         {
1529             wxLogLastError(wxT("SelectObject(pen)"));
1530         }
1531         else // selected ok
1532         {
1533             if ( !m_oldPen )
1534                 m_oldPen = (WXHPEN)hpen;
1535
1536             m_pen = pen;
1537         }
1538     }
1539     else // invalid pen, reset the current pen
1540     {
1541         if ( m_oldPen )
1542         {
1543             if ( ::SelectObject(GetHdc(), (HPEN) m_oldPen) == HGDI_ERROR )
1544             {
1545                 wxLogLastError(wxT("SelectObject(old pen)"));
1546             }
1547
1548             m_oldPen = 0;
1549         }
1550
1551         m_pen = wxNullPen;
1552     }
1553 }
1554
1555 void wxMSWDCImpl::SetBrush(const wxBrush& brush)
1556 {
1557     WXMICROWIN_CHECK_HDC
1558
1559     if ( brush == m_brush )
1560         return;
1561
1562     if ( brush.IsOk() )
1563     {
1564         // we must make sure the brush is aligned with the logical coordinates
1565         // before selecting it or using the same brush for the background of
1566         // different windows would result in discontinuities
1567         wxSize sizeBrushBitmap = wxDefaultSize;
1568         wxBitmap *stipple = brush.GetStipple();
1569         if ( stipple && stipple->IsOk() )
1570             sizeBrushBitmap = stipple->GetSize();
1571         else if ( brush.IsHatch() )
1572             sizeBrushBitmap = wxSize(8, 8);
1573
1574         if ( sizeBrushBitmap.IsFullySpecified() )
1575         {
1576             if ( !::SetBrushOrgEx
1577                     (
1578                         GetHdc(),
1579                         m_deviceOriginX % sizeBrushBitmap.x,
1580                         m_deviceOriginY % sizeBrushBitmap.y,
1581                         NULL                    // [out] previous brush origin
1582                     ) )
1583             {
1584                 wxLogLastError(wxT("SetBrushOrgEx()"));
1585             }
1586         }
1587
1588         HGDIOBJ hbrush = ::SelectObject(GetHdc(), GetHbrushOf(brush));
1589         if ( hbrush == HGDI_ERROR )
1590         {
1591             wxLogLastError(wxT("SelectObject(brush)"));
1592         }
1593         else // selected ok
1594         {
1595             if ( !m_oldBrush )
1596                 m_oldBrush = (WXHBRUSH)hbrush;
1597
1598             m_brush = brush;
1599         }
1600     }
1601     else // invalid brush, reset the current brush
1602     {
1603         if ( m_oldBrush )
1604         {
1605             if ( ::SelectObject(GetHdc(), (HPEN) m_oldBrush) == HGDI_ERROR )
1606             {
1607                 wxLogLastError(wxT("SelectObject(old brush)"));
1608             }
1609
1610             m_oldBrush = 0;
1611         }
1612
1613         m_brush = wxNullBrush;
1614     }
1615 }
1616
1617 void wxMSWDCImpl::SetBackground(const wxBrush& brush)
1618 {
1619     WXMICROWIN_CHECK_HDC
1620
1621     m_backgroundBrush = brush;
1622
1623     if ( m_backgroundBrush.IsOk() )
1624     {
1625         (void)SetBkColor(GetHdc(), m_backgroundBrush.GetColour().GetPixel());
1626     }
1627 }
1628
1629 void wxMSWDCImpl::SetBackgroundMode(int mode)
1630 {
1631     WXMICROWIN_CHECK_HDC
1632
1633     m_backgroundMode = mode;
1634
1635     // SetBackgroundColour now only refers to text background
1636     // and m_backgroundMode is used there
1637 }
1638
1639 void wxMSWDCImpl::SetLogicalFunction(wxRasterOperationMode function)
1640 {
1641     WXMICROWIN_CHECK_HDC
1642
1643     m_logicalFunction = function;
1644
1645     SetRop(m_hDC);
1646 }
1647
1648 void wxMSWDCImpl::SetRop(WXHDC dc)
1649 {
1650     if ( !dc || m_logicalFunction < 0 )
1651         return;
1652
1653     int rop;
1654
1655     switch (m_logicalFunction)
1656     {
1657         case wxCLEAR:        rop = R2_BLACK;         break;
1658         case wxXOR:          rop = R2_XORPEN;        break;
1659         case wxINVERT:       rop = R2_NOT;           break;
1660         case wxOR_REVERSE:   rop = R2_MERGEPENNOT;   break;
1661         case wxAND_REVERSE:  rop = R2_MASKPENNOT;    break;
1662         case wxCOPY:         rop = R2_COPYPEN;       break;
1663         case wxAND:          rop = R2_MASKPEN;       break;
1664         case wxAND_INVERT:   rop = R2_MASKNOTPEN;    break;
1665         case wxNO_OP:        rop = R2_NOP;           break;
1666         case wxNOR:          rop = R2_NOTMERGEPEN;   break;
1667         case wxEQUIV:        rop = R2_NOTXORPEN;     break;
1668         case wxSRC_INVERT:   rop = R2_NOTCOPYPEN;    break;
1669         case wxOR_INVERT:    rop = R2_MERGENOTPEN;   break;
1670         case wxNAND:         rop = R2_NOTMASKPEN;    break;
1671         case wxOR:           rop = R2_MERGEPEN;      break;
1672         case wxSET:          rop = R2_WHITE;         break;
1673         default:
1674             wxFAIL_MSG( wxS("unknown logical function") );
1675             return;
1676     }
1677
1678     SetROP2(GetHdc(), rop);
1679 }
1680
1681 bool wxMSWDCImpl::StartDoc(const wxString& WXUNUSED(message))
1682 {
1683     // We might be previewing, so return true to let it continue.
1684     return true;
1685 }
1686
1687 void wxMSWDCImpl::EndDoc()
1688 {
1689 }
1690
1691 void wxMSWDCImpl::StartPage()
1692 {
1693 }
1694
1695 void wxMSWDCImpl::EndPage()
1696 {
1697 }
1698
1699 // ---------------------------------------------------------------------------
1700 // text metrics
1701 // ---------------------------------------------------------------------------
1702
1703 wxCoord wxMSWDCImpl::GetCharHeight() const
1704 {
1705     WXMICROWIN_CHECK_HDC_RET(0)
1706
1707     TEXTMETRIC lpTextMetric;
1708
1709     GetTextMetrics(GetHdc(), &lpTextMetric);
1710
1711     return lpTextMetric.tmHeight;
1712 }
1713
1714 wxCoord wxMSWDCImpl::GetCharWidth() const
1715 {
1716     WXMICROWIN_CHECK_HDC_RET(0)
1717
1718     TEXTMETRIC lpTextMetric;
1719
1720     GetTextMetrics(GetHdc(), &lpTextMetric);
1721
1722     return lpTextMetric.tmAveCharWidth;
1723 }
1724
1725 void wxMSWDCImpl::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
1726                            wxCoord *descent, wxCoord *externalLeading,
1727                            const wxFont *font) const
1728 {
1729 #ifdef __WXMICROWIN__
1730     if (!GetHDC())
1731     {
1732         if (x) *x = 0;
1733         if (y) *y = 0;
1734         if (descent) *descent = 0;
1735         if (externalLeading) *externalLeading = 0;
1736         return;
1737     }
1738 #endif // __WXMICROWIN__
1739
1740     HFONT hfontOld;
1741     if ( font )
1742     {
1743         wxASSERT_MSG( font->IsOk(), wxT("invalid font in wxMSWDCImpl::GetTextExtent") );
1744
1745         hfontOld = (HFONT)::SelectObject(GetHdc(), GetHfontOf(*font));
1746     }
1747     else // don't change the font
1748     {
1749         hfontOld = 0;
1750     }
1751
1752     SIZE sizeRect;
1753     const size_t len = string.length();
1754     if ( !::GetTextExtentPoint32(GetHdc(), string.wx_str(), len, &sizeRect) )
1755     {
1756         wxLogLastError(wxT("GetTextExtentPoint32()"));
1757     }
1758
1759 #if !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
1760     // the result computed by GetTextExtentPoint32() may be too small as it
1761     // accounts for under/overhang of the first/last character while we want
1762     // just the bounding rect for this string so adjust the width as needed
1763     // (using API not available in 2002 SDKs of WinCE)
1764     if ( len > 0 )
1765     {
1766         ABC width;
1767         const wxChar chFirst = *string.begin();
1768         if ( ::GetCharABCWidths(GetHdc(), chFirst, chFirst, &width) )
1769         {
1770             if ( width.abcA < 0 )
1771                 sizeRect.cx -= width.abcA;
1772
1773             if ( len > 1 )
1774             {
1775                 const wxChar chLast = *string.rbegin();
1776                 ::GetCharABCWidths(GetHdc(), chLast, chLast, &width);
1777             }
1778             //else: we already have the width of the last character
1779
1780             if ( width.abcC < 0 )
1781                 sizeRect.cx -= width.abcC;
1782         }
1783         //else: GetCharABCWidths() failed, not a TrueType font?
1784     }
1785 #endif // !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
1786
1787     if (x)
1788         *x = sizeRect.cx;
1789     if (y)
1790         *y = sizeRect.cy;
1791
1792     if ( descent || externalLeading )
1793     {
1794         TEXTMETRIC tm;
1795         ::GetTextMetrics(GetHdc(), &tm);
1796
1797         if (descent)
1798             *descent = tm.tmDescent;
1799         if (externalLeading)
1800             *externalLeading = tm.tmExternalLeading;
1801     }
1802
1803     if ( hfontOld )
1804     {
1805         ::SelectObject(GetHdc(), hfontOld);
1806     }
1807 }
1808
1809
1810 // Each element of the array will be the width of the string up to and
1811 // including the coresoponding character in text.
1812
1813 bool wxMSWDCImpl::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
1814 {
1815     static int maxLenText = -1;
1816     static int maxWidth = -1;
1817     int fit = 0;
1818     SIZE sz = {0,0};
1819     int stlen = text.length();
1820
1821     if (maxLenText == -1)
1822     {
1823         // Win9x and WinNT+ have different limits
1824         int version = wxGetOsVersion();
1825         maxLenText = version == wxOS_WINDOWS_NT ? 65535 : 8192;
1826         maxWidth =   version == wxOS_WINDOWS_NT ? INT_MAX : 32767;
1827     }
1828
1829     widths.Empty();
1830     widths.Add(0, stlen);  // fill the array with zeros
1831     if (stlen == 0)
1832         return true;
1833
1834     if (!::GetTextExtentExPoint(GetHdc(),
1835                                 text.c_str(),           // string to check
1836                                 wxMin(stlen, maxLenText),
1837                                 maxWidth,
1838                                 &fit,                   // [out] count of chars
1839                                                         // that will fit
1840                                 &widths[0],             // array to fill
1841                                 &sz))
1842     {
1843         // API failed
1844         wxLogLastError(wxT("GetTextExtentExPoint"));
1845         return false;
1846     }
1847
1848     return true;
1849 }
1850
1851 void wxMSWDCImpl::RealizeScaleAndOrigin()
1852 {
1853     // although it may seem wasteful to always use MM_ANISOTROPIC here instead
1854     // of using MM_TEXT if there is no scaling, benchmarking doesn't detect any
1855     // noticeable difference between these mapping modes
1856 #ifndef __WXWINCE__
1857     ::SetMapMode(GetHdc(), MM_ANISOTROPIC);
1858
1859     int width = DeviceToLogicalXRel(VIEWPORT_EXTENT)*m_signX,
1860         height = DeviceToLogicalYRel(VIEWPORT_EXTENT)*m_signY;
1861
1862     ::SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);
1863     ::SetWindowExtEx(GetHdc(), width, height, NULL);
1864
1865     ::SetViewportOrgEx(GetHdc(), m_deviceOriginX, m_deviceOriginY, NULL);
1866     ::SetWindowOrgEx(GetHdc(), m_logicalOriginX, m_logicalOriginY, NULL);
1867 #endif
1868 }
1869
1870 void wxMSWDCImpl::SetMapMode(wxMappingMode mode)
1871 {
1872     WXMICROWIN_CHECK_HDC
1873
1874     m_mappingMode = mode;
1875
1876     if ( mode == wxMM_TEXT )
1877     {
1878         m_logicalScaleX =
1879         m_logicalScaleY = 1.0;
1880     }
1881     else // need to do some calculations
1882     {
1883         int pixel_width = ::GetDeviceCaps(GetHdc(), HORZRES),
1884             pixel_height = ::GetDeviceCaps(GetHdc(), VERTRES),
1885             mm_width = ::GetDeviceCaps(GetHdc(), HORZSIZE),
1886             mm_height = ::GetDeviceCaps(GetHdc(), VERTSIZE);
1887
1888         if ( (mm_width == 0) || (mm_height == 0) )
1889         {
1890             // we can't calculate mm2pixels[XY] then!
1891             return;
1892         }
1893
1894         double mm2pixelsX = (double)pixel_width / mm_width,
1895                mm2pixelsY = (double)pixel_height / mm_height;
1896
1897         switch (mode)
1898         {
1899             case wxMM_TWIPS:
1900                 m_logicalScaleX = twips2mm * mm2pixelsX;
1901                 m_logicalScaleY = twips2mm * mm2pixelsY;
1902                 break;
1903
1904             case wxMM_POINTS:
1905                 m_logicalScaleX = pt2mm * mm2pixelsX;
1906                 m_logicalScaleY = pt2mm * mm2pixelsY;
1907                 break;
1908
1909             case wxMM_METRIC:
1910                 m_logicalScaleX = mm2pixelsX;
1911                 m_logicalScaleY = mm2pixelsY;
1912                 break;
1913
1914             case wxMM_LOMETRIC:
1915                 m_logicalScaleX = mm2pixelsX / 10.0;
1916                 m_logicalScaleY = mm2pixelsY / 10.0;
1917                 break;
1918
1919             default:
1920                 wxFAIL_MSG( wxT("unknown mapping mode in SetMapMode") );
1921         }
1922     }
1923
1924     ComputeScaleAndOrigin();
1925
1926     RealizeScaleAndOrigin();
1927 }
1928
1929 void wxMSWDCImpl::SetUserScale(double x, double y)
1930 {
1931     WXMICROWIN_CHECK_HDC
1932
1933     if ( x == m_userScaleX && y == m_userScaleY )
1934         return;
1935
1936     wxDCImpl::SetUserScale(x,y);
1937
1938     RealizeScaleAndOrigin();
1939 }
1940
1941 void wxMSWDCImpl::SetAxisOrientation(bool xLeftRight,
1942                               bool yBottomUp)
1943 {
1944     WXMICROWIN_CHECK_HDC
1945
1946     int signX = xLeftRight ? 1 : -1,
1947         signY = yBottomUp ? -1 : 1;
1948
1949     if (signX == m_signX && signY == m_signY)
1950         return;
1951
1952     wxDCImpl::SetAxisOrientation( xLeftRight, yBottomUp );
1953
1954     RealizeScaleAndOrigin();
1955 }
1956
1957 void wxMSWDCImpl::SetLogicalOrigin(wxCoord x, wxCoord y)
1958 {
1959     WXMICROWIN_CHECK_HDC
1960
1961     if ( x == m_logicalOriginX && y == m_logicalOriginY )
1962         return;
1963
1964     wxDCImpl::SetLogicalOrigin( x, y );
1965
1966     RealizeScaleAndOrigin();
1967 }
1968
1969 // For use by wxWidgets only, unless custom units are required.
1970 void wxMSWDCImpl::SetLogicalScale(double x, double y)
1971 {
1972     WXMICROWIN_CHECK_HDC
1973
1974     wxDCImpl::SetLogicalScale(x,y);
1975 }
1976
1977 void wxMSWDCImpl::SetDeviceOrigin(wxCoord x, wxCoord y)
1978 {
1979     WXMICROWIN_CHECK_HDC
1980
1981     if ( x == m_deviceOriginX && y == m_deviceOriginY )
1982         return;
1983
1984     wxDCImpl::SetDeviceOrigin( x, y );
1985
1986     ::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
1987 }
1988
1989 // ---------------------------------------------------------------------------
1990 // bit blit
1991 // ---------------------------------------------------------------------------
1992
1993 bool wxMSWDCImpl::DoBlit(wxCoord dstX, wxCoord dstY,
1994                   wxCoord dstWidth, wxCoord dstHeight,
1995                   wxDC *source,
1996                   wxCoord srcX, wxCoord srcY,
1997                   wxRasterOperationMode rop, bool useMask,
1998                   wxCoord srcMaskX, wxCoord srcMaskY)
1999 {
2000     return DoStretchBlit(dstX, dstY, dstWidth, dstHeight, source, srcX, srcY, dstWidth, dstHeight, rop, useMask, srcMaskX, srcMaskY);
2001 }
2002
2003 bool wxMSWDCImpl::DoStretchBlit(wxCoord xdest, wxCoord ydest,
2004                          wxCoord dstWidth, wxCoord dstHeight,
2005                          wxDC *source,
2006                          wxCoord xsrc, wxCoord ysrc,
2007                          wxCoord srcWidth, wxCoord srcHeight,
2008                          wxRasterOperationMode rop, bool useMask,
2009                          wxCoord xsrcMask, wxCoord ysrcMask)
2010 {
2011     wxCHECK_MSG( source, false, wxT("wxMSWDCImpl::Blit(): NULL wxDC pointer") );
2012
2013     WXMICROWIN_CHECK_HDC_RET(false)
2014
2015     wxMSWDCImpl *implSrc = wxDynamicCast( source->GetImpl(), wxMSWDCImpl );
2016     if ( !implSrc )
2017     {
2018         // TODO: Do we want to be able to blit from other DCs too?
2019         return false;
2020     }
2021
2022     const HDC hdcSrc = GetHdcOf(*implSrc);
2023
2024     // if either the source or destination has alpha channel, we must use
2025     // AlphaBlt() as other function don't handle it correctly
2026     const wxBitmap& bmpSrc = implSrc->GetSelectedBitmap();
2027     if ( bmpSrc.IsOk() && (bmpSrc.HasAlpha() ||
2028             (m_selectedBitmap.IsOk() && m_selectedBitmap.HasAlpha())) )
2029     {
2030         if ( AlphaBlt(GetHdc(), xdest, ydest, dstWidth, dstHeight,
2031                       xsrc, ysrc, srcWidth, srcHeight, hdcSrc, bmpSrc) )
2032             return true;
2033     }
2034
2035     wxMask *mask = NULL;
2036     if ( useMask )
2037     {
2038         mask = bmpSrc.GetMask();
2039
2040         if ( !(bmpSrc.IsOk() && mask && mask->GetMaskBitmap()) )
2041         {
2042             // don't give assert here because this would break existing
2043             // programs - just silently ignore useMask parameter
2044             useMask = false;
2045         }
2046     }
2047
2048     if (xsrcMask == -1 && ysrcMask == -1)
2049     {
2050         xsrcMask = xsrc; ysrcMask = ysrc;
2051     }
2052
2053     wxTextColoursChanger textCol(GetHdc(), *this);
2054
2055     DWORD dwRop;
2056     switch (rop)
2057     {
2058         case wxXOR:          dwRop = SRCINVERT;        break;
2059         case wxINVERT:       dwRop = DSTINVERT;        break;
2060         case wxOR_REVERSE:   dwRop = 0x00DD0228;       break;
2061         case wxAND_REVERSE:  dwRop = SRCERASE;         break;
2062         case wxCLEAR:        dwRop = BLACKNESS;        break;
2063         case wxSET:          dwRop = WHITENESS;        break;
2064         case wxOR_INVERT:    dwRop = MERGEPAINT;       break;
2065         case wxAND:          dwRop = SRCAND;           break;
2066         case wxOR:           dwRop = SRCPAINT;         break;
2067         case wxEQUIV:        dwRop = 0x00990066;       break;
2068         case wxNAND:         dwRop = 0x007700E6;       break;
2069         case wxAND_INVERT:   dwRop = 0x00220326;       break;
2070         case wxCOPY:         dwRop = SRCCOPY;          break;
2071         case wxNO_OP:        dwRop = DSTCOPY;          break;
2072         case wxSRC_INVERT:   dwRop = NOTSRCCOPY;       break;
2073         case wxNOR:          dwRop = NOTSRCCOPY;       break;
2074         default:
2075            wxFAIL_MSG( wxT("unsupported logical function") );
2076            return false;
2077     }
2078
2079     bool success = false;
2080
2081     if (useMask)
2082     {
2083 #ifdef __WIN32__
2084         // we want the part of the image corresponding to the mask to be
2085         // transparent, so use "DSTCOPY" ROP for the mask points (the usual
2086         // meaning of fg and bg is inverted which corresponds to wxWin notion
2087         // of the mask which is also contrary to the Windows one)
2088
2089         // On some systems, MaskBlt succeeds yet is much much slower
2090         // than the wxWidgets fall-back implementation. So we need
2091         // to be able to switch this on and off at runtime.
2092 #if wxUSE_SYSTEM_OPTIONS
2093         if (wxSystemOptions::GetOptionInt(wxT("no-maskblt")) == 0)
2094 #endif
2095         {
2096             if ( dstWidth == srcWidth && dstHeight == srcHeight )
2097             {
2098                 success = ::MaskBlt
2099                             (
2100                             GetHdc(),
2101                             xdest, ydest, dstWidth, dstHeight,
2102                             hdcSrc,
2103                             xsrc, ysrc,
2104                             (HBITMAP)mask->GetMaskBitmap(),
2105                             xsrcMask, ysrcMask,
2106                             MAKEROP4(dwRop, DSTCOPY)
2107                             ) != 0;
2108             }
2109         }
2110
2111         if ( !success )
2112 #endif // Win32
2113         {
2114             // Blit bitmap with mask
2115             HDC dc_mask ;
2116             HDC  dc_buffer ;
2117             HBITMAP buffer_bmap ;
2118
2119 #if wxUSE_DC_CACHEING
2120             // create a temp buffer bitmap and DCs to access it and the mask
2121             wxDCCacheEntry* dcCacheEntry1 = FindDCInCache(NULL, hdcSrc);
2122             dc_mask = (HDC) dcCacheEntry1->m_dc;
2123
2124             wxDCCacheEntry* dcCacheEntry2 = FindDCInCache(dcCacheEntry1, GetHDC());
2125             dc_buffer = (HDC) dcCacheEntry2->m_dc;
2126
2127             wxDCCacheEntry* bitmapCacheEntry = FindBitmapInCache(GetHDC(),
2128                 dstWidth, dstHeight);
2129
2130             buffer_bmap = (HBITMAP) bitmapCacheEntry->m_bitmap;
2131 #else // !wxUSE_DC_CACHEING
2132             // create a temp buffer bitmap and DCs to access it and the mask
2133             dc_mask = ::CreateCompatibleDC(hdcSrc);
2134             dc_buffer = ::CreateCompatibleDC(GetHdc());
2135             buffer_bmap = ::CreateCompatibleBitmap(GetHdc(), dstWidth, dstHeight);
2136 #endif // wxUSE_DC_CACHEING/!wxUSE_DC_CACHEING
2137             HGDIOBJ hOldMaskBitmap = ::SelectObject(dc_mask, (HBITMAP) mask->GetMaskBitmap());
2138             HGDIOBJ hOldBufferBitmap = ::SelectObject(dc_buffer, buffer_bmap);
2139
2140             // copy dest to buffer
2141             if ( !::BitBlt(dc_buffer, 0, 0, dstWidth, dstHeight,
2142                            GetHdc(), xdest, ydest, SRCCOPY) )
2143             {
2144                 wxLogLastError(wxT("BitBlt"));
2145             }
2146
2147             SET_STRETCH_BLT_MODE(GetHdc());
2148
2149             // copy src to buffer using selected raster op
2150             if ( !::StretchBlt(dc_buffer, 0, 0, dstWidth, dstHeight,
2151                                hdcSrc, xsrc, ysrc, srcWidth, srcHeight, dwRop) )
2152             {
2153                 wxLogLastError(wxT("StretchBlt"));
2154             }
2155
2156             // set masked area in buffer to BLACK
2157             {
2158                 wxTextColoursChanger textCol2(GetHdc(), *wxBLACK, *wxWHITE);
2159                 if ( !::StretchBlt(dc_buffer, 0, 0, dstWidth, dstHeight,
2160                                    dc_mask, xsrcMask, ysrcMask,
2161                                    srcWidth, srcHeight, SRCAND) )
2162                 {
2163                     wxLogLastError(wxT("StretchBlt"));
2164                 }
2165
2166                 // set unmasked area in dest to BLACK
2167                 ::SetBkColor(GetHdc(), RGB(0, 0, 0));
2168                 ::SetTextColor(GetHdc(), RGB(255, 255, 255));
2169                 if ( !::StretchBlt(GetHdc(), xdest, ydest, dstWidth, dstHeight,
2170                                    dc_mask, xsrcMask, ysrcMask,
2171                                    srcWidth, srcHeight, SRCAND) )
2172                 {
2173                     wxLogLastError(wxT("StretchBlt"));
2174                 }
2175             } // restore the original text and background colours
2176
2177             // OR buffer to dest
2178             success = ::BitBlt(GetHdc(), xdest, ydest, dstWidth, dstHeight,
2179                                dc_buffer, 0, 0, SRCPAINT) != 0;
2180             if ( !success )
2181             {
2182                 wxLogLastError(wxT("BitBlt"));
2183             }
2184
2185             // tidy up temporary DCs and bitmap
2186             ::SelectObject(dc_mask, hOldMaskBitmap);
2187             ::SelectObject(dc_buffer, hOldBufferBitmap);
2188
2189 #if !wxUSE_DC_CACHEING
2190             {
2191                 ::DeleteDC(dc_mask);
2192                 ::DeleteDC(dc_buffer);
2193                 ::DeleteObject(buffer_bmap);
2194             }
2195 #endif
2196         }
2197     }
2198     else // no mask, just BitBlt() it
2199     {
2200         // if we already have a DIB, draw it using StretchDIBits(), otherwise
2201         // use StretchBlt() if available and finally fall back to BitBlt()
2202
2203         // FIXME: use appropriate WinCE functions
2204 #ifndef __WXWINCE__
2205         const int caps = ::GetDeviceCaps(GetHdc(), RASTERCAPS);
2206         if ( bmpSrc.IsOk() && (caps & RC_STRETCHDIB) )
2207         {
2208             DIBSECTION ds;
2209             wxZeroMemory(ds);
2210
2211             if ( ::GetObject(GetHbitmapOf(bmpSrc),
2212                              sizeof(ds),
2213                              &ds) == sizeof(ds) )
2214             {
2215                 SET_STRETCH_BLT_MODE(GetHdc());
2216
2217                 // Figure out what co-ordinate system we're supposed to specify
2218                 // ysrc in.
2219                 const LONG hDIB = ds.dsBmih.biHeight;
2220                 if ( hDIB > 0 )
2221                 {
2222                     // reflect ysrc
2223                     ysrc = hDIB - (ysrc + srcHeight);
2224                 }
2225
2226                 if ( ::StretchDIBits(GetHdc(),
2227                                      xdest, ydest,
2228                                      dstWidth, dstHeight,
2229                                      xsrc, ysrc,
2230                                      srcWidth, srcHeight,
2231                                      ds.dsBm.bmBits,
2232                                      (LPBITMAPINFO)&ds.dsBmih,
2233                                      DIB_RGB_COLORS,
2234                                      dwRop
2235                                      ) == (int)GDI_ERROR )
2236                 {
2237                     // On Win9x this API fails most (all?) of the time, so
2238                     // logging it becomes quite distracting.  Since it falls
2239                     // back to the code below this is not really serious, so
2240                     // don't log it.
2241                     //wxLogLastError(wxT("StretchDIBits"));
2242                 }
2243                 else
2244                 {
2245                     success = true;
2246                 }
2247             }
2248         }
2249
2250         if ( !success && (caps & RC_STRETCHBLT) )
2251 #endif
2252         // __WXWINCE__
2253         {
2254             SET_STRETCH_BLT_MODE(GetHdc());
2255
2256             if ( !::StretchBlt
2257                     (
2258                         GetHdc(),
2259                         xdest, ydest, dstWidth, dstHeight,
2260                         hdcSrc,
2261                         xsrc, ysrc, srcWidth, srcHeight,
2262                         dwRop
2263                     ) )
2264             {
2265                 wxLogLastError(wxT("StretchBlt"));
2266             }
2267             else
2268             {
2269                 success = true;
2270             }
2271         }
2272
2273         if ( !success )
2274         {
2275             if ( !::BitBlt(GetHdc(), xdest, ydest, dstWidth, dstHeight,
2276                            hdcSrc, xsrc, ysrc, dwRop) )
2277             {
2278                 wxLogLastError(wxT("BitBlt"));
2279             }
2280             else
2281             {
2282                 success = true;
2283             }
2284         }
2285     }
2286
2287     return success;
2288 }
2289
2290 void wxMSWDCImpl::GetDeviceSize(int *width, int *height) const
2291 {
2292     WXMICROWIN_CHECK_HDC
2293
2294     if ( width )
2295         *width = ::GetDeviceCaps(GetHdc(), HORZRES);
2296     if ( height )
2297         *height = ::GetDeviceCaps(GetHdc(), VERTRES);
2298 }
2299
2300 void wxMSWDCImpl::DoGetSizeMM(int *w, int *h) const
2301 {
2302     WXMICROWIN_CHECK_HDC
2303
2304     // if we implement it in terms of DoGetSize() instead of directly using the
2305     // results returned by GetDeviceCaps(HORZ/VERTSIZE) as was done before, it
2306     // will also work for wxWindowDC and wxClientDC even though their size is
2307     // not the same as the total size of the screen
2308     int wPixels, hPixels;
2309     DoGetSize(&wPixels, &hPixels);
2310
2311     if ( w )
2312     {
2313         int wTotal = ::GetDeviceCaps(GetHdc(), HORZRES);
2314
2315         wxCHECK_RET( wTotal, wxT("0 width device?") );
2316
2317         *w = (wPixels * ::GetDeviceCaps(GetHdc(), HORZSIZE)) / wTotal;
2318     }
2319
2320     if ( h )
2321     {
2322         int hTotal = ::GetDeviceCaps(GetHdc(), VERTRES);
2323
2324         wxCHECK_RET( hTotal, wxT("0 height device?") );
2325
2326         *h = (hPixels * ::GetDeviceCaps(GetHdc(), VERTSIZE)) / hTotal;
2327     }
2328 }
2329
2330 wxSize wxMSWDCImpl::GetPPI() const
2331 {
2332     WXMICROWIN_CHECK_HDC_RET(wxSize(0,0))
2333
2334     int x = ::GetDeviceCaps(GetHdc(), LOGPIXELSX);
2335     int y = ::GetDeviceCaps(GetHdc(), LOGPIXELSY);
2336
2337     return wxSize(x, y);
2338 }
2339
2340 // ----------------------------------------------------------------------------
2341 // DC caching
2342 // ----------------------------------------------------------------------------
2343
2344 #if wxUSE_DC_CACHEING
2345
2346 /*
2347  * This implementation is a bit ugly and uses the old-fashioned wxList class, so I will
2348  * improve it in due course, either using arrays, or simply storing pointers to one
2349  * entry for the bitmap, and two for the DCs. -- JACS
2350  */
2351
2352 wxObjectList wxMSWDCImpl::sm_bitmapCache;
2353 wxObjectList wxMSWDCImpl::sm_dcCache;
2354
2355 wxDCCacheEntry::wxDCCacheEntry(WXHBITMAP hBitmap, int w, int h, int depth)
2356 {
2357     m_bitmap = hBitmap;
2358     m_dc = 0;
2359     m_width = w;
2360     m_height = h;
2361     m_depth = depth;
2362 }
2363
2364 wxDCCacheEntry::wxDCCacheEntry(WXHDC hDC, int depth)
2365 {
2366     m_bitmap = 0;
2367     m_dc = hDC;
2368     m_width = 0;
2369     m_height = 0;
2370     m_depth = depth;
2371 }
2372
2373 wxDCCacheEntry::~wxDCCacheEntry()
2374 {
2375     if (m_bitmap)
2376         ::DeleteObject((HBITMAP) m_bitmap);
2377     if (m_dc)
2378         ::DeleteDC((HDC) m_dc);
2379 }
2380
2381 wxDCCacheEntry* wxMSWDCImpl::FindBitmapInCache(WXHDC dc, int w, int h)
2382 {
2383     int depth = ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
2384     wxList::compatibility_iterator node = sm_bitmapCache.GetFirst();
2385     while (node)
2386     {
2387         wxDCCacheEntry* entry = (wxDCCacheEntry*) node->GetData();
2388
2389         if (entry->m_depth == depth)
2390         {
2391             if (entry->m_width < w || entry->m_height < h)
2392             {
2393                 ::DeleteObject((HBITMAP) entry->m_bitmap);
2394                 entry->m_bitmap = (WXHBITMAP) ::CreateCompatibleBitmap((HDC) dc, w, h);
2395                 if ( !entry->m_bitmap)
2396                 {
2397                     wxLogLastError(wxT("CreateCompatibleBitmap"));
2398                 }
2399                 entry->m_width = w; entry->m_height = h;
2400                 return entry;
2401             }
2402             return entry;
2403         }
2404
2405         node = node->GetNext();
2406     }
2407     WXHBITMAP hBitmap = (WXHBITMAP) ::CreateCompatibleBitmap((HDC) dc, w, h);
2408     if ( !hBitmap)
2409     {
2410         wxLogLastError(wxT("CreateCompatibleBitmap"));
2411     }
2412     wxDCCacheEntry* entry = new wxDCCacheEntry(hBitmap, w, h, depth);
2413     AddToBitmapCache(entry);
2414     return entry;
2415 }
2416
2417 wxDCCacheEntry* wxMSWDCImpl::FindDCInCache(wxDCCacheEntry* notThis, WXHDC dc)
2418 {
2419     int depth = ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
2420     wxList::compatibility_iterator node = sm_dcCache.GetFirst();
2421     while (node)
2422     {
2423         wxDCCacheEntry* entry = (wxDCCacheEntry*) node->GetData();
2424
2425         // Don't return the same one as we already have
2426         if (!notThis || (notThis != entry))
2427         {
2428             if (entry->m_depth == depth)
2429             {
2430                 return entry;
2431             }
2432         }
2433
2434         node = node->GetNext();
2435     }
2436     WXHDC hDC = (WXHDC) ::CreateCompatibleDC((HDC) dc);
2437     if ( !hDC)
2438     {
2439         wxLogLastError(wxT("CreateCompatibleDC"));
2440     }
2441     wxDCCacheEntry* entry = new wxDCCacheEntry(hDC, depth);
2442     AddToDCCache(entry);
2443     return entry;
2444 }
2445
2446 void wxMSWDCImpl::AddToBitmapCache(wxDCCacheEntry* entry)
2447 {
2448     sm_bitmapCache.Append(entry);
2449 }
2450
2451 void wxMSWDCImpl::AddToDCCache(wxDCCacheEntry* entry)
2452 {
2453     sm_dcCache.Append(entry);
2454 }
2455
2456 void wxMSWDCImpl::ClearCache()
2457 {
2458     WX_CLEAR_LIST(wxList, sm_dcCache);
2459     WX_CLEAR_LIST(wxList, sm_bitmapCache);
2460 }
2461
2462 // Clean up cache at app exit
2463 class wxDCModule : public wxModule
2464 {
2465 public:
2466     virtual bool OnInit() { return true; }
2467     virtual void OnExit() { wxMSWDCImpl::ClearCache(); }
2468
2469 private:
2470     DECLARE_DYNAMIC_CLASS(wxDCModule)
2471 };
2472
2473 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
2474
2475 #endif // wxUSE_DC_CACHEING
2476
2477 // ----------------------------------------------------------------------------
2478 // alpha channel support
2479 // ----------------------------------------------------------------------------
2480
2481 static bool AlphaBlt(HDC hdcDst,
2482                      int x, int y, int dstWidth, int dstHeight,
2483                      int srcX, int srcY,
2484                      int srcWidth, int srcHeight,
2485                      HDC hdcSrc,
2486                      const wxBitmap& bmp)
2487 {
2488     wxASSERT_MSG( bmp.IsOk() && bmp.HasAlpha(), wxT("AlphaBlt(): invalid bitmap") );
2489     wxASSERT_MSG( hdcDst && hdcSrc, wxT("AlphaBlt(): invalid HDC") );
2490
2491     // do we have AlphaBlend() and company in the headers?
2492 #if defined(AC_SRC_OVER) && wxUSE_DYNLIB_CLASS
2493     // yes, now try to see if we have it during run-time
2494     typedef BOOL (WINAPI *AlphaBlend_t)(HDC,int,int,int,int,
2495                                         HDC,int,int,int,int,
2496                                         BLENDFUNCTION);
2497
2498     static AlphaBlend_t
2499         pfnAlphaBlend = (AlphaBlend_t)wxMSIMG32DLL.GetSymbol(wxT("AlphaBlend"));
2500     if ( pfnAlphaBlend )
2501     {
2502         BLENDFUNCTION bf;
2503         bf.BlendOp = AC_SRC_OVER;
2504         bf.BlendFlags = 0;
2505         bf.SourceConstantAlpha = 0xff;
2506         bf.AlphaFormat = AC_SRC_ALPHA;
2507
2508         if ( pfnAlphaBlend(hdcDst, x, y, dstWidth, dstHeight,
2509                            hdcSrc, srcX, srcY, srcWidth, srcHeight,
2510                            bf) )
2511         {
2512             // skip wxAlphaBlend() call below
2513             return true;
2514         }
2515
2516         wxLogLastError(wxT("AlphaBlend"));
2517     }
2518 #else
2519     wxUnusedVar(hdcSrc);
2520 #endif // defined(AC_SRC_OVER)
2521
2522     // AlphaBlend() unavailable of failed: use our own (probably much slower)
2523     // implementation
2524 #ifdef wxHAS_RAW_BITMAP
2525     wxAlphaBlend(hdcDst, x, y, dstWidth, dstHeight, srcX, srcY, srcWidth, srcHeight, bmp);
2526
2527     return true;
2528 #else // !wxHAS_RAW_BITMAP
2529     // no wxAlphaBlend() neither, fall back to using simple BitBlt() (we lose
2530     // alpha but at least something will be shown like this)
2531     wxUnusedVar(bmp);
2532     return false;
2533 #endif // wxHAS_RAW_BITMAP/!wxHAS_RAW_BITMAP
2534 }
2535
2536
2537 // wxAlphaBlend: our fallback if ::AlphaBlend() is unavailable
2538 #ifdef wxHAS_RAW_BITMAP
2539
2540 static void
2541 wxAlphaBlend(HDC hdcDst, int xDst, int yDst,
2542              int dstWidth, int dstHeight,
2543              int srcX, int srcY,
2544              int srcWidth, int srcHeight,
2545              const wxBitmap& bmpSrc)
2546 {
2547     // get the destination DC pixels
2548     wxBitmap bmpDst(dstWidth, dstHeight, 32 /* force creating RGBA DIB */);
2549     MemoryHDC hdcMem;
2550     SelectInHDC select(hdcMem, GetHbitmapOf(bmpDst));
2551
2552     if ( !::BitBlt(hdcMem, 0, 0, dstWidth, dstHeight, hdcDst, xDst, yDst, SRCCOPY) )
2553     {
2554         wxLogLastError(wxT("BitBlt"));
2555     }
2556
2557     // combine them with the source bitmap using alpha
2558     wxAlphaPixelData dataDst(bmpDst),
2559                      dataSrc((wxBitmap &)bmpSrc);
2560
2561     wxCHECK_RET( dataDst && dataSrc,
2562                     wxT("failed to get raw data in wxAlphaBlend") );
2563
2564     wxAlphaPixelData::Iterator pDst(dataDst),
2565                                pSrc(dataSrc);
2566
2567
2568     for ( int y = 0; y < dstHeight; y++ )
2569     {
2570         wxAlphaPixelData::Iterator pDstRowStart = pDst;
2571
2572         for ( int x = 0; x < dstWidth; x++ )
2573         {
2574             // source is point sampled, Alpha StretchBlit is ugly on Win95
2575             // (but does not impact performance)
2576             pSrc.MoveTo(dataSrc, srcX + (srcWidth*x/dstWidth), srcY + (srcHeight*y/dstHeight));
2577
2578             // note that source bitmap uses premultiplied alpha (as required by
2579             // the real AlphaBlend)
2580             const unsigned beta = 255 - pSrc.Alpha();
2581
2582             pDst.Red() = pSrc.Red() + (beta * pDst.Red() + 127) / 255;
2583             pDst.Blue() = pSrc.Blue() + (beta * pDst.Blue() + 127) / 255;
2584             pDst.Green() = pSrc.Green() + (beta * pDst.Green() + 127) / 255;
2585
2586             ++pDst;
2587         }
2588
2589         pDst = pDstRowStart;
2590         pDst.OffsetY(dataDst, 1);
2591     }
2592
2593     // and finally blit them back to the destination DC
2594     if ( !::BitBlt(hdcDst, xDst, yDst, dstWidth, dstHeight, hdcMem, 0, 0, SRCCOPY) )
2595     {
2596         wxLogLastError(wxT("BitBlt"));
2597     }
2598 }
2599
2600 #endif // wxHAS_RAW_BITMAP
2601
2602 void wxMSWDCImpl::DoGradientFillLinear (const wxRect& rect,
2603                                  const wxColour& initialColour,
2604                                  const wxColour& destColour,
2605                                  wxDirection nDirection)
2606 {
2607     // use native function if we have compile-time support it and can load it
2608     // during run-time (linking to it statically would make the program
2609     // unusable on earlier Windows versions)
2610 #if defined(GRADIENT_FILL_RECT_H) && wxUSE_DYNLIB_CLASS
2611     typedef BOOL
2612         (WINAPI *GradientFill_t)(HDC, PTRIVERTEX, ULONG, PVOID, ULONG, ULONG);
2613     static GradientFill_t pfnGradientFill =
2614         (GradientFill_t)wxMSIMG32DLL.GetSymbol(wxT("GradientFill"));
2615
2616     if ( pfnGradientFill )
2617     {
2618         GRADIENT_RECT grect;
2619         grect.UpperLeft = 0;
2620         grect.LowerRight = 1;
2621
2622         // invert colours direction if not filling from left-to-right or
2623         // top-to-bottom
2624         int firstVertex = nDirection == wxNORTH || nDirection == wxWEST ? 1 : 0;
2625
2626         // one vertex for upper left and one for upper-right
2627         TRIVERTEX vertices[2];
2628
2629         vertices[0].x = rect.GetLeft();
2630         vertices[0].y = rect.GetTop();
2631         vertices[1].x = rect.GetRight()+1;
2632         vertices[1].y = rect.GetBottom()+1;
2633
2634         vertices[firstVertex].Red = (COLOR16)(initialColour.Red() << 8);
2635         vertices[firstVertex].Green = (COLOR16)(initialColour.Green() << 8);
2636         vertices[firstVertex].Blue = (COLOR16)(initialColour.Blue() << 8);
2637         vertices[firstVertex].Alpha = 0;
2638         vertices[1 - firstVertex].Red = (COLOR16)(destColour.Red() << 8);
2639         vertices[1 - firstVertex].Green = (COLOR16)(destColour.Green() << 8);
2640         vertices[1 - firstVertex].Blue = (COLOR16)(destColour.Blue() << 8);
2641         vertices[1 - firstVertex].Alpha = 0;
2642
2643         if ( (*pfnGradientFill)
2644              (
2645                 GetHdc(),
2646                 vertices,
2647                 WXSIZEOF(vertices),
2648                 &grect,
2649                 1,
2650                 nDirection == wxWEST || nDirection == wxEAST
2651                     ? GRADIENT_FILL_RECT_H
2652                     : GRADIENT_FILL_RECT_V
2653              ) )
2654         {
2655             // skip call of the base class version below
2656             return;
2657         }
2658
2659         wxLogLastError(wxT("GradientFill"));
2660     }
2661 #endif // wxUSE_DYNLIB_CLASS
2662
2663     wxDCImpl::DoGradientFillLinear(rect, initialColour, destColour, nDirection);
2664 }
2665
2666 #if wxUSE_DYNLIB_CLASS
2667
2668 static DWORD wxGetDCLayout(HDC hdc)
2669 {
2670     typedef DWORD (WINAPI *GetLayout_t)(HDC);
2671     static GetLayout_t
2672         wxDL_INIT_FUNC(s_pfn, GetLayout, wxDynamicLibrary(wxT("gdi32.dll")));
2673
2674     return s_pfnGetLayout ? s_pfnGetLayout(hdc) : (DWORD)-1;
2675 }
2676
2677 wxLayoutDirection wxMSWDCImpl::GetLayoutDirection() const
2678 {
2679     DWORD layout = wxGetDCLayout(GetHdc());
2680
2681     if ( layout == (DWORD)-1 )
2682         return wxLayout_Default;
2683
2684     return layout & LAYOUT_RTL ? wxLayout_RightToLeft : wxLayout_LeftToRight;
2685 }
2686
2687 void wxMSWDCImpl::SetLayoutDirection(wxLayoutDirection dir)
2688 {
2689     typedef DWORD (WINAPI *SetLayout_t)(HDC, DWORD);
2690     static SetLayout_t
2691         wxDL_INIT_FUNC(s_pfn, SetLayout, wxDynamicLibrary(wxT("gdi32.dll")));
2692     if ( !s_pfnSetLayout )
2693         return;
2694
2695     if ( dir == wxLayout_Default )
2696     {
2697         dir = wxTheApp->GetLayoutDirection();
2698         if ( dir == wxLayout_Default )
2699             return;
2700     }
2701
2702     DWORD layout = wxGetDCLayout(GetHdc());
2703     if ( dir == wxLayout_RightToLeft )
2704         layout |= LAYOUT_RTL;
2705     else
2706         layout &= ~LAYOUT_RTL;
2707
2708     s_pfnSetLayout(GetHdc(), layout);
2709 }
2710
2711 #else // !wxUSE_DYNLIB_CLASS
2712
2713 // we can't provide RTL support without dynamic loading, so stub it out
2714 wxLayoutDirection wxMSWDCImpl::GetLayoutDirection() const
2715 {
2716     return wxLayout_Default;
2717 }
2718
2719 void wxMSWDCImpl::SetLayoutDirection(wxLayoutDirection WXUNUSED(dir))
2720 {
2721 }
2722
2723 #endif // wxUSE_DYNLIB_CLASS/!wxUSE_DYNLIB_CLASS