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