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