src/msw/dc.cpp

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