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