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 #endif
  39
  40 #include "wx/sysopt.h"
  41 #include "wx/dcprint.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 = (WXHPEN)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 = (WXHPEN)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     // the result computed by GetTextExtentPoint32() may be too small as it
1749     // accounts for under/overhang of the first/last character while we want
1750     // just the bounding rect for this string so adjust the width as needed
1751     if ( len > 0 )
1752     {
1753         ABC width;
1754         const wxChar chFirst = *string.begin();
1755         if ( ::GetCharABCWidths(GetHdc(), chFirst, chFirst, &width) )
1756         {
1757             if ( width.abcA < 0 )
1758                 sizeRect.cx -= width.abcA;
1759
1760             if ( len > 1 )
1761             {
1762                 const wxChar chLast = *string.rbegin();
1763                 ::GetCharABCWidths(GetHdc(), chLast, chLast, &width);
1764             }
1765             //else: we already have the width of the last character
1766
1767             if ( width.abcC < 0 )
1768                 sizeRect.cx -= width.abcC;
1769         }
1770         //else: GetCharABCWidths() failed, not a TrueType font?
1771     }
1772
1773     TEXTMETRIC tm;
1774     ::GetTextMetrics(GetHdc(), &tm);
1775
1776     if (x)
1777         *x = sizeRect.cx;
1778     if (y)
1779         *y = sizeRect.cy;
1780     if (descent)
1781         *descent = tm.tmDescent;
1782     if (externalLeading)
1783         *externalLeading = tm.tmExternalLeading;
1784
1785     if ( hfontOld )
1786     {
1787         ::SelectObject(GetHdc(), hfontOld);
1788     }
1789 }
1790
1791
1792 // Each element of the array will be the width of the string up to and
1793 // including the coresoponding character in text.
1794
1795 bool wxDC::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
1796 {
1797     static int maxLenText = -1;
1798     static int maxWidth = -1;
1799     int fit = 0;
1800     SIZE sz = {0,0};
1801     int stlen = text.length();
1802
1803     if (maxLenText == -1)
1804     {
1805         // Win9x and WinNT+ have different limits
1806         int version = wxGetOsVersion();
1807         maxLenText = version == wxWINDOWS_NT ? 65535 : 8192;
1808         maxWidth =   version == wxWINDOWS_NT ? INT_MAX : 32767;
1809     }
1810
1811     widths.Empty();
1812     widths.Add(0, stlen);  // fill the array with zeros
1813     if (stlen == 0)
1814         return true;
1815
1816     if (!::GetTextExtentExPoint(GetHdc(),
1817                                 text.c_str(),           // string to check
1818                                 wxMin(stlen, maxLenText),
1819                                 maxWidth,
1820                                 &fit,                   // [out] count of chars
1821                                                         // that will fit
1822                                 &widths[0],             // array to fill
1823                                 &sz))
1824     {
1825         // API failed
1826         wxLogLastError(wxT("GetTextExtentExPoint"));
1827         return false;
1828     }
1829
1830     return true;
1831 }
1832
1833
1834
1835
1836 void wxDC::SetMapMode(int mode)
1837 {
1838     WXMICROWIN_CHECK_HDC
1839
1840     m_mappingMode = mode;
1841
1842     if ( mode == wxMM_TEXT )
1843     {
1844         m_logicalScaleX =
1845         m_logicalScaleY = 1.0;
1846     }
1847     else // need to do some calculations
1848     {
1849         int pixel_width = ::GetDeviceCaps(GetHdc(), HORZRES),
1850             pixel_height = ::GetDeviceCaps(GetHdc(), VERTRES),
1851             mm_width = ::GetDeviceCaps(GetHdc(), HORZSIZE),
1852             mm_height = ::GetDeviceCaps(GetHdc(), VERTSIZE);
1853
1854         if ( (mm_width == 0) || (mm_height == 0) )
1855         {
1856             // we can't calculate mm2pixels[XY] then!
1857             return;
1858         }
1859
1860         double mm2pixelsX = (double)pixel_width / mm_width,
1861                mm2pixelsY = (double)pixel_height / mm_height;
1862
1863         switch (mode)
1864         {
1865             case wxMM_TWIPS:
1866                 m_logicalScaleX = twips2mm * mm2pixelsX;
1867                 m_logicalScaleY = twips2mm * mm2pixelsY;
1868                 break;
1869
1870             case wxMM_POINTS:
1871                 m_logicalScaleX = pt2mm * mm2pixelsX;
1872                 m_logicalScaleY = pt2mm * mm2pixelsY;
1873                 break;
1874
1875             case wxMM_METRIC:
1876                 m_logicalScaleX = mm2pixelsX;
1877                 m_logicalScaleY = mm2pixelsY;
1878                 break;
1879
1880             case wxMM_LOMETRIC:
1881                 m_logicalScaleX = mm2pixelsX / 10.0;
1882                 m_logicalScaleY = mm2pixelsY / 10.0;
1883                 break;
1884
1885             default:
1886                 wxFAIL_MSG( _T("unknown mapping mode in SetMapMode") );
1887         }
1888     }
1889
1890     // VZ: it seems very wasteful to always use MM_ANISOTROPIC when in 99% of
1891     //     cases we could do with MM_TEXT and in the remaining 0.9% with
1892     //     MM_ISOTROPIC (TODO!)
1893 #ifndef __WXWINCE__
1894     ::SetMapMode(GetHdc(), MM_ANISOTROPIC);
1895
1896     int width = DeviceToLogicalXRel(VIEWPORT_EXTENT)*m_signX,
1897         height = DeviceToLogicalYRel(VIEWPORT_EXTENT)*m_signY;
1898
1899     ::SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);
1900     ::SetWindowExtEx(GetHdc(), width, height, NULL);
1901
1902     ::SetViewportOrgEx(GetHdc(), m_deviceOriginX, m_deviceOriginY, NULL);
1903     ::SetWindowOrgEx(GetHdc(), m_logicalOriginX, m_logicalOriginY, NULL);
1904 #endif
1905 }
1906
1907 void wxDC::SetUserScale(double x, double y)
1908 {
1909     WXMICROWIN_CHECK_HDC
1910
1911     if ( x == m_userScaleX && y == m_userScaleY )
1912         return;
1913
1914     m_userScaleX = x;
1915     m_userScaleY = y;
1916
1917     this->SetMapMode(m_mappingMode);
1918 }
1919
1920 void wxDC::SetAxisOrientation(bool WXUNUSED_IN_WINCE(xLeftRight),
1921                               bool WXUNUSED_IN_WINCE(yBottomUp))
1922 {
1923     WXMICROWIN_CHECK_HDC
1924
1925 #ifndef __WXWINCE__
1926     int signX = xLeftRight ? 1 : -1,
1927         signY = yBottomUp ? -1 : 1;
1928
1929     if ( signX != m_signX || signY != m_signY )
1930     {
1931         m_signX = signX;
1932         m_signY = signY;
1933
1934         SetMapMode(m_mappingMode);
1935     }
1936 #endif
1937 }
1938
1939 void wxDC::SetSystemScale(double x, double y)
1940 {
1941     WXMICROWIN_CHECK_HDC
1942
1943     if ( x == m_scaleX && y == m_scaleY )
1944         return;
1945
1946     m_scaleX = x;
1947     m_scaleY = y;
1948
1949 #ifndef __WXWINCE__
1950     SetMapMode(m_mappingMode);
1951 #endif
1952 }
1953
1954 void wxDC::SetLogicalOrigin(wxCoord x, wxCoord y)
1955 {
1956     WXMICROWIN_CHECK_HDC
1957
1958     if ( x == m_logicalOriginX && y == m_logicalOriginY )
1959         return;
1960
1961     m_logicalOriginX = x;
1962     m_logicalOriginY = 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     m_deviceOriginX = x;
1977     m_deviceOriginY = y;
1978
1979     ::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
1980 }
1981
1982 // ---------------------------------------------------------------------------
1983 // coordinates transformations
1984 // ---------------------------------------------------------------------------
1985
1986 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
1987 {
1988     return DeviceToLogicalXRel(x - m_deviceOriginX)*m_signX + m_logicalOriginX;
1989 }
1990
1991 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
1992 {
1993     // axis orientation is not taken into account for conversion of a distance
1994     return (wxCoord)(x / (m_logicalScaleX*m_userScaleX*m_scaleX));
1995 }
1996
1997 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
1998 {
1999     return DeviceToLogicalYRel(y - m_deviceOriginY)*m_signY + m_logicalOriginY;
2000 }
2001
2002 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
2003 {
2004     // axis orientation is not taken into account for conversion of a distance
2005     return (wxCoord)( y / (m_logicalScaleY*m_userScaleY*m_scaleY));
2006 }
2007
2008 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
2009 {
2010     return LogicalToDeviceXRel(x - m_logicalOriginX)*m_signX + m_deviceOriginX;
2011 }
2012
2013 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
2014 {
2015     // axis orientation is not taken into account for conversion of a distance
2016     return (wxCoord) (x*m_logicalScaleX*m_userScaleX*m_scaleX);
2017 }
2018
2019 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
2020 {
2021     return LogicalToDeviceYRel(y - m_logicalOriginY)*m_signY + m_deviceOriginY;
2022 }
2023
2024 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
2025 {
2026     // axis orientation is not taken into account for conversion of a distance
2027     return (wxCoord) (y*m_logicalScaleY*m_userScaleY*m_scaleY);
2028 }
2029
2030 // ---------------------------------------------------------------------------
2031 // bit blit
2032 // ---------------------------------------------------------------------------
2033
2034 bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
2035                   wxCoord width, wxCoord height,
2036                   wxDC *source, wxCoord xsrc, wxCoord ysrc,
2037                   int rop, bool useMask,
2038                   wxCoord xsrcMask, wxCoord ysrcMask)
2039 {
2040     wxCHECK_MSG( source, false, _T("wxDC::Blit(): NULL wxDC pointer") );
2041
2042     WXMICROWIN_CHECK_HDC_RET(false)
2043
2044     // if either the source or destination has alpha channel, we must use
2045     // AlphaBlt() as other function don't handle it correctly
2046     const wxBitmap& bmpSrc = source->m_selectedBitmap;
2047     if ( bmpSrc.Ok() && (bmpSrc.HasAlpha() ||
2048             (m_selectedBitmap.Ok() && m_selectedBitmap.HasAlpha())) )
2049     {
2050         if ( AlphaBlt(GetHdc(), xdest, ydest, width, height,
2051                       xsrc, ysrc, GetHdcOf(*source), bmpSrc) )
2052             return true;
2053     }
2054
2055     wxMask *mask = NULL;
2056     if ( useMask )
2057     {
2058         mask = bmpSrc.GetMask();
2059
2060         if ( !(bmpSrc.Ok() && mask && mask->GetMaskBitmap()) )
2061         {
2062             // don't give assert here because this would break existing
2063             // programs - just silently ignore useMask parameter
2064             useMask = false;
2065         }
2066     }
2067
2068     if (xsrcMask == -1 && ysrcMask == -1)
2069     {
2070         xsrcMask = xsrc; ysrcMask = ysrc;
2071     }
2072
2073     COLORREF old_textground = ::GetTextColor(GetHdc());
2074     COLORREF old_background = ::GetBkColor(GetHdc());
2075     if (m_textForegroundColour.Ok())
2076     {
2077         ::SetTextColor(GetHdc(), m_textForegroundColour.GetPixel() );
2078     }
2079     if (m_textBackgroundColour.Ok())
2080     {
2081         ::SetBkColor(GetHdc(), m_textBackgroundColour.GetPixel() );
2082     }
2083
2084     DWORD dwRop;
2085     switch (rop)
2086     {
2087         case wxXOR:          dwRop = SRCINVERT;        break;
2088         case wxINVERT:       dwRop = DSTINVERT;        break;
2089         case wxOR_REVERSE:   dwRop = 0x00DD0228;       break;
2090         case wxAND_REVERSE:  dwRop = SRCERASE;         break;
2091         case wxCLEAR:        dwRop = BLACKNESS;        break;
2092         case wxSET:          dwRop = WHITENESS;        break;
2093         case wxOR_INVERT:    dwRop = MERGEPAINT;       break;
2094         case wxAND:          dwRop = SRCAND;           break;
2095         case wxOR:           dwRop = SRCPAINT;         break;
2096         case wxEQUIV:        dwRop = 0x00990066;       break;
2097         case wxNAND:         dwRop = 0x007700E6;       break;
2098         case wxAND_INVERT:   dwRop = 0x00220326;       break;
2099         case wxCOPY:         dwRop = SRCCOPY;          break;
2100         case wxNO_OP:        dwRop = DSTCOPY;          break;
2101         case wxSRC_INVERT:   dwRop = NOTSRCCOPY;       break;
2102         case wxNOR:          dwRop = NOTSRCCOPY;       break;
2103         default:
2104            wxFAIL_MSG( wxT("unsupported logical function") );
2105            return false;
2106     }
2107
2108     bool success = false;
2109
2110     if (useMask)
2111     {
2112 #ifdef __WIN32__
2113         // we want the part of the image corresponding to the mask to be
2114         // transparent, so use "DSTCOPY" ROP for the mask points (the usual
2115         // meaning of fg and bg is inverted which corresponds to wxWin notion
2116         // of the mask which is also contrary to the Windows one)
2117
2118         // On some systems, MaskBlt succeeds yet is much much slower
2119         // than the wxWidgets fall-back implementation. So we need
2120         // to be able to switch this on and off at runtime.
2121 #if wxUSE_SYSTEM_OPTIONS
2122         if (wxSystemOptions::GetOptionInt(wxT("no-maskblt")) == 0)
2123 #endif
2124         {
2125            success = ::MaskBlt
2126                        (
2127                             GetHdc(),
2128                             xdest, ydest, width, height,
2129                             GetHdcOf(*source),
2130                             xsrc, ysrc,
2131                             (HBITMAP)mask->GetMaskBitmap(),
2132                             xsrcMask, ysrcMask,
2133                             MAKEROP4(dwRop, DSTCOPY)
2134                         ) != 0;
2135         }
2136
2137         if ( !success )
2138 #endif // Win32
2139         {
2140             // Blit bitmap with mask
2141             HDC dc_mask ;
2142             HDC  dc_buffer ;
2143             HBITMAP buffer_bmap ;
2144
2145 #if wxUSE_DC_CACHEING
2146             // create a temp buffer bitmap and DCs to access it and the mask
2147             wxDCCacheEntry* dcCacheEntry1 = FindDCInCache(NULL, source->GetHDC());
2148             dc_mask = (HDC) dcCacheEntry1->m_dc;
2149
2150             wxDCCacheEntry* dcCacheEntry2 = FindDCInCache(dcCacheEntry1, GetHDC());
2151             dc_buffer = (HDC) dcCacheEntry2->m_dc;
2152
2153             wxDCCacheEntry* bitmapCacheEntry = FindBitmapInCache(GetHDC(),
2154                 width, height);
2155
2156             buffer_bmap = (HBITMAP) bitmapCacheEntry->m_bitmap;
2157 #else // !wxUSE_DC_CACHEING
2158             // create a temp buffer bitmap and DCs to access it and the mask
2159             dc_mask = ::CreateCompatibleDC(GetHdcOf(*source));
2160             dc_buffer = ::CreateCompatibleDC(GetHdc());
2161             buffer_bmap = ::CreateCompatibleBitmap(GetHdc(), width, height);
2162 #endif // wxUSE_DC_CACHEING/!wxUSE_DC_CACHEING
2163             HGDIOBJ hOldMaskBitmap = ::SelectObject(dc_mask, (HBITMAP) mask->GetMaskBitmap());
2164             HGDIOBJ hOldBufferBitmap = ::SelectObject(dc_buffer, buffer_bmap);
2165
2166             // copy dest to buffer
2167             if ( !::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
2168                            GetHdc(), xdest, ydest, SRCCOPY) )
2169             {
2170                 wxLogLastError(wxT("BitBlt"));
2171             }
2172
2173             // copy src to buffer using selected raster op
2174             if ( !::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
2175                            GetHdcOf(*source), xsrc, ysrc, dwRop) )
2176             {
2177                 wxLogLastError(wxT("BitBlt"));
2178             }
2179
2180             // set masked area in buffer to BLACK (pixel value 0)
2181             COLORREF prevBkCol = ::SetBkColor(GetHdc(), RGB(255, 255, 255));
2182             COLORREF prevCol = ::SetTextColor(GetHdc(), RGB(0, 0, 0));
2183             if ( !::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
2184                            dc_mask, xsrcMask, ysrcMask, SRCAND) )
2185             {
2186                 wxLogLastError(wxT("BitBlt"));
2187             }
2188
2189             // set unmasked area in dest to BLACK
2190             ::SetBkColor(GetHdc(), RGB(0, 0, 0));
2191             ::SetTextColor(GetHdc(), RGB(255, 255, 255));
2192             if ( !::BitBlt(GetHdc(), xdest, ydest, (int)width, (int)height,
2193                            dc_mask, xsrcMask, ysrcMask, SRCAND) )
2194             {
2195                 wxLogLastError(wxT("BitBlt"));
2196             }
2197             ::SetBkColor(GetHdc(), prevBkCol);   // restore colours to original values
2198             ::SetTextColor(GetHdc(), prevCol);
2199
2200             // OR buffer to dest
2201             success = ::BitBlt(GetHdc(), xdest, ydest,
2202                                (int)width, (int)height,
2203                                dc_buffer, 0, 0, SRCPAINT) != 0;
2204             if ( !success )
2205             {
2206                 wxLogLastError(wxT("BitBlt"));
2207             }
2208
2209             // tidy up temporary DCs and bitmap
2210             ::SelectObject(dc_mask, hOldMaskBitmap);
2211             ::SelectObject(dc_buffer, hOldBufferBitmap);
2212
2213 #if !wxUSE_DC_CACHEING
2214             {
2215                 ::DeleteDC(dc_mask);
2216                 ::DeleteDC(dc_buffer);
2217                 ::DeleteObject(buffer_bmap);
2218             }
2219 #endif
2220         }
2221     }
2222     else // no mask, just BitBlt() it
2223     {
2224         // if we already have a DIB, draw it using StretchDIBits(), otherwise
2225         // use StretchBlt() if available and finally fall back to BitBlt()
2226
2227         // FIXME: use appropriate WinCE functions
2228 #ifndef __WXWINCE__
2229         const int caps = ::GetDeviceCaps(GetHdc(), RASTERCAPS);
2230         if ( bmpSrc.Ok() && (caps & RC_STRETCHDIB) )
2231         {
2232             DIBSECTION ds;
2233             wxZeroMemory(ds);
2234
2235             if ( ::GetObject(GetHbitmapOf(bmpSrc),
2236                              sizeof(ds),
2237                              &ds) == sizeof(ds) )
2238             {
2239                 StretchBltModeChanger changeMode(GetHdc(), COLORONCOLOR);
2240
2241                 // Figure out what co-ordinate system we're supposed to specify
2242                 // ysrc in.
2243                 const LONG hDIB = ds.dsBmih.biHeight;
2244                 if ( hDIB > 0 )
2245                 {
2246                     // reflect ysrc
2247                     ysrc = hDIB - (ysrc + height);
2248                 }
2249
2250                 if ( ::StretchDIBits(GetHdc(),
2251                                      xdest, ydest,
2252                                      width, height,
2253                                      xsrc, ysrc,
2254                                      width, height,
2255                                      ds.dsBm.bmBits,
2256                                      (LPBITMAPINFO)&ds.dsBmih,
2257                                      DIB_RGB_COLORS,
2258                                      SRCCOPY
2259                                      ) == (int)GDI_ERROR )
2260                 {
2261                     // On Win9x this API fails most (all?) of the time, so
2262                     // logging it becomes quite distracting.  Since it falls
2263                     // back to the code below this is not really serious, so
2264                     // don't log it.
2265                     //wxLogLastError(wxT("StretchDIBits"));
2266                 }
2267                 else
2268                 {
2269                     success = true;
2270                 }
2271             }
2272         }
2273
2274         if ( !success && (caps & RC_STRETCHBLT) )
2275 #endif
2276         // __WXWINCE__
2277         {
2278 #ifndef __WXWINCE__
2279             StretchBltModeChanger changeMode(GetHdc(), COLORONCOLOR);
2280 #endif
2281
2282             if ( !::StretchBlt
2283                     (
2284                         GetHdc(),
2285                         xdest, ydest, width, height,
2286                         GetHdcOf(*source),
2287                         xsrc, ysrc, width, height,
2288                         dwRop
2289                     ) )
2290             {
2291                 wxLogLastError(_T("StretchBlt"));
2292             }
2293             else
2294             {
2295                 success = true;
2296             }
2297         }
2298
2299         if ( !success )
2300         {
2301             if ( !::BitBlt
2302                     (
2303                         GetHdc(),
2304                         xdest, ydest,
2305                         (int)width, (int)height,
2306                         GetHdcOf(*source),
2307                         xsrc, ysrc,
2308                         dwRop
2309                     ) )
2310             {
2311                 wxLogLastError(_T("BitBlt"));
2312             }
2313             else
2314             {
2315                 success = true;
2316             }
2317         }
2318     }
2319
2320     ::SetTextColor(GetHdc(), old_textground);
2321     ::SetBkColor(GetHdc(), old_background);
2322
2323     return success;
2324 }
2325
2326 void wxDC::GetDeviceSize(int *width, int *height) const
2327 {
2328     WXMICROWIN_CHECK_HDC
2329
2330     if ( width )
2331         *width = ::GetDeviceCaps(GetHdc(), HORZRES);
2332     if ( height )
2333         *height = ::GetDeviceCaps(GetHdc(), VERTRES);
2334 }
2335
2336 void wxDC::DoGetSizeMM(int *w, int *h) const
2337 {
2338     WXMICROWIN_CHECK_HDC
2339
2340     // if we implement it in terms of DoGetSize() instead of directly using the
2341     // results returned by GetDeviceCaps(HORZ/VERTSIZE) as was done before, it
2342     // will also work for wxWindowDC and wxClientDC even though their size is
2343     // not the same as the total size of the screen
2344     int wPixels, hPixels;
2345     DoGetSize(&wPixels, &hPixels);
2346
2347     if ( w )
2348     {
2349         int wTotal = ::GetDeviceCaps(GetHdc(), HORZRES);
2350
2351         wxCHECK_RET( wTotal, _T("0 width device?") );
2352
2353         *w = (wPixels * ::GetDeviceCaps(GetHdc(), HORZSIZE)) / wTotal;
2354     }
2355
2356     if ( h )
2357     {
2358         int hTotal = ::GetDeviceCaps(GetHdc(), VERTRES);
2359
2360         wxCHECK_RET( hTotal, _T("0 height device?") );
2361
2362         *h = (hPixels * ::GetDeviceCaps(GetHdc(), VERTSIZE)) / hTotal;
2363     }
2364 }
2365
2366 wxSize wxDC::GetPPI() const
2367 {
2368     WXMICROWIN_CHECK_HDC_RET(wxSize(0,0))
2369
2370     int x = ::GetDeviceCaps(GetHdc(), LOGPIXELSX);
2371     int y = ::GetDeviceCaps(GetHdc(), LOGPIXELSY);
2372
2373     return wxSize(x, y);
2374 }
2375
2376 // For use by wxWidgets only, unless custom units are required.
2377 void wxDC::SetLogicalScale(double x, double y)
2378 {
2379     WXMICROWIN_CHECK_HDC
2380
2381     m_logicalScaleX = x;
2382     m_logicalScaleY = y;
2383 }
2384
2385 // ----------------------------------------------------------------------------
2386 // DC caching
2387 // ----------------------------------------------------------------------------
2388
2389 #if wxUSE_DC_CACHEING
2390
2391 /*
2392  * This implementation is a bit ugly and uses the old-fashioned wxList class, so I will
2393  * improve it in due course, either using arrays, or simply storing pointers to one
2394  * entry for the bitmap, and two for the DCs. -- JACS
2395  */
2396
2397 wxList wxDC::sm_bitmapCache;
2398 wxList wxDC::sm_dcCache;
2399
2400 wxDCCacheEntry::wxDCCacheEntry(WXHBITMAP hBitmap, int w, int h, int depth)
2401 {
2402     m_bitmap = hBitmap;
2403     m_dc = 0;
2404     m_width = w;
2405     m_height = h;
2406     m_depth = depth;
2407 }
2408
2409 wxDCCacheEntry::wxDCCacheEntry(WXHDC hDC, int depth)
2410 {
2411     m_bitmap = 0;
2412     m_dc = hDC;
2413     m_width = 0;
2414     m_height = 0;
2415     m_depth = depth;
2416 }
2417
2418 wxDCCacheEntry::~wxDCCacheEntry()
2419 {
2420     if (m_bitmap)
2421         ::DeleteObject((HBITMAP) m_bitmap);
2422     if (m_dc)
2423         ::DeleteDC((HDC) m_dc);
2424 }
2425
2426 wxDCCacheEntry* wxDC::FindBitmapInCache(WXHDC dc, int w, int h)
2427 {
2428     int depth = ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
2429     wxList::compatibility_iterator node = sm_bitmapCache.GetFirst();
2430     while (node)
2431     {
2432         wxDCCacheEntry* entry = (wxDCCacheEntry*) node->GetData();
2433
2434         if (entry->m_depth == depth)
2435         {
2436             if (entry->m_width < w || entry->m_height < h)
2437             {
2438                 ::DeleteObject((HBITMAP) entry->m_bitmap);
2439                 entry->m_bitmap = (WXHBITMAP) ::CreateCompatibleBitmap((HDC) dc, w, h);
2440                 if ( !entry->m_bitmap)
2441                 {
2442                     wxLogLastError(wxT("CreateCompatibleBitmap"));
2443                 }
2444                 entry->m_width = w; entry->m_height = h;
2445                 return entry;
2446             }
2447             return entry;
2448         }
2449
2450         node = node->GetNext();
2451     }
2452     WXHBITMAP hBitmap = (WXHBITMAP) ::CreateCompatibleBitmap((HDC) dc, w, h);
2453     if ( !hBitmap)
2454     {
2455         wxLogLastError(wxT("CreateCompatibleBitmap"));
2456     }
2457     wxDCCacheEntry* entry = new wxDCCacheEntry(hBitmap, w, h, depth);
2458     AddToBitmapCache(entry);
2459     return entry;
2460 }
2461
2462 wxDCCacheEntry* wxDC::FindDCInCache(wxDCCacheEntry* notThis, WXHDC dc)
2463 {
2464     int depth = ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
2465     wxList::compatibility_iterator node = sm_dcCache.GetFirst();
2466     while (node)
2467     {
2468         wxDCCacheEntry* entry = (wxDCCacheEntry*) node->GetData();
2469
2470         // Don't return the same one as we already have
2471         if (!notThis || (notThis != entry))
2472         {
2473             if (entry->m_depth == depth)
2474             {
2475                 return entry;
2476             }
2477         }
2478
2479         node = node->GetNext();
2480     }
2481     WXHDC hDC = (WXHDC) ::CreateCompatibleDC((HDC) dc);
2482     if ( !hDC)
2483     {
2484         wxLogLastError(wxT("CreateCompatibleDC"));
2485     }
2486     wxDCCacheEntry* entry = new wxDCCacheEntry(hDC, depth);
2487     AddToDCCache(entry);
2488     return entry;
2489 }
2490
2491 void wxDC::AddToBitmapCache(wxDCCacheEntry* entry)
2492 {
2493     sm_bitmapCache.Append(entry);
2494 }
2495
2496 void wxDC::AddToDCCache(wxDCCacheEntry* entry)
2497 {
2498     sm_dcCache.Append(entry);
2499 }
2500
2501 void wxDC::ClearCache()
2502 {
2503     WX_CLEAR_LIST(wxList, sm_dcCache);
2504     WX_CLEAR_LIST(wxList, sm_bitmapCache);
2505 }
2506
2507 // Clean up cache at app exit
2508 class wxDCModule : public wxModule
2509 {
2510 public:
2511     virtual bool OnInit() { return true; }
2512     virtual void OnExit() { wxDC::ClearCache(); }
2513
2514 private:
2515     DECLARE_DYNAMIC_CLASS(wxDCModule)
2516 };
2517
2518 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
2519
2520 #endif // wxUSE_DC_CACHEING
2521
2522 // ----------------------------------------------------------------------------
2523 // alpha channel support
2524 // ----------------------------------------------------------------------------
2525
2526 static bool AlphaBlt(HDC hdcDst,
2527                      int x, int y, int width, int height,
2528                      int srcX, int srcY, HDC hdcSrc,
2529                      const wxBitmap& bmp)
2530 {
2531     wxASSERT_MSG( bmp.Ok() && bmp.HasAlpha(), _T("AlphaBlt(): invalid bitmap") );
2532     wxASSERT_MSG( hdcDst && hdcSrc, _T("AlphaBlt(): invalid HDC") );
2533
2534     // do we have AlphaBlend() and company in the headers?
2535 #if defined(AC_SRC_OVER) && wxUSE_DYNLIB_CLASS
2536     // yes, now try to see if we have it during run-time
2537     typedef BOOL (WINAPI *AlphaBlend_t)(HDC,int,int,int,int,
2538                                         HDC,int,int,int,int,
2539                                         BLENDFUNCTION);
2540
2541     static AlphaBlend_t pfnAlphaBlend = wxMSIMG32_SYMBOL(AlphaBlend);
2542     if ( pfnAlphaBlend )
2543     {
2544         BLENDFUNCTION bf;
2545         bf.BlendOp = AC_SRC_OVER;
2546         bf.BlendFlags = 0;
2547         bf.SourceConstantAlpha = 0xff;
2548         bf.AlphaFormat = AC_SRC_ALPHA;
2549
2550         if ( pfnAlphaBlend(hdcDst, x, y, width, height,
2551                            hdcSrc, srcX, srcY, width, height,
2552                            bf) )
2553         {
2554             // skip wxAlphaBlend() call below
2555             return true;
2556         }
2557
2558         wxLogLastError(_T("AlphaBlend"));
2559     }
2560 #else
2561     wxUnusedVar(hdcSrc);
2562 #endif // defined(AC_SRC_OVER)
2563
2564     // AlphaBlend() unavailable of failed: use our own (probably much slower)
2565     // implementation
2566 #ifdef wxHAVE_RAW_BITMAP
2567     wxAlphaBlend(hdcDst, x, y, width, height, srcX, srcY, bmp);
2568
2569     return true;
2570 #else // !wxHAVE_RAW_BITMAP
2571     // no wxAlphaBlend() neither, fall back to using simple BitBlt() (we lose
2572     // alpha but at least something will be shown like this)
2573     wxUnusedVar(bmp);
2574     return false;
2575 #endif // wxHAVE_RAW_BITMAP
2576 }
2577
2578
2579 // wxAlphaBlend: our fallback if ::AlphaBlend() is unavailable
2580 #ifdef wxHAVE_RAW_BITMAP
2581
2582 static void
2583 wxAlphaBlend(HDC hdcDst, int xDst, int yDst,
2584              int w, int h,
2585              int srcX, int srcY, const wxBitmap& bmpSrc)
2586 {
2587     // get the destination DC pixels
2588     wxBitmap bmpDst(w, h, 32 /* force creating RGBA DIB */);
2589     MemoryHDC hdcMem;
2590     SelectInHDC select(hdcMem, GetHbitmapOf(bmpDst));
2591
2592     if ( !::BitBlt(hdcMem, 0, 0, w, h, hdcDst, xDst, yDst, SRCCOPY) )
2593     {
2594         wxLogLastError(_T("BitBlt"));
2595     }
2596
2597     // combine them with the source bitmap using alpha
2598     wxAlphaPixelData dataDst(bmpDst),
2599                      dataSrc((wxBitmap &)bmpSrc);
2600
2601     wxCHECK_RET( dataDst && dataSrc,
2602                     _T("failed to get raw data in wxAlphaBlend") );
2603
2604     wxAlphaPixelData::Iterator pDst(dataDst),
2605                                pSrc(dataSrc);
2606
2607     pSrc.Offset(dataSrc, srcX, srcY);
2608
2609     for ( int y = 0; y < h; y++ )
2610     {
2611         wxAlphaPixelData::Iterator pDstRowStart = pDst,
2612                                    pSrcRowStart = pSrc;
2613
2614         for ( int x = 0; x < w; x++ )
2615         {
2616             // note that source bitmap uses premultiplied alpha (as required by
2617             // the real AlphaBlend)
2618             const unsigned beta = 255 - pSrc.Alpha();
2619
2620             pDst.Red() = pSrc.Red() + (beta * pDst.Red() + 127) / 255;
2621             pDst.Blue() = pSrc.Blue() + (beta * pDst.Blue() + 127) / 255;
2622             pDst.Green() = pSrc.Green() + (beta * pDst.Green() + 127) / 255;
2623
2624             ++pDst;
2625             ++pSrc;
2626         }
2627
2628         pDst = pDstRowStart;
2629         pSrc = pSrcRowStart;
2630         pDst.OffsetY(dataDst, 1);
2631         pSrc.OffsetY(dataSrc, 1);
2632     }
2633
2634     // and finally blit them back to the destination DC
2635     if ( !::BitBlt(hdcDst, xDst, yDst, w, h, hdcMem, 0, 0, SRCCOPY) )
2636     {
2637         wxLogLastError(_T("BitBlt"));
2638     }
2639 }
2640
2641 #endif // #ifdef wxHAVE_RAW_BITMAP
2642
2643 void wxDC::DoGradientFillLinear (const wxRect& rect,
2644                                  const wxColour& initialColour,
2645                                  const wxColour& destColour,
2646                                  wxDirection nDirection)
2647 {
2648     // use native function if we have compile-time support it and can load it
2649     // during run-time (linking to it statically would make the program
2650     // unusable on earlier Windows versions)
2651 #if defined(GRADIENT_FILL_RECT_H) && wxUSE_DYNLIB_CLASS
2652     typedef BOOL
2653         (WINAPI *GradientFill_t)(HDC, PTRIVERTEX, ULONG, PVOID, ULONG, ULONG);
2654     static GradientFill_t pfnGradientFill = wxMSIMG32_SYMBOL(GradientFill);
2655
2656     if ( pfnGradientFill )
2657     {
2658         GRADIENT_RECT grect;
2659         grect.UpperLeft = 0;
2660         grect.LowerRight = 1;
2661
2662         // invert colours direction if not filling from left-to-right or
2663         // top-to-bottom
2664         int firstVertex = nDirection == wxNORTH || nDirection == wxWEST ? 1 : 0;
2665
2666         // one vertex for upper left and one for upper-right
2667         TRIVERTEX vertices[2];
2668
2669         vertices[0].x = rect.GetLeft();
2670         vertices[0].y = rect.GetTop();
2671         vertices[1].x = rect.GetRight();
2672         vertices[1].y = rect.GetBottom();
2673
2674         vertices[firstVertex].Red = (COLOR16)(initialColour.Red() << 8);
2675         vertices[firstVertex].Green = (COLOR16)(initialColour.Green() << 8);
2676         vertices[firstVertex].Blue = (COLOR16)(initialColour.Blue() << 8);
2677         vertices[firstVertex].Alpha = 0;
2678         vertices[1 - firstVertex].Red = (COLOR16)(destColour.Red() << 8);
2679         vertices[1 - firstVertex].Green = (COLOR16)(destColour.Green() << 8);
2680         vertices[1 - firstVertex].Blue = (COLOR16)(destColour.Blue() << 8);
2681         vertices[1 - firstVertex].Alpha = 0;
2682
2683         if ( (*pfnGradientFill)
2684              (
2685                 GetHdc(),
2686                 vertices,
2687                 WXSIZEOF(vertices),
2688                 &grect,
2689                 1,
2690                 nDirection == wxWEST || nDirection == wxEAST
2691                     ? GRADIENT_FILL_RECT_H
2692                     : GRADIENT_FILL_RECT_V
2693              ) )
2694         {
2695             // skip call of the base class version below
2696             return;
2697         }
2698
2699         wxLogLastError(_T("GradientFill"));
2700     }
2701 #endif // wxUSE_DYNLIB_CLASS
2702
2703     wxDCBase::DoGradientFillLinear(rect, initialColour, destColour, nDirection);
2704 }