src/common/dcbase.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/dcbase.cpp
   3 // Purpose:     generic methods of the wxDC Class
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     05/25/99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) wxWidgets team
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #include "wx/dc.h"
  28 #include "wx/dcclient.h"
  29 #include "wx/dcmemory.h"
  30 #include "wx/dcscreen.h"
  31 #include "wx/dcprint.h"
  32 #include "wx/prntbase.h"
  33 #include "wx/scopeguard.h"
  34
  35 #ifndef WX_PRECOMP
  36     #include "wx/math.h"
  37     #include "wx/module.h"
  38     #include "wx/window.h"
  39 #endif
  40
  41 #include "wx/private/textmeasure.h"
  42
  43 #ifdef __WXMSW__
  44     #include "wx/msw/dcclient.h"
  45     #include "wx/msw/dcmemory.h"
  46     #include "wx/msw/dcscreen.h"
  47 #endif
  48
  49 #ifdef __WXGTK3__
  50     #include "wx/gtk/dc.h"
  51 #elif defined __WXGTK20__
  52     #include "wx/gtk/dcclient.h"
  53     #include "wx/gtk/dcmemory.h"
  54     #include "wx/gtk/dcscreen.h"
  55 #elif defined(__WXGTK__)
  56     #include "wx/gtk1/dcclient.h"
  57     #include "wx/gtk1/dcmemory.h"
  58     #include "wx/gtk1/dcscreen.h"
  59 #endif
  60
  61 #ifdef __WXMAC__
  62     #include "wx/osx/dcclient.h"
  63     #include "wx/osx/dcmemory.h"
  64     #include "wx/osx/dcscreen.h"
  65 #endif
  66
  67 #ifdef __WXPM__
  68     #include "wx/os2/dcclient.h"
  69     #include "wx/os2/dcmemory.h"
  70     #include "wx/os2/dcscreen.h"
  71 #endif
  72
  73 #ifdef __WXCOCOA__
  74     #include "wx/cocoa/dcclient.h"
  75     #include "wx/cocoa/dcmemory.h"
  76     #include "wx/cocoa/dcscreen.h"
  77 #endif
  78
  79 #ifdef __WXMOTIF__
  80     #include "wx/motif/dcclient.h"
  81     #include "wx/motif/dcmemory.h"
  82     #include "wx/motif/dcscreen.h"
  83 #endif
  84
  85 #ifdef __WXX11__
  86     #include "wx/x11/dcclient.h"
  87     #include "wx/x11/dcmemory.h"
  88     #include "wx/x11/dcscreen.h"
  89 #endif
  90
  91 #ifdef __WXDFB__
  92     #include "wx/dfb/dcclient.h"
  93     #include "wx/dfb/dcmemory.h"
  94     #include "wx/dfb/dcscreen.h"
  95 #endif
  96
  97 //----------------------------------------------------------------------------
  98 // wxDCFactory
  99 //----------------------------------------------------------------------------
 100
 101 wxDCFactory *wxDCFactory::m_factory = NULL;
 102
 103 void wxDCFactory::Set(wxDCFactory *factory)
 104 {
 105     delete m_factory;
 106
 107     m_factory = factory;
 108 }
 109
 110 wxDCFactory *wxDCFactory::Get()
 111 {
 112     if ( !m_factory )
 113         m_factory = new wxNativeDCFactory;
 114
 115     return m_factory;
 116 }
 117
 118 class wxDCFactoryCleanupModule : public wxModule
 119 {
 120 public:
 121     virtual bool OnInit() { return true; }
 122     virtual void OnExit() { wxDCFactory::Set(NULL); }
 123
 124 private:
 125     DECLARE_DYNAMIC_CLASS(wxDCFactoryCleanupModule)
 126 };
 127
 128 IMPLEMENT_DYNAMIC_CLASS(wxDCFactoryCleanupModule, wxModule)
 129
 130 //-----------------------------------------------------------------------------
 131 // wxNativeDCFactory
 132 //-----------------------------------------------------------------------------
 133
 134 wxDCImpl* wxNativeDCFactory::CreateWindowDC( wxWindowDC *owner, wxWindow *window )
 135 {
 136     wxDCImpl * const impl = new wxWindowDCImpl( owner, window );
 137     impl->InheritAttributes(window);
 138     return impl;
 139 }
 140
 141 wxDCImpl* wxNativeDCFactory::CreateClientDC( wxClientDC *owner, wxWindow *window )
 142 {
 143     wxDCImpl * const impl = new wxClientDCImpl( owner, window );
 144     impl->InheritAttributes(window);
 145     return impl;
 146 }
 147
 148 wxDCImpl* wxNativeDCFactory::CreatePaintDC( wxPaintDC *owner, wxWindow *window )
 149 {
 150     wxDCImpl * const impl = new wxPaintDCImpl( owner, window );
 151     impl->InheritAttributes(window);
 152     return impl;
 153 }
 154
 155 wxDCImpl* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner )
 156 {
 157     return new wxMemoryDCImpl( owner );
 158 }
 159
 160 wxDCImpl* wxNativeDCFactory::CreateMemoryDC(wxMemoryDC *owner, wxBitmap& bitmap)
 161 {
 162     // the bitmap may be modified when it's selected into a memory DC so make
 163     // sure changing this bitmap doesn't affect any other shallow copies of it
 164     // (see wxMemoryDC::SelectObject())
 165     //
 166     // notice that we don't provide any ctor equivalent to SelectObjectAsSource
 167     // method because this should be rarely needed and easy to work around by
 168     // using the default ctor and calling SelectObjectAsSource itself
 169     if ( bitmap.IsOk() )
 170         bitmap.UnShare();
 171
 172     return new wxMemoryDCImpl(owner, bitmap);
 173 }
 174
 175 wxDCImpl* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner, wxDC *dc )
 176 {
 177     return new wxMemoryDCImpl( owner, dc );
 178 }
 179
 180 wxDCImpl* wxNativeDCFactory::CreateScreenDC( wxScreenDC *owner )
 181 {
 182     return new wxScreenDCImpl( owner );
 183 }
 184
 185 #if wxUSE_PRINTING_ARCHITECTURE
 186 wxDCImpl *wxNativeDCFactory::CreatePrinterDC( wxPrinterDC *owner, const wxPrintData &data )
 187 {
 188     wxPrintFactory *factory = wxPrintFactory::GetFactory();
 189     return factory->CreatePrinterDCImpl( owner, data );
 190 }
 191 #endif
 192
 193 //-----------------------------------------------------------------------------
 194 // wxWindowDC
 195 //-----------------------------------------------------------------------------
 196
 197 IMPLEMENT_ABSTRACT_CLASS(wxWindowDC, wxDC)
 198
 199 wxWindowDC::wxWindowDC(wxWindow *win)
 200           : wxDC(wxDCFactory::Get()->CreateWindowDC(this, win))
 201 {
 202 }
 203
 204 //-----------------------------------------------------------------------------
 205 // wxClientDC
 206 //-----------------------------------------------------------------------------
 207
 208 IMPLEMENT_ABSTRACT_CLASS(wxClientDC, wxWindowDC)
 209
 210 wxClientDC::wxClientDC(wxWindow *win)
 211           : wxWindowDC(wxDCFactory::Get()->CreateClientDC(this, win))
 212 {
 213 }
 214
 215 //-----------------------------------------------------------------------------
 216 // wxMemoryDC
 217 //-----------------------------------------------------------------------------
 218
 219 IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxDC)
 220
 221 wxMemoryDC::wxMemoryDC()
 222           : wxDC(wxDCFactory::Get()->CreateMemoryDC(this))
 223 {
 224 }
 225
 226 wxMemoryDC::wxMemoryDC(wxBitmap& bitmap)
 227           : wxDC(wxDCFactory::Get()->CreateMemoryDC(this, bitmap))
 228 {
 229 }
 230
 231 wxMemoryDC::wxMemoryDC(wxDC *dc)
 232           : wxDC(wxDCFactory::Get()->CreateMemoryDC(this, dc))
 233 {
 234 }
 235
 236 void wxMemoryDC::SelectObject(wxBitmap& bmp)
 237 {
 238     if ( bmp.IsSameAs(GetSelectedBitmap()) )
 239     {
 240         // Nothing to do, this bitmap is already selected.
 241         return;
 242     }
 243
 244     // make sure that the given wxBitmap is not sharing its data with other
 245     // wxBitmap instances as its contents will be modified by any drawing
 246     // operation done on this DC
 247     if (bmp.IsOk())
 248         bmp.UnShare();
 249
 250     GetImpl()->DoSelect(bmp);
 251 }
 252
 253 void wxMemoryDC::SelectObjectAsSource(const wxBitmap& bmp)
 254 {
 255     GetImpl()->DoSelect(bmp);
 256 }
 257
 258 const wxBitmap& wxMemoryDC::GetSelectedBitmap() const
 259 {
 260     return GetImpl()->GetSelectedBitmap();
 261 }
 262
 263 wxBitmap& wxMemoryDC::GetSelectedBitmap()
 264 {
 265     return GetImpl()->GetSelectedBitmap();
 266 }
 267
 268
 269 //-----------------------------------------------------------------------------
 270 // wxPaintDC
 271 //-----------------------------------------------------------------------------
 272
 273 IMPLEMENT_ABSTRACT_CLASS(wxPaintDC, wxClientDC)
 274
 275 wxPaintDC::wxPaintDC(wxWindow *win)
 276          : wxClientDC(wxDCFactory::Get()->CreatePaintDC(this, win))
 277 {
 278 }
 279
 280 //-----------------------------------------------------------------------------
 281 // wxScreenDC
 282 //-----------------------------------------------------------------------------
 283
 284 IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxWindowDC)
 285
 286 wxScreenDC::wxScreenDC()
 287           : wxDC(wxDCFactory::Get()->CreateScreenDC(this))
 288 {
 289 }
 290
 291 //-----------------------------------------------------------------------------
 292 // wxPrinterDC
 293 //-----------------------------------------------------------------------------
 294
 295 #if wxUSE_PRINTING_ARCHITECTURE
 296
 297 IMPLEMENT_DYNAMIC_CLASS(wxPrinterDC, wxDC)
 298
 299 wxPrinterDC::wxPrinterDC()
 300            : wxDC(wxDCFactory::Get()->CreatePrinterDC(this, wxPrintData()))
 301 {
 302 }
 303
 304 wxPrinterDC::wxPrinterDC(const wxPrintData& data)
 305            : wxDC(wxDCFactory::Get()->CreatePrinterDC(this, data))
 306 {
 307 }
 308
 309 wxRect wxPrinterDC::GetPaperRect() const
 310 {
 311     return GetImpl()->GetPaperRect();
 312 }
 313
 314 int wxPrinterDC::GetResolution() const
 315 {
 316     return GetImpl()->GetResolution();
 317 }
 318
 319 #endif // wxUSE_PRINTING_ARCHITECTURE
 320
 321 //-----------------------------------------------------------------------------
 322 // wxDCImpl
 323 //-----------------------------------------------------------------------------
 324
 325 IMPLEMENT_ABSTRACT_CLASS(wxDCImpl, wxObject)
 326
 327 wxDCImpl::wxDCImpl( wxDC *owner )
 328         : m_window(NULL)
 329         , m_colour(wxColourDisplay())
 330         , m_ok(true)
 331         , m_clipping(false)
 332         , m_isInteractive(0)
 333         , m_isBBoxValid(false)
 334         , m_logicalOriginX(0), m_logicalOriginY(0)
 335         , m_deviceOriginX(0), m_deviceOriginY(0)
 336         , m_deviceLocalOriginX(0), m_deviceLocalOriginY(0)
 337         , m_logicalScaleX(1.0), m_logicalScaleY(1.0)
 338         , m_userScaleX(1.0), m_userScaleY(1.0)
 339         , m_scaleX(1.0), m_scaleY(1.0)
 340         , m_signX(1), m_signY(1)
 341         , m_contentScaleFactor(1)
 342         , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
 343         , m_clipX1(0), m_clipY1(0), m_clipX2(0), m_clipY2(0)
 344         , m_logicalFunction(wxCOPY)
 345         , m_backgroundMode(wxBRUSHSTYLE_TRANSPARENT)
 346         , m_mappingMode(wxMM_TEXT)
 347         , m_pen()
 348         , m_brush()
 349         , m_backgroundBrush()
 350         , m_textForegroundColour(*wxBLACK)
 351         , m_textBackgroundColour(*wxWHITE)
 352         , m_font()
 353 #if wxUSE_PALETTE
 354         , m_palette()
 355         , m_hasCustomPalette(false)
 356 #endif // wxUSE_PALETTE
 357 {
 358     m_owner = owner;
 359
 360     m_mm_to_pix_x = (double)wxGetDisplaySize().GetWidth() /
 361                     (double)wxGetDisplaySizeMM().GetWidth();
 362     m_mm_to_pix_y = (double)wxGetDisplaySize().GetHeight() /
 363                     (double)wxGetDisplaySizeMM().GetHeight();
 364
 365     ResetBoundingBox();
 366     ResetClipping();
 367 }
 368
 369 wxDCImpl::~wxDCImpl()
 370 {
 371 }
 372
 373 // ----------------------------------------------------------------------------
 374 // clipping
 375 // ----------------------------------------------------------------------------
 376
 377 void wxDCImpl::DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
 378 {
 379     if ( m_clipping )
 380     {
 381         m_clipX1 = wxMax( m_clipX1, x );
 382         m_clipY1 = wxMax( m_clipY1, y );
 383         m_clipX2 = wxMin( m_clipX2, (x + w) );
 384         m_clipY2 = wxMin( m_clipY2, (y + h) );
 385     }
 386     else
 387     {
 388         m_clipping = true;
 389
 390         m_clipX1 = x;
 391         m_clipY1 = y;
 392         m_clipX2 = x + w;
 393         m_clipY2 = y + h;
 394     }
 395 }
 396
 397 // ----------------------------------------------------------------------------
 398 // coordinate conversions and transforms
 399 // ----------------------------------------------------------------------------
 400
 401 wxCoord wxDCImpl::DeviceToLogicalX(wxCoord x) const
 402 {
 403     return wxRound( (double)((x - m_deviceOriginX - m_deviceLocalOriginX) * m_signX) / m_scaleX ) + m_logicalOriginX ;
 404 }
 405
 406 wxCoord wxDCImpl::DeviceToLogicalY(wxCoord y) const
 407 {
 408     return wxRound( (double)((y - m_deviceOriginY - m_deviceLocalOriginY) * m_signY) / m_scaleY ) + m_logicalOriginY ;
 409 }
 410
 411 wxCoord wxDCImpl::DeviceToLogicalXRel(wxCoord x) const
 412 {
 413     return wxRound((double)(x) / m_scaleX);
 414 }
 415
 416 wxCoord wxDCImpl::DeviceToLogicalYRel(wxCoord y) const
 417 {
 418     return wxRound((double)(y) / m_scaleY);
 419 }
 420
 421 wxCoord wxDCImpl::LogicalToDeviceX(wxCoord x) const
 422 {
 423     return wxRound( (double)((x - m_logicalOriginX) * m_signX) * m_scaleX) + m_deviceOriginX + m_deviceLocalOriginX;
 424 }
 425
 426 wxCoord wxDCImpl::LogicalToDeviceY(wxCoord y) const
 427 {
 428     return wxRound( (double)((y - m_logicalOriginY) * m_signY) * m_scaleY) + m_deviceOriginY + m_deviceLocalOriginY;
 429 }
 430
 431 wxCoord wxDCImpl::LogicalToDeviceXRel(wxCoord x) const
 432 {
 433     return wxRound((double)(x) * m_scaleX);
 434 }
 435
 436 wxCoord wxDCImpl::LogicalToDeviceYRel(wxCoord y) const
 437 {
 438     return wxRound((double)(y) * m_scaleY);
 439 }
 440
 441 void wxDCImpl::ComputeScaleAndOrigin()
 442 {
 443     m_scaleX = m_logicalScaleX * m_userScaleX;
 444     m_scaleY = m_logicalScaleY * m_userScaleY;
 445 }
 446
 447 void wxDCImpl::SetMapMode( wxMappingMode mode )
 448 {
 449     switch (mode)
 450     {
 451         case wxMM_TWIPS:
 452           SetLogicalScale( twips2mm*m_mm_to_pix_x, twips2mm*m_mm_to_pix_y );
 453           break;
 454         case wxMM_POINTS:
 455           SetLogicalScale( pt2mm*m_mm_to_pix_x, pt2mm*m_mm_to_pix_y );
 456           break;
 457         case wxMM_METRIC:
 458           SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
 459           break;
 460         case wxMM_LOMETRIC:
 461           SetLogicalScale( m_mm_to_pix_x/10.0, m_mm_to_pix_y/10.0 );
 462           break;
 463         default:
 464         case wxMM_TEXT:
 465           SetLogicalScale( 1.0, 1.0 );
 466           break;
 467     }
 468     m_mappingMode = mode;
 469 }
 470
 471 void wxDCImpl::SetUserScale( double x, double y )
 472 {
 473     // allow negative ? -> no
 474     m_userScaleX = x;
 475     m_userScaleY = y;
 476     ComputeScaleAndOrigin();
 477 }
 478
 479 void wxDCImpl::SetLogicalScale( double x, double y )
 480 {
 481     // allow negative ?
 482     m_logicalScaleX = x;
 483     m_logicalScaleY = y;
 484     ComputeScaleAndOrigin();
 485 }
 486
 487 void wxDCImpl::SetLogicalOrigin( wxCoord x, wxCoord y )
 488 {
 489     m_logicalOriginX = x * m_signX;
 490     m_logicalOriginY = y * m_signY;
 491     ComputeScaleAndOrigin();
 492 }
 493
 494 void wxDCImpl::SetDeviceOrigin( wxCoord x, wxCoord y )
 495 {
 496     m_deviceOriginX = x;
 497     m_deviceOriginY = y;
 498     ComputeScaleAndOrigin();
 499 }
 500
 501 void wxDCImpl::SetDeviceLocalOrigin( wxCoord x, wxCoord y )
 502 {
 503     m_deviceLocalOriginX = x;
 504     m_deviceLocalOriginY = y;
 505     ComputeScaleAndOrigin();
 506 }
 507
 508 void wxDCImpl::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
 509 {
 510     // only wxPostScripDC has m_signX = -1, we override SetAxisOrientation there
 511     // wxWidgets 2.9: no longer override it
 512     m_signX = (xLeftRight ?  1 : -1);
 513     m_signY = (yBottomUp  ? -1 :  1);
 514     ComputeScaleAndOrigin();
 515 }
 516
 517 bool wxDCImpl::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
 518 {
 519     wxTextMeasure tm(GetOwner(), &m_font);
 520     return tm.GetPartialTextExtents(text, widths, m_scaleX);
 521 }
 522
 523 void wxDCImpl::GetMultiLineTextExtent(const wxString& text,
 524                                       wxCoord *x,
 525                                       wxCoord *y,
 526                                       wxCoord *h,
 527                                       const wxFont *font) const
 528 {
 529     wxTextMeasure tm(GetOwner(), font && font->IsOk() ? font : &m_font);
 530     tm.GetMultiLineTextExtent(text, x, y, h);
 531 }
 532
 533 void wxDCImpl::DoDrawCheckMark(wxCoord x1, wxCoord y1,
 534                                wxCoord width, wxCoord height)
 535 {
 536     wxCHECK_RET( IsOk(), wxT("invalid window dc") );
 537
 538     wxCoord x2 = x1 + width,
 539             y2 = y1 + height;
 540
 541     // the pen width is calibrated to give 3 for width == height == 10
 542     wxDCPenChanger pen( *m_owner, wxPen(GetTextForeground(), (width + height + 1)/7));
 543
 544     // we're drawing a scaled version of wx/generic/tick.xpm here
 545     wxCoord x3 = x1 + (4*width) / 10,   // x of the tick bottom
 546             y3 = y1 + height / 2;       // y of the left tick branch
 547     DoDrawLine(x1, y3, x3, y2);
 548     DoDrawLine(x3, y2, x2, y1);
 549
 550     CalcBoundingBox(x1, y1);
 551     CalcBoundingBox(x2, y2);
 552 }
 553
 554 bool
 555 wxDCImpl::DoStretchBlit(wxCoord xdest, wxCoord ydest,
 556                         wxCoord dstWidth, wxCoord dstHeight,
 557                         wxDC *source,
 558                         wxCoord xsrc, wxCoord ysrc,
 559                         wxCoord srcWidth, wxCoord srcHeight,
 560                         wxRasterOperationMode rop,
 561                         bool useMask,
 562                         wxCoord xsrcMask,
 563                         wxCoord ysrcMask)
 564 {
 565     wxCHECK_MSG( srcWidth && srcHeight && dstWidth && dstHeight, false,
 566                  wxT("invalid blit size") );
 567
 568     // emulate the stretching by modifying the DC scale
 569     double xscale = (double)srcWidth/dstWidth,
 570            yscale = (double)srcHeight/dstHeight;
 571
 572     double xscaleOld, yscaleOld;
 573     GetUserScale(&xscaleOld, &yscaleOld);
 574     SetUserScale(xscaleOld/xscale, yscaleOld/yscale);
 575
 576     bool rc = DoBlit(wxCoord(xdest*xscale), wxCoord(ydest*yscale),
 577                      wxCoord(dstWidth*xscale), wxCoord(dstHeight*yscale),
 578                      source,
 579                      xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask);
 580
 581     SetUserScale(xscaleOld, yscaleOld);
 582
 583     return rc;
 584 }
 585
 586 void wxDCImpl::DrawLines(const wxPointList *list, wxCoord xoffset, wxCoord yoffset)
 587 {
 588     int n = list->GetCount();
 589     wxPoint *points = new wxPoint[n];
 590
 591     int i = 0;
 592     for ( wxPointList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )
 593     {
 594         wxPoint *point = node->GetData();
 595         points[i].x = point->x;
 596         points[i].y = point->y;
 597     }
 598
 599     DoDrawLines(n, points, xoffset, yoffset);
 600
 601     delete [] points;
 602 }
 603
 604 void wxDCImpl::DrawPolygon(const wxPointList *list,
 605                            wxCoord xoffset, wxCoord yoffset,
 606                            wxPolygonFillMode fillStyle)
 607 {
 608     int n = list->GetCount();
 609     wxPoint *points = new wxPoint[n];
 610
 611     int i = 0;
 612     for ( wxPointList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )
 613     {
 614         wxPoint *point = node->GetData();
 615         points[i].x = point->x;
 616         points[i].y = point->y;
 617     }
 618
 619     DoDrawPolygon(n, points, xoffset, yoffset, fillStyle);
 620
 621     delete [] points;
 622 }
 623
 624 void
 625 wxDCImpl::DoDrawPolyPolygon(int n,
 626                             const int count[],
 627                             const wxPoint points[],
 628                             wxCoord xoffset, wxCoord yoffset,
 629                             wxPolygonFillMode fillStyle)
 630 {
 631     if ( n == 1 )
 632     {
 633         DoDrawPolygon(count[0], points, xoffset, yoffset, fillStyle);
 634         return;
 635     }
 636
 637     int      i, j, lastOfs;
 638     wxPoint* pts;
 639
 640     for (i = j = lastOfs = 0; i < n; i++)
 641     {
 642         lastOfs = j;
 643         j      += count[i];
 644     }
 645     pts = new wxPoint[j+n-1];
 646     for (i = 0; i < j; i++)
 647         pts[i] = points[i];
 648     for (i = 2; i <= n; i++)
 649     {
 650         lastOfs -= count[n-i];
 651         pts[j++] = pts[lastOfs];
 652     }
 653
 654     {
 655         wxDCPenChanger setTransp(*m_owner, *wxTRANSPARENT_PEN);
 656         DoDrawPolygon(j, pts, xoffset, yoffset, fillStyle);
 657     }
 658
 659     for (i = j = 0; i < n; i++)
 660     {
 661         DoDrawLines(count[i], pts+j, xoffset, yoffset);
 662         j += count[i];
 663     }
 664     delete[] pts;
 665 }
 666
 667 #if wxUSE_SPLINES
 668
 669 void wxDCImpl::DrawSpline(wxCoord x1, wxCoord y1,
 670                           wxCoord x2, wxCoord y2,
 671                           wxCoord x3, wxCoord y3)
 672 {
 673     wxPoint points[] = { wxPoint(x1, y1), wxPoint(x2, y2), wxPoint(x3, y3) };
 674     DrawSpline(WXSIZEOF(points), points);
 675 }
 676
 677 void wxDCImpl::DrawSpline(int n, const wxPoint points[])
 678 {
 679     wxPointList list;
 680     for ( int i = 0; i < n; i++ )
 681         list.Append(const_cast<wxPoint*>(&points[i]));
 682
 683     DrawSpline(&list);
 684 }
 685
 686 // ----------------------------------- spline code ----------------------------------------
 687
 688 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
 689                          double a3, double b3, double a4, double b4);
 690 void wx_clear_stack();
 691 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
 692         double *y3, double *x4, double *y4);
 693 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
 694           double x4, double y4);
 695 static bool wx_spline_add_point(double x, double y);
 696 static void wx_spline_draw_point_array(wxDC *dc);
 697
 698 static wxPointList wx_spline_point_list;
 699
 700 #define                half(z1, z2)        ((z1+z2)/2.0)
 701 #define                THRESHOLD        5
 702
 703 /* iterative version */
 704
 705 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
 706                  double b4)
 707 {
 708     register double  xmid, ymid;
 709     double           x1, y1, x2, y2, x3, y3, x4, y4;
 710
 711     wx_clear_stack();
 712     wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
 713
 714     while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
 715         xmid = (double)half(x2, x3);
 716         ymid = (double)half(y2, y3);
 717         if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
 718             fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
 719             wx_spline_add_point( x1, y1 );
 720             wx_spline_add_point( xmid, ymid );
 721         } else {
 722             wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
 723                  (double)half(x3, x4), (double)half(y3, y4), x4, y4);
 724             wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
 725                  (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
 726         }
 727     }
 728 }
 729
 730 /* utilities used by spline drawing routines */
 731
 732 typedef struct wx_spline_stack_struct {
 733     double           x1, y1, x2, y2, x3, y3, x4, y4;
 734 } Stack;
 735
 736 #define         SPLINE_STACK_DEPTH             20
 737 static Stack    wx_spline_stack[SPLINE_STACK_DEPTH];
 738 static Stack   *wx_stack_top;
 739 static int      wx_stack_count;
 740
 741 void wx_clear_stack()
 742 {
 743     wx_stack_top = wx_spline_stack;
 744     wx_stack_count = 0;
 745 }
 746
 747 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
 748 {
 749     wx_stack_top->x1 = x1;
 750     wx_stack_top->y1 = y1;
 751     wx_stack_top->x2 = x2;
 752     wx_stack_top->y2 = y2;
 753     wx_stack_top->x3 = x3;
 754     wx_stack_top->y3 = y3;
 755     wx_stack_top->x4 = x4;
 756     wx_stack_top->y4 = y4;
 757     wx_stack_top++;
 758     wx_stack_count++;
 759 }
 760
 761 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
 762                   double *x3, double *y3, double *x4, double *y4)
 763 {
 764     if (wx_stack_count == 0)
 765         return (0);
 766     wx_stack_top--;
 767     wx_stack_count--;
 768     *x1 = wx_stack_top->x1;
 769     *y1 = wx_stack_top->y1;
 770     *x2 = wx_stack_top->x2;
 771     *y2 = wx_stack_top->y2;
 772     *x3 = wx_stack_top->x3;
 773     *y3 = wx_stack_top->y3;
 774     *x4 = wx_stack_top->x4;
 775     *y4 = wx_stack_top->y4;
 776     return (1);
 777 }
 778
 779 static bool wx_spline_add_point(double x, double y)
 780 {
 781     wxPoint *point = new wxPoint( wxRound(x), wxRound(y) );
 782     wx_spline_point_list.Append(point );
 783     return true;
 784 }
 785
 786 static void wx_spline_draw_point_array(wxDC *dc)
 787 {
 788     dc->DrawLines(&wx_spline_point_list, 0, 0 );
 789     wxPointList::compatibility_iterator node = wx_spline_point_list.GetFirst();
 790     while (node)
 791     {
 792         wxPoint *point = node->GetData();
 793         delete point;
 794         wx_spline_point_list.Erase(node);
 795         node = wx_spline_point_list.GetFirst();
 796     }
 797 }
 798
 799 void wxDCImpl::DoDrawSpline( const wxPointList *points )
 800 {
 801     wxCHECK_RET( IsOk(), wxT("invalid window dc") );
 802
 803     const wxPoint *p;
 804     double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
 805     double           x1, y1, x2, y2;
 806
 807     wxPointList::compatibility_iterator node = points->GetFirst();
 808     if (!node)
 809         // empty list
 810         return;
 811
 812     p = node->GetData();
 813
 814     x1 = p->x;
 815     y1 = p->y;
 816
 817     node = node->GetNext();
 818     p = node->GetData();
 819
 820     x2 = p->x;
 821     y2 = p->y;
 822     cx1 = (double)((x1 + x2) / 2);
 823     cy1 = (double)((y1 + y2) / 2);
 824     cx2 = (double)((cx1 + x2) / 2);
 825     cy2 = (double)((cy1 + y2) / 2);
 826
 827     wx_spline_add_point(x1, y1);
 828
 829     while ((node = node->GetNext())
 830 #if !wxUSE_STD_CONTAINERS
 831            != NULL
 832 #endif // !wxUSE_STD_CONTAINERS
 833           )
 834     {
 835         p = node->GetData();
 836         x1 = x2;
 837         y1 = y2;
 838         x2 = p->x;
 839         y2 = p->y;
 840         cx4 = (double)(x1 + x2) / 2;
 841         cy4 = (double)(y1 + y2) / 2;
 842         cx3 = (double)(x1 + cx4) / 2;
 843         cy3 = (double)(y1 + cy4) / 2;
 844
 845         wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
 846
 847         cx1 = cx4;
 848         cy1 = cy4;
 849         cx2 = (double)(cx1 + x2) / 2;
 850         cy2 = (double)(cy1 + y2) / 2;
 851     }
 852
 853     wx_spline_add_point( cx1, cy1 );
 854     wx_spline_add_point( x2, y2 );
 855
 856     wx_spline_draw_point_array( m_owner );
 857 }
 858
 859 #endif // wxUSE_SPLINES
 860
 861
 862
 863 void wxDCImpl::DoGradientFillLinear(const wxRect& rect,
 864                                     const wxColour& initialColour,
 865                                     const wxColour& destColour,
 866                                     wxDirection nDirection)
 867 {
 868     // save old pen
 869     wxPen oldPen = m_pen;
 870     wxBrush oldBrush = m_brush;
 871
 872     wxUint8 nR1 = initialColour.Red();
 873     wxUint8 nG1 = initialColour.Green();
 874     wxUint8 nB1 = initialColour.Blue();
 875     wxUint8 nR2 = destColour.Red();
 876     wxUint8 nG2 = destColour.Green();
 877     wxUint8 nB2 = destColour.Blue();
 878     wxUint8 nR, nG, nB;
 879
 880     if ( nDirection == wxEAST || nDirection == wxWEST )
 881     {
 882         wxInt32 x = rect.GetWidth();
 883         wxInt32 w = x;              // width of area to shade
 884         wxInt32 xDelta = w/256;     // height of one shade bend
 885         if (xDelta < 1)
 886             xDelta = 1;
 887
 888         while (x >= xDelta)
 889         {
 890             x -= xDelta;
 891             if (nR1 > nR2)
 892                 nR = nR1 - (nR1-nR2)*(w-x)/w;
 893             else
 894                 nR = nR1 + (nR2-nR1)*(w-x)/w;
 895
 896             if (nG1 > nG2)
 897                 nG = nG1 - (nG1-nG2)*(w-x)/w;
 898             else
 899                 nG = nG1 + (nG2-nG1)*(w-x)/w;
 900
 901             if (nB1 > nB2)
 902                 nB = nB1 - (nB1-nB2)*(w-x)/w;
 903             else
 904                 nB = nB1 + (nB2-nB1)*(w-x)/w;
 905
 906             wxColour colour(nR,nG,nB);
 907             SetPen(wxPen(colour, 1, wxPENSTYLE_SOLID));
 908             SetBrush(wxBrush(colour));
 909             if(nDirection == wxEAST)
 910                 DoDrawRectangle(rect.GetRight()-x-xDelta+1, rect.GetTop(),
 911                         xDelta, rect.GetHeight());
 912             else //nDirection == wxWEST
 913                 DoDrawRectangle(rect.GetLeft()+x, rect.GetTop(),
 914                         xDelta, rect.GetHeight());
 915         }
 916     }
 917     else  // nDirection == wxNORTH || nDirection == wxSOUTH
 918     {
 919         wxInt32 y = rect.GetHeight();
 920         wxInt32 w = y;              // height of area to shade
 921         wxInt32 yDelta = w/255;     // height of one shade bend
 922         if (yDelta < 1)
 923             yDelta = 1;
 924
 925         while (y > 0)
 926         {
 927             y -= yDelta;
 928             if (nR1 > nR2)
 929                 nR = nR1 - (nR1-nR2)*(w-y)/w;
 930             else
 931                 nR = nR1 + (nR2-nR1)*(w-y)/w;
 932
 933             if (nG1 > nG2)
 934                 nG = nG1 - (nG1-nG2)*(w-y)/w;
 935             else
 936                 nG = nG1 + (nG2-nG1)*(w-y)/w;
 937
 938             if (nB1 > nB2)
 939                 nB = nB1 - (nB1-nB2)*(w-y)/w;
 940             else
 941                 nB = nB1 + (nB2-nB1)*(w-y)/w;
 942
 943             wxColour colour(nR,nG,nB);
 944             SetPen(wxPen(colour, 1, wxPENSTYLE_SOLID));
 945             SetBrush(wxBrush(colour));
 946             if(nDirection == wxNORTH)
 947                 DoDrawRectangle(rect.GetLeft(), rect.GetTop()+y,
 948                         rect.GetWidth(), yDelta);
 949             else //nDirection == wxSOUTH
 950                 DoDrawRectangle(rect.GetLeft(), rect.GetBottom()-y-yDelta+1,
 951                         rect.GetWidth(), yDelta);
 952         }
 953     }
 954
 955     SetPen(oldPen);
 956     SetBrush(oldBrush);
 957 }
 958
 959 void wxDCImpl::DoGradientFillConcentric(const wxRect& rect,
 960                                       const wxColour& initialColour,
 961                                       const wxColour& destColour,
 962                                       const wxPoint& circleCenter)
 963 {
 964     // save the old pen and ensure it is restored on exit
 965     const wxPen penOrig = m_pen;
 966     wxON_BLOCK_EXIT_SET(m_pen, penOrig);
 967
 968     wxUint8 nR1 = destColour.Red();
 969     wxUint8 nG1 = destColour.Green();
 970     wxUint8 nB1 = destColour.Blue();
 971     wxUint8 nR2 = initialColour.Red();
 972     wxUint8 nG2 = initialColour.Green();
 973     wxUint8 nB2 = initialColour.Blue();
 974     wxUint8 nR, nG, nB;
 975
 976
 977     //Radius
 978     double cx = rect.GetWidth() / 2;
 979     double cy = rect.GetHeight() / 2;
 980     double dRadius;
 981     if (cx < cy)
 982         dRadius = cx;
 983     else
 984         dRadius = cy;
 985
 986     //Offset of circle
 987     double ptX, ptY;
 988     ptX = circleCenter.x;
 989     ptY = circleCenter.y;
 990     double nCircleOffX = ptX - cx;
 991     double nCircleOffY = ptY - cy;
 992
 993     double dGradient;
 994     double dx, dy;
 995
 996     for ( wxInt32 x = 0; x < rect.GetWidth(); x++ )
 997     {
 998         for ( wxInt32 y = 0; y < rect.GetHeight(); y++ )
 999         {
1000             //get color difference
1001             dx = x;
1002             dy = y;
1003
1004             dGradient = ((dRadius - sqrt(  (dx - cx - nCircleOffX) * (dx - cx - nCircleOffX)
1005                                           +(dy - cy - nCircleOffY) * (dy - cy - nCircleOffY)
1006                                          )
1007                          ) * 100
1008                         ) / dRadius;
1009
1010             //normalize Gradient
1011             if (dGradient < 0)
1012                 dGradient = 0.0;
1013
1014             //get dest colors
1015             nR = (wxUint8)(nR1 + ((nR2 - nR1) * dGradient / 100));
1016             nG = (wxUint8)(nG1 + ((nG2 - nG1) * dGradient / 100));
1017             nB = (wxUint8)(nB1 + ((nB2 - nB1) * dGradient / 100));
1018
1019             //set the pixel
1020             SetPen(wxColour(nR,nG,nB));
1021             DoDrawPoint(x + rect.GetLeft(), y + rect.GetTop());
1022         }
1023     }
1024 }
1025
1026 void wxDCImpl::InheritAttributes(wxWindow *win)
1027 {
1028     wxCHECK_RET( win, "window can't be NULL" );
1029
1030     SetFont(win->GetFont());
1031     SetTextForeground(win->GetForegroundColour());
1032     SetTextBackground(win->GetBackgroundColour());
1033     SetBackground(win->GetBackgroundColour());
1034     SetLayoutDirection(win->GetLayoutDirection());
1035 }
1036
1037 void wxDCImpl::DoGetFontMetrics(int *height,
1038                                 int *ascent,
1039                                 int *descent,
1040                                 int *internalLeading,
1041                                 int *externalLeading,
1042                                 int *averageWidth) const
1043 {
1044     // Average width is typically the same as width of 'x'.
1045     wxCoord h, d;
1046     DoGetTextExtent("x", averageWidth, &h, &d, externalLeading);
1047
1048     if ( height )
1049         *height = h;
1050     if ( ascent )
1051         *ascent = h - d;
1052     if ( descent )
1053         *descent = d;
1054     if ( internalLeading )
1055         *internalLeading = 0;
1056 }
1057
1058 //-----------------------------------------------------------------------------
1059 // wxDC
1060 //-----------------------------------------------------------------------------
1061
1062 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
1063
1064 void wxDC::CopyAttributes(const wxDC& dc)
1065 {
1066     SetFont(dc.GetFont());
1067     SetTextForeground(dc.GetTextForeground());
1068     SetTextBackground(dc.GetTextBackground());
1069     SetBackground(dc.GetBackground());
1070     SetLayoutDirection(dc.GetLayoutDirection());
1071 }
1072
1073 void wxDC::DrawLabel(const wxString& text,
1074                          const wxBitmap& bitmap,
1075                          const wxRect& rect,
1076                          int alignment,
1077                          int indexAccel,
1078                          wxRect *rectBounding)
1079 {
1080     // find the text position
1081     wxCoord widthText, heightText, heightLine;
1082     GetMultiLineTextExtent(text, &widthText, &heightText, &heightLine);
1083
1084     wxCoord width, height;
1085     if ( bitmap.IsOk() )
1086     {
1087         width = widthText + bitmap.GetWidth();
1088         height = bitmap.GetHeight();
1089     }
1090     else // no bitmap
1091     {
1092         width = widthText;
1093         height = heightText;
1094     }
1095
1096     wxCoord x, y;
1097     if ( alignment & wxALIGN_RIGHT )
1098     {
1099         x = rect.GetRight() - width;
1100     }
1101     else if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
1102     {
1103         x = (rect.GetLeft() + rect.GetRight() + 1 - width) / 2;
1104     }
1105     else // alignment & wxALIGN_LEFT
1106     {
1107         x = rect.GetLeft();
1108     }
1109
1110     if ( alignment & wxALIGN_BOTTOM )
1111     {
1112         y = rect.GetBottom() - height;
1113     }
1114     else if ( alignment & wxALIGN_CENTRE_VERTICAL )
1115     {
1116         y = (rect.GetTop() + rect.GetBottom() + 1 - height) / 2;
1117     }
1118     else // alignment & wxALIGN_TOP
1119     {
1120         y = rect.GetTop();
1121     }
1122
1123     // draw the bitmap first
1124     wxCoord x0 = x,
1125             y0 = y,
1126             width0 = width;
1127     if ( bitmap.IsOk() )
1128     {
1129         DrawBitmap(bitmap, x, y, true /* use mask */);
1130
1131         wxCoord offset = bitmap.GetWidth() + 4;
1132         x += offset;
1133         width -= offset;
1134
1135         y += (height - heightText) / 2;
1136     }
1137
1138     // we will draw the underscore under the accel char later
1139     wxCoord startUnderscore = 0,
1140             endUnderscore = 0,
1141             yUnderscore = 0;
1142
1143     // split the string into lines and draw each of them separately
1144     //
1145     // NB: while wxDC::DrawText() on some platforms supports drawing multi-line
1146     //     strings natively, this is not the case for all of them, notably not
1147     //     wxMSW which uses this function for multi-line texts, so we may only
1148     //     call DrawText() for single-line strings from here to avoid infinite
1149     //     recursion.
1150     wxString curLine;
1151     for ( wxString::const_iterator pc = text.begin(); ; ++pc )
1152     {
1153         if ( pc == text.end() || *pc == '\n' )
1154         {
1155             int xRealStart = x; // init it here to avoid compielr warnings
1156
1157             if ( !curLine.empty() )
1158             {
1159                 // NB: can't test for !(alignment & wxALIGN_LEFT) because
1160                 //     wxALIGN_LEFT is 0
1161                 if ( alignment & (wxALIGN_RIGHT | wxALIGN_CENTRE_HORIZONTAL) )
1162                 {
1163                     wxCoord widthLine;
1164                     GetTextExtent(curLine, &widthLine, NULL);
1165
1166                     if ( alignment & wxALIGN_RIGHT )
1167                     {
1168                         xRealStart += width - widthLine;
1169                     }
1170                     else // if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
1171                     {
1172                         xRealStart += (width - widthLine) / 2;
1173                     }
1174                 }
1175                 //else: left aligned, nothing to do
1176
1177                 DrawText(curLine, xRealStart, y);
1178             }
1179
1180             y += heightLine;
1181
1182             // do we have underscore in this line? we can check yUnderscore
1183             // because it is set below to just y + heightLine if we do
1184             if ( y == yUnderscore )
1185             {
1186                 // adjust the horz positions to account for the shift
1187                 startUnderscore += xRealStart;
1188                 endUnderscore += xRealStart;
1189             }
1190
1191             if ( pc == text.end() )
1192                 break;
1193
1194             curLine.clear();
1195         }
1196         else // not end of line
1197         {
1198             if ( pc - text.begin() == indexAccel )
1199             {
1200                 // remember to draw underscore here
1201                 GetTextExtent(curLine, &startUnderscore, NULL);
1202                 curLine += *pc;
1203                 GetTextExtent(curLine, &endUnderscore, NULL);
1204
1205                 yUnderscore = y + heightLine;
1206             }
1207             else
1208             {
1209                 curLine += *pc;
1210             }
1211         }
1212     }
1213
1214     // draw the underscore if found
1215     if ( startUnderscore != endUnderscore )
1216     {
1217         // it should be of the same colour as text
1218         SetPen(wxPen(GetTextForeground(), 0, wxPENSTYLE_SOLID));
1219
1220         // This adjustment is relatively arbitrary: we need to draw the
1221         // underline slightly higher to avoid overflowing the character cell
1222         // but whether we should do it 1, 2 or 3 pixels higher is not clear.
1223         //
1224         // The currently used value seems to be compatible with native MSW
1225         // behaviour, i.e. it results in the same appearance of the owner-drawn
1226         // and normal labels.
1227         yUnderscore -= 2;
1228
1229         DrawLine(startUnderscore, yUnderscore, endUnderscore, yUnderscore);
1230     }
1231
1232     // return bounding rect if requested
1233     if ( rectBounding )
1234     {
1235         *rectBounding = wxRect(x, y - heightText, widthText, heightText);
1236     }
1237
1238     CalcBoundingBox(x0, y0);
1239     CalcBoundingBox(x0 + width0, y0 + height);
1240 }
1241
1242 #if WXWIN_COMPATIBILITY_2_8
1243     // for compatibility with the old code when wxCoord was long everywhere
1244 void wxDC::GetTextExtent(const wxString& string,
1245                        long *x, long *y,
1246                        long *descent,
1247                        long *externalLeading,
1248                        const wxFont *theFont) const
1249     {
1250         wxCoord x2, y2, descent2, externalLeading2;
1251         m_pimpl->DoGetTextExtent(string, &x2, &y2,
1252                         &descent2, &externalLeading2,
1253                         theFont);
1254         if ( x )
1255             *x = x2;
1256         if ( y )
1257             *y = y2;
1258         if ( descent )
1259             *descent = descent2;
1260         if ( externalLeading )
1261             *externalLeading = externalLeading2;
1262     }
1263
1264 void wxDC::GetLogicalOrigin(long *x, long *y) const
1265     {
1266         wxCoord x2, y2;
1267         m_pimpl->DoGetLogicalOrigin(&x2, &y2);
1268         if ( x )
1269             *x = x2;
1270         if ( y )
1271             *y = y2;
1272     }
1273
1274 void wxDC::GetDeviceOrigin(long *x, long *y) const
1275     {
1276         wxCoord x2, y2;
1277         m_pimpl->DoGetDeviceOrigin(&x2, &y2);
1278         if ( x )
1279             *x = x2;
1280         if ( y )
1281             *y = y2;
1282     }
1283
1284 void wxDC::GetClippingBox(long *x, long *y, long *w, long *h) const
1285     {
1286         wxCoord xx,yy,ww,hh;
1287         m_pimpl->DoGetClippingBox(&xx, &yy, &ww, &hh);
1288         if (x) *x = xx;
1289         if (y) *y = yy;
1290         if (w) *w = ww;
1291         if (h) *h = hh;
1292     }
1293
1294 void wxDC::DrawObject(wxDrawObject* drawobject)
1295 {
1296     drawobject->Draw(*this);
1297     CalcBoundingBox(drawobject->MinX(),drawobject->MinY());
1298     CalcBoundingBox(drawobject->MaxX(),drawobject->MaxY());
1299 }
1300
1301 #endif  // WXWIN_COMPATIBILITY_2_8
1302
1303 /*
1304 Notes for wxWidgets DrawEllipticArcRot(...)
1305
1306 wxDCBase::DrawEllipticArcRot(...) draws a rotated elliptic arc or an ellipse.
1307 It uses wxDCBase::CalculateEllipticPoints(...) and wxDCBase::Rotate(...),
1308 which are also new.
1309
1310 All methods are generic, so they can be implemented in wxDCBase.
1311 DoDrawEllipticArcRot(...) is virtual, so it can be called from deeper
1312 methods like (WinCE) wxDC::DoDrawArc(...).
1313
1314 CalculateEllipticPoints(...) fills a given list of wxPoints with some points
1315 of an elliptic arc. The algorithm is pixel-based: In every row (in flat
1316 parts) or every column (in steep parts) only one pixel is calculated.
1317 Trigonometric calculation (sin, cos, tan, atan) is only done if the
1318 starting angle is not equal to the ending angle. The calculation of the
1319 pixels is done using simple arithmetic only and should perform not too
1320 bad even on devices without floating point processor. I didn't test this yet.
1321
1322 Rotate(...) rotates a list of point pixel-based, you will see rounding errors.
1323 For instance: an ellipse rotated 180 degrees is drawn
1324 slightly different from the original.
1325
1326 The points are then moved to an array and used to draw a polyline and/or polygon
1327 (with center added, the pie).
1328 The result looks quite similar to the native ellipse, only e few pixels differ.
1329
1330 The performance on a desktop system (Athlon 1800, WinXP) is about 7 times
1331 slower as DrawEllipse(...), which calls the native API.
1332 An rotated ellipse outside the clipping region takes nearly the same time,
1333 while an native ellipse outside takes nearly no time to draw.
1334
1335 If you draw an arc with this new method, you will see the starting and ending angles
1336 are calculated properly.
1337 If you use DrawEllipticArc(...), you will see they are only correct for circles
1338 and not properly calculated for ellipses.
1339
1340 Peter Lenhard
1341 p.lenhard@t-online.de
1342 */
1343
1344 #ifdef __WXWINCE__
1345 void wxDCImpl::DoDrawEllipticArcRot( wxCoord x, wxCoord y,
1346                                      wxCoord w, wxCoord h,
1347                                      double sa, double ea, double angle )
1348 {
1349     wxPointList list;
1350
1351     CalculateEllipticPoints( &list, x, y, w, h, sa, ea );
1352     Rotate( &list, angle, wxPoint( x+w/2, y+h/2 ) );
1353
1354     // Add center (for polygon/pie)
1355     list.Append( new wxPoint( x+w/2, y+h/2 ) );
1356
1357     // copy list into array and delete list elements
1358     int n = list.GetCount();
1359     wxPoint *points = new wxPoint[n];
1360     int i = 0;
1361     wxPointList::compatibility_iterator node;
1362     for ( node = list.GetFirst(); node; node = node->GetNext(), i++ )
1363     {
1364         wxPoint *point = node->GetData();
1365         points[i].x = point->x;
1366         points[i].y = point->y;
1367         delete point;
1368     }
1369
1370     // first draw the pie without pen, if necessary
1371     if( GetBrush() != *wxTRANSPARENT_BRUSH )
1372     {
1373         wxPen tempPen( GetPen() );
1374         SetPen( *wxTRANSPARENT_PEN );
1375         DoDrawPolygon( n, points, 0, 0 );
1376         SetPen( tempPen );
1377     }
1378
1379     // then draw the arc without brush, if necessary
1380     if( GetPen() != *wxTRANSPARENT_PEN )
1381     {
1382         // without center
1383         DoDrawLines( n-1, points, 0, 0 );
1384     }
1385
1386     delete [] points;
1387
1388 } // DrawEllipticArcRot
1389
1390 void wxDCImpl::Rotate( wxPointList* points, double angle, wxPoint center )
1391 {
1392     if( angle != 0.0 )
1393     {
1394         double pi(M_PI);
1395         double dSinA = -sin(angle*2.0*pi/360.0);
1396         double dCosA = cos(angle*2.0*pi/360.0);
1397         wxPointList::compatibility_iterator node;
1398         for ( node = points->GetFirst(); node; node = node->GetNext() )
1399         {
1400             wxPoint* point = node->GetData();
1401
1402             // transform coordinates, if necessary
1403             if( center.x ) point->x -= center.x;
1404             if( center.y ) point->y -= center.y;
1405
1406             // calculate rotation, rounding simply by implicit cast to integer
1407             int xTemp = point->x * dCosA - point->y * dSinA;
1408             point->y = point->x * dSinA + point->y * dCosA;
1409             point->x = xTemp;
1410
1411             // back transform coordinates, if necessary
1412             if( center.x ) point->x += center.x;
1413             if( center.y ) point->y += center.y;
1414         }
1415     }
1416 }
1417
1418 void wxDCImpl::CalculateEllipticPoints( wxPointList* points,
1419                                         wxCoord xStart, wxCoord yStart,
1420                                         wxCoord w, wxCoord h,
1421                                         double sa, double ea )
1422 {
1423     double pi = M_PI;
1424     double sar = 0;
1425     double ear = 0;
1426     int xsa = 0;
1427     int ysa = 0;
1428     int xea = 0;
1429     int yea = 0;
1430     int sq = 0;
1431     int eq = 0;
1432     bool bUseAngles = false;
1433     if( w<0 ) w = -w;
1434     if( h<0 ) h = -h;
1435     // half-axes
1436     wxCoord a = w/2;
1437     wxCoord b = h/2;
1438     // decrement 1 pixel if ellipse is smaller than 2*a, 2*b
1439     int decrX = 0;
1440     if( 2*a == w ) decrX = 1;
1441     int decrY = 0;
1442     if( 2*b == h ) decrY = 1;
1443     // center
1444     wxCoord xCenter = xStart + a;
1445     wxCoord yCenter = yStart + b;
1446     // calculate data for start and end, if necessary
1447     if( sa != ea )
1448     {
1449         bUseAngles = true;
1450         // normalisation of angles
1451         while( sa<0 ) sa += 360;
1452         while( ea<0 ) ea += 360;
1453         while( sa>=360 ) sa -= 360;
1454         while( ea>=360 ) ea -= 360;
1455         // calculate quadrant numbers
1456         if( sa > 270 ) sq = 3;
1457         else if( sa > 180 ) sq = 2;
1458         else if( sa > 90 ) sq = 1;
1459         if( ea > 270 ) eq = 3;
1460         else if( ea > 180 ) eq = 2;
1461         else if( ea > 90 ) eq = 1;
1462         sar = sa * pi / 180.0;
1463         ear = ea * pi / 180.0;
1464         // correct angle circle -> ellipse
1465         sar = atan( -a/(double)b * tan( sar ) );
1466         if ( sq == 1 || sq == 2 ) sar += pi;
1467         ear = atan( -a/(double)b * tan( ear ) );
1468         if ( eq == 1 || eq == 2 ) ear += pi;
1469         // coordinates of points
1470         xsa = xCenter + a * cos( sar );
1471         if( sq == 0 || sq == 3 ) xsa -= decrX;
1472         ysa = yCenter + b * sin( sar );
1473         if( sq == 2 || sq == 3 ) ysa -= decrY;
1474         xea = xCenter + a * cos( ear );
1475         if( eq == 0 || eq == 3 ) xea -= decrX;
1476         yea = yCenter + b * sin( ear );
1477         if( eq == 2 || eq == 3 ) yea -= decrY;
1478     } // if iUseAngles
1479     // calculate c1 = b^2, c2 = b^2/a^2 with a = w/2, b = h/2
1480     double c1 = b * b;
1481     double c2 = 2.0 / w;
1482     c2 *= c2;
1483     c2 *= c1;
1484     wxCoord x = 0;
1485     wxCoord y = b;
1486     long x2 = 1;
1487     long y2 = y*y;
1488     long y2_old = 0;
1489     long y_old = 0;
1490     // Lists for quadrant 1 to 4
1491     wxPointList pointsarray[4];
1492     // Calculate points for first quadrant and set in all quadrants
1493     for( x = 0; x <= a; ++x )
1494     {
1495         x2 = x2+x+x-1;
1496         y2_old = y2;
1497         y_old = y;
1498         bool bNewPoint = false;
1499         while( y2 > c1 - c2 * x2 && y > 0 )
1500         {
1501             bNewPoint = true;
1502             y2 = y2-y-y+1;
1503             --y;
1504         }
1505         // old y now too big: set point with old y, old x
1506         if( bNewPoint && x>1)
1507         {
1508             int x1 = x - 1;
1509             // remove points on the same line
1510             pointsarray[0].Insert( new wxPoint( xCenter + x1 - decrX, yCenter - y_old ) );
1511             pointsarray[1].Append( new wxPoint( xCenter - x1, yCenter - y_old ) );
1512             pointsarray[2].Insert( new wxPoint( xCenter - x1, yCenter + y_old - decrY ) );
1513             pointsarray[3].Append( new wxPoint( xCenter + x1 - decrX, yCenter + y_old - decrY ) );
1514         } // set point
1515     } // calculate point
1516
1517     // Starting and/or ending points for the quadrants, first quadrant gets both.
1518     pointsarray[0].Insert( new wxPoint( xCenter + a - decrX, yCenter ) );
1519     pointsarray[0].Append( new wxPoint( xCenter, yCenter - b ) );
1520     pointsarray[1].Append( new wxPoint( xCenter - a, yCenter ) );
1521     pointsarray[2].Append( new wxPoint( xCenter, yCenter + b - decrY ) );
1522     pointsarray[3].Append( new wxPoint( xCenter + a - decrX, yCenter ) );
1523
1524     // copy quadrants in original list
1525     if( bUseAngles )
1526     {
1527         // Copy the right part of the points in the lists
1528         // and delete the wxPoints, because they do not leave this method.
1529         points->Append( new wxPoint( xsa, ysa ) );
1530         int q = sq;
1531         bool bStarted = false;
1532         bool bReady = false;
1533         bool bForceTurn = ( sq == eq && sa > ea );
1534         while( !bReady )
1535         {
1536             wxPointList::compatibility_iterator node;
1537             for( node = pointsarray[q].GetFirst(); node; node = node->GetNext() )
1538             {
1539                 // once: go to starting point in start quadrant
1540                 if( !bStarted &&
1541                     (
1542                       node->GetData()->x < xsa+1 && q <= 1
1543                       ||
1544                       node->GetData()->x > xsa-1 && q >= 2
1545                     )
1546                   )
1547                 {
1548                     bStarted = true;
1549                 }
1550
1551                 // copy point, if not at ending point
1552                 if( bStarted )
1553                 {
1554                     if( q != eq || bForceTurn
1555                         ||
1556                         ( (wxPoint*) node->GetData() )->x > xea+1 && q <= 1
1557                         ||
1558                         ( (wxPoint*) node->GetData() )->x < xea-1 && q >= 2
1559                       )
1560                     {
1561                         // copy point
1562                         wxPoint* pPoint = new wxPoint( *(node->GetData()) );
1563                         points->Append( pPoint );
1564                     }
1565                     else if( q == eq && !bForceTurn || node->GetData()->x == xea)
1566                     {
1567                         bReady = true;
1568                     }
1569                 }
1570             } // for node
1571             ++q;
1572             if( q > 3 ) q = 0;
1573             bForceTurn = false;
1574             bStarted = true;
1575         } // while not bReady
1576         points->Append( new wxPoint( xea, yea ) );
1577
1578         // delete points
1579         for( q = 0; q < 4; ++q )
1580         {
1581             wxPointList::compatibility_iterator node;
1582             for( node = pointsarray[q].GetFirst(); node; node = node->GetNext() )
1583             {
1584                 wxPoint *p = node->GetData();
1585                 delete p;
1586             }
1587         }
1588     }
1589     else
1590     {
1591         wxPointList::compatibility_iterator node;
1592         // copy whole ellipse, wxPoints will be deleted outside
1593         for( node = pointsarray[0].GetFirst(); node; node = node->GetNext() )
1594         {
1595             wxPoint *p = node->GetData();
1596             points->Append( p );
1597         }
1598         for( node = pointsarray[1].GetFirst(); node; node = node->GetNext() )
1599         {
1600             wxPoint *p = node->GetData();
1601             points->Append( p );
1602         }
1603         for( node = pointsarray[2].GetFirst(); node; node = node->GetNext() )
1604         {
1605             wxPoint *p = node->GetData();
1606             points->Append( p );
1607         }
1608         for( node = pointsarray[3].GetFirst(); node; node = node->GetNext() )
1609         {
1610             wxPoint *p = node->GetData();
1611             points->Append( p );
1612         }
1613     } // not iUseAngles
1614 } // CalculateEllipticPoints
1615
1616 #endif // __WXWINCE__
1617
1618 float wxDCImpl::GetFontPointSizeAdjustment(float dpi)
1619 {
1620     // wxMSW has long-standing bug where wxFont point size is interpreted as
1621     // "pixel size corresponding to given point size *on screen*". In other
1622     // words, on a typical 600dpi printer and a typical 96dpi screen, fonts
1623     // are ~6 times smaller when printing. Unfortunately, this bug is so severe
1624     // that *all* printing code has to account for it and consequently, other
1625     // ports need to emulate this bug too:
1626     const wxSize screenPPI = wxGetDisplayPPI();
1627     return float(screenPPI.y) / dpi;
1628 }