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