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