include/wx/dc.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/dc.h
   3 // Purpose:     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 #ifndef _WX_DC_H_BASE_
  13 #define _WX_DC_H_BASE_
  14
  15 // ----------------------------------------------------------------------------
  16 // headers which we must include here
  17 // ----------------------------------------------------------------------------
  18
  19 #include "wx/object.h"          // the base class
  20
  21 #include "wx/intl.h"            // for wxLayoutDirection
  22 #include "wx/cursor.h"          // we have member variables of these classes
  23 #include "wx/font.h"            // so we can't do without them
  24 #include "wx/colour.h"
  25 #include "wx/bitmap.h"          // for wxNullBitmap
  26 #include "wx/brush.h"
  27 #include "wx/pen.h"
  28 #include "wx/palette.h"
  29 #include "wx/list.h"            // we use wxList in inline functions
  30 #include "wx/dynarray.h"
  31 #include "wx/math.h"
  32
  33   // 1 if using the reorganized DC code
  34 #define wxUSE_NEW_DC 0
  35
  36
  37 #if wxUSE_NEW_DC
  38
  39 //-----------------------------------------------------------------------------
  40 // wxDCFactory
  41 //-----------------------------------------------------------------------------
  42
  43 class WXDLLIMPEXP_FWD_CORE wxImplDC;
  44
  45 class WXDLLIMPEXP_CORE wxDCFactory
  46 {
  47 public:
  48     wxDCFactory() {}
  49     virtual ~wxDCFactory() {}
  50
  51     virtual wxImplDC* CreateWindowDC() = 0;
  52     virtual wxImplDC* CreateWindowDC( wxWindow *window ) = 0;
  53     virtual wxImplDC* CreateClientDC() = 0;
  54     virtual wxImplDC* CreateClientDC( wxWindow *window ) = 0;
  55     virtual wxImplDC* CreatePaintDC() = 0;
  56     virtual wxImplDC* CreatePaintDC( wxWindow *window ) = 0;
  57     virtual wxImplDC* CreateMemoryDC() = 0;
  58     virtual wxImplDC* CreateMemoryDC( wxBitmap &bitmap ) = 0;
  59     virtual wxImplDC* CreateMemoryDC( wxDC *dc ) = 0;
  60
  61     static void SetDCFactory( wxDCFactory *factory );
  62     static wxDCFactory *GetFactory();
  63 private:
  64     static wxDCFactory *m_factory;
  65 };
  66
  67 //-----------------------------------------------------------------------------
  68 // wxNativeDCFactory
  69 //-----------------------------------------------------------------------------
  70
  71 class WXDLLIMPEXP_CORE wxDCFactory
  72 {
  73 public:
  74     wxNativeDCFactory() {}
  75
  76     virtual wxImplDC* CreateWindowDC();
  77     virtual wxImplDC* CreateWindowDC( wxWindow *window );
  78     virtual wxImplDC* CreateClientDC();
  79     virtual wxImplDC* CreateClientDC( wxWindow *window );
  80     virtual wxImplDC* CreatePaintDC();
  81     virtual wxImplDC* CreatePaintDC( wxWindow *window );
  82     virtual wxImplDC* CreateMemoryDC();
  83     virtual wxImplDC* CreateMemoryDC( wxBitmap &bitmap );
  84     virtual wxImplDC* CreateMemoryDC( wxDC *dc );
  85 };
  86
  87 //-----------------------------------------------------------------------------
  88 // wxWindowDC
  89 //-----------------------------------------------------------------------------
  90
  91 class WXDLLIMPEXP_CORE wxWindowDC : public wxDC
  92 {
  93 public:
  94     wxWindowDC();
  95     wxWindowDC( wxWindow *win );
  96
  97 private:
  98     DECLARE_DYNAMIC_CLASS(wxWindowDC)
  99 };
 100
 101 //-----------------------------------------------------------------------------
 102 // wxClientDC
 103 //-----------------------------------------------------------------------------
 104
 105 class WXDLLIMPEXP_CORE wxClientDC : public wxDC
 106 {
 107 public:
 108     wxClientDC();
 109     wxClientDC( wxWindow *win );
 110
 111 private:
 112     DECLARE_DYNAMIC_CLASS(wxClientDC)
 113 };
 114
 115 //-----------------------------------------------------------------------------
 116 // wxMemoryDC
 117 //-----------------------------------------------------------------------------
 118
 119 class WXDLLIMPEXP_CORE wxMemoryDC: public wxDC
 120 {
 121 public:
 122     wxMemoryDC();
 123     wxMemoryDC( wxBitmap& bitmap );
 124     wxMemoryDC( wxDC *dc );
 125
 126 private:
 127     DECLARE_DYNAMIC_CLASS(wxMemoryDC)
 128 };
 129
 130 //-----------------------------------------------------------------------------
 131 // wxPaintDC
 132 //-----------------------------------------------------------------------------
 133
 134 class WXDLLIMPEXP_CORE wxPaintDC : public wxDC
 135 {
 136 public:
 137     wxPaintDC();
 138     wxPaintDC( wxWindow *win );
 139
 140 private:
 141     DECLARE_DYNAMIC_CLASS(wxPaintDC)
 142 };
 143
 144 //-----------------------------------------------------------------------------
 145 // wxImplDC
 146 //-----------------------------------------------------------------------------
 147
 148 class WXDLLIMPEXP_CORE wxImplDC: public wxObject
 149 {
 150 public:
 151     wxImplDC( wxDC *owner );
 152     ~wxImplDC();
 153
 154     wxDC *GetOwner() { return m_owner; }
 155
 156     virtual bool IsOk() const { return m_ok; }
 157
 158     // query capabilities
 159
 160     virtual bool CanDrawBitmap() const = 0;
 161     virtual bool CanGetTextExtent() const = 0;
 162
 163     // query dimension, colour deps, resolution
 164
 165     virtual void DoGetSize(int *width, int *height) const = 0;
 166     virtual void DoGetSizeMM(int* width, int* height) const = 0;
 167
 168     virtual int GetDepth() const = 0;
 169     virtual wxSize GetPPI() const = 0;
 170
 171     // Right-To-Left (RTL) modes
 172
 173     virtual void SetLayoutDirection(wxLayoutDirection WXUNUSED(dir)) { }
 174     virtual wxLayoutDirection GetLayoutDirection() const  { return wxLayout_Default; }
 175
 176     // page and document
 177
 178     virtual bool StartDoc(const wxString& WXUNUSED(message)) { return true; }
 179     virtual void EndDoc() { }
 180
 181     virtual void StartPage() { }
 182     virtual void EndPage() { }
 183
 184     // bounding box
 185
 186     virtual void CalcBoundingBox(wxCoord x, wxCoord y);
 187     {
 188       if ( m_isBBoxValid )
 189       {
 190          if ( x < m_minX ) m_minX = x;
 191          if ( y < m_minY ) m_minY = y;
 192          if ( x > m_maxX ) m_maxX = x;
 193          if ( y > m_maxY ) m_maxY = y;
 194       }
 195       else
 196       {
 197          m_isBBoxValid = true;
 198
 199          m_minX = x;
 200          m_minY = y;
 201          m_maxX = x;
 202          m_maxY = y;
 203       }
 204     }
 205     void ResetBoundingBox();
 206     {
 207         m_isBBoxValid = false;
 208
 209         m_minX = m_maxX = m_minY = m_maxY = 0;
 210     }
 211
 212     wxCoord MinX() const { return m_minX; }
 213     wxCoord MaxX() const { return m_maxX; }
 214     wxCoord MinY() const { return m_minY; }
 215     wxCoord MaxY() const { return m_maxY; }
 216
 217     // setters and getters
 218
 219     virtual void SetFont(const wxFont& font) = 0;
 220     virtual const wxFont&   GetFont() const { return m_font; }
 221
 222     virtual void SetPen(const wxPen& pen) = 0;
 223     virtual const wxPen&    GetPen() const { return m_pen; }
 224
 225     virtual void SetBrush(const wxBrush& brush) = 0;
 226     virtual const wxBrush&  GetBrush() const { return m_brush; }
 227
 228     virtual void SetBackground(const wxBrush& brush) = 0;
 229     virtual const wxBrush&  GetBackground() const { return m_backgroundBrush; }
 230
 231     virtual void SetBackgroundMode(int mode) = 0;
 232     virtual int GetBackgroundMode() const { return m_backgroundMode; }
 233
 234     virtual void SetTextForeground(const wxColour& colour)
 235         { m_textForegroundColour = colour; }
 236     virtual const wxColour& GetTextForeground() const { return m_textForegroundColour; }
 237
 238     virtual void SetTextBackground(const wxColour& colour)
 239         { m_textBackgroundColour = colour; }
 240     virtual const wxColour& GetTextBackground() const { return m_textBackgroundColour; }
 241
 242 #if wxUSE_PALETTE
 243     virtual void SetPalette(const wxPalette& palette) = 0;
 244 #endif // wxUSE_PALETTE
 245
 246     // logical functions
 247
 248     virtual void SetLogicalFunction(int function) = 0;
 249     virtual int GetLogicalFunction() const { return m_logicalFunction; }
 250
 251     // text measurement
 252
 253     virtual wxCoord GetCharHeight() const = 0;
 254     virtual wxCoord GetCharWidth() const = 0;
 255     virtual void DoGetTextExtent(const wxString& string,
 256                                  wxCoord *x, wxCoord *y,
 257                                  wxCoord *descent = NULL,
 258                                  wxCoord *externalLeading = NULL,
 259                                  const wxFont *theFont = NULL) const = 0;
 260     virtual void GetMultiLineTextExtent(const wxString& string,
 261                                         wxCoord *width,
 262                                         wxCoord *height,
 263                                         wxCoord *heightLine = NULL,
 264                                         const wxFont *font = NULL) const;
 265     virtual bool DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const;
 266
 267     // clearing
 268
 269     virtual void Clear() = 0;
 270
 271     // clipping
 272
 273     virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
 274                                      wxCoord width, wxCoord height) = 0;
 275     virtual void DoSetClippingRegionAsRegion(const wxRegion& region) = 0;
 276
 277     virtual void DoGetClippingBox(wxCoord *x, wxCoord *y,
 278                                   wxCoord *w, wxCoord *h) const
 279     {
 280         if ( x )
 281             *x = m_clipX1;
 282         if ( y )
 283             *y = m_clipY1;
 284         if ( w )
 285             *w = m_clipX2 - m_clipX1;
 286         if ( h )
 287             *h = m_clipY2 - m_clipY1;
 288     }
 289
 290     virtual void DestroyClippingRegion() { ResetClipping(); }
 291
 292
 293     // coordinates conversions and transforms
 294
 295     virtual wxCoord DeviceToLogicalX(wxCoord x) const;
 296     virtual wxCoord DeviceToLogicalY(wxCoord y) const;
 297     virtual wxCoord DeviceToLogicalXRel(wxCoord x) const;
 298     virtual wxCoord DeviceToLogicalYRel(wxCoord y) const;
 299     virtual wxCoord LogicalToDeviceX(wxCoord x) const;
 300     virtual wxCoord LogicalToDeviceY(wxCoord y) const;
 301     virtual wxCoord LogicalToDeviceXRel(wxCoord x) const;
 302     virtual wxCoord LogicalToDeviceYRel(wxCoord y) const;
 303
 304     virtual void SetMapMode(int mode);
 305     virtual int GetMapMode() const { return m_mappingMode; }
 306
 307     virtual void SetUserScale(double x, double y);
 308     virtual void GetUserScale(double *x, double *y) const
 309     {
 310         if ( x ) *x = m_userScaleX;
 311         if ( y ) *y = m_userScaleY;
 312     }
 313
 314     virtual void SetLogicalScale(double x, double y);
 315     virtual void GetLogicalScale(double *x, double *y)
 316     {
 317         if ( x ) *x = m_logicalScaleX;
 318         if ( y ) *y = m_logicalScaleY;
 319     }
 320
 321     virtual void SetLogicalOrigin(wxCoord x, wxCoord y);
 322     virtual void DoGetLogicalOrigin(wxCoord *x, wxCoord *y) const
 323     {
 324         if ( x ) *x = m_logicalOriginX;
 325         if ( y ) *y = m_logicalOriginY;
 326     }
 327
 328     virtual void SetDeviceOrigin(wxCoord x, wxCoord y);
 329     virtual void DoGetDeviceOrigin(wxCoord *x, wxCoord *y) const
 330     {
 331         if ( x ) *x = m_deviceOriginX;
 332         if ( y ) *y = m_deviceOriginY;
 333     }
 334
 335     virtual void SetDeviceLocalOrigin( wxCoord x, wxCoord y );
 336
 337     virtual void ComputeScaleAndOrigin();
 338
 339     // this needs to overidden if the axis is inverted
 340     virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp);
 341
 342     // ---------------------------------------------------------
 343     // the actual drawing API
 344
 345     virtual bool DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,
 346                              int style = wxFLOOD_SURFACE) = 0;
 347
 348     virtual void DoGradientFillLinear(const wxRect& rect,
 349                                       const wxColour& initialColour,
 350                                       const wxColour& destColour,
 351                                       wxDirection nDirection = wxEAST);
 352
 353     virtual void DoGradientFillConcentric(const wxRect& rect,
 354                                         const wxColour& initialColour,
 355                                         const wxColour& destColour,
 356                                         const wxPoint& circleCenter);
 357
 358     virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const = 0;
 359
 360     virtual void DoDrawPoint(wxCoord x, wxCoord y) = 0;
 361     virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2) = 0;
 362
 363     virtual void DoDrawArc(wxCoord x1, wxCoord y1,
 364                            wxCoord x2, wxCoord y2,
 365                            wxCoord xc, wxCoord yc) = 0;
 366     virtual void DoDrawCheckMark(wxCoord x, wxCoord y,
 367                                  wxCoord width, wxCoord height);
 368     virtual void DoDrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
 369                                    double sa, double ea) = 0;
 370
 371     virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height) = 0;
 372     virtual void DoDrawRoundedRectangle(wxCoord x, wxCoord y,
 373                                         wxCoord width, wxCoord height,
 374                                         double radius) = 0;
 375     virtual void DoDrawEllipse(wxCoord x, wxCoord y,
 376                                wxCoord width, wxCoord height) = 0;
 377
 378     virtual void DoCrossHair(wxCoord x, wxCoord y) = 0;
 379
 380     virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y) = 0;
 381     virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
 382                               bool useMask = false) = 0;
 383
 384     virtual void DoDrawText(const wxString& text, wxCoord x, wxCoord y) = 0;
 385     virtual void DoDrawRotatedText(const wxString& text,
 386                                    wxCoord x, wxCoord y, double angle) = 0;
 387
 388     virtual bool DoBlit(wxCoord xdest, wxCoord ydest,
 389                         wxCoord width, wxCoord height,
 390                         wxDC *source,
 391                         wxCoord xsrc, wxCoord ysrc,
 392                         int rop = wxCOPY,
 393                         bool useMask = false,
 394                         wxCoord xsrcMask = wxDefaultCoord,
 395                         wxCoord ysrcMask = wxDefaultCoord) = 0;
 396
 397     virtual bool DoStretchBlit(wxCoord xdest, wxCoord ydest,
 398                                wxCoord dstWidth, wxCoord dstHeight,
 399                                wxDC *source,
 400                                wxCoord xsrc, wxCoord ysrc,
 401                                wxCoord srcWidth, wxCoord srcHeight,
 402                                int rop = wxCOPY,
 403                                bool useMask = false,
 404                                wxCoord xsrcMask = wxDefaultCoord,
 405                                wxCoord ysrcMask = wxDefaultCoord);
 406
 407     virtual wxBitmap DoGetAsBitmap(const wxRect *WXUNUSED(subrect)) const
 408         { return wxNullBitmap; }
 409
 410
 411     virtual void DoDrawLines(int n, wxPoint points[],
 412                              wxCoord xoffset, wxCoord yoffset) = 0;
 413     virtual void DoDrawPolygon(int n, wxPoint points[],
 414                                wxCoord xoffset, wxCoord yoffset,
 415                                int fillStyle = wxODDEVEN_RULE) = 0;
 416     virtual void DoDrawPolyPolygon(int n, int count[], wxPoint points[],
 417                                wxCoord xoffset, wxCoord yoffset,
 418                                int fillStyle);
 419
 420
 421
 422 #if wxUSE_SPLINES
 423     virtual void DoDrawSpline(wxList *points);
 424 #endif
 425
 426 private:
 427     wxDC    *m_owner;
 428
 429 protected:
 430     // unset clipping variables (after clipping region was destroyed)
 431     void ResetClipping()
 432     {
 433         m_clipping = false;
 434
 435         m_clipX1 = m_clipX2 = m_clipY1 = m_clipY2 = 0;
 436     }
 437
 438     // flags
 439     bool m_colour:1;
 440     bool m_ok:1;
 441     bool m_clipping:1;
 442     bool m_isInteractive:1;
 443     bool m_isBBoxValid:1;
 444
 445     // coordinate system variables
 446
 447     wxCoord m_logicalOriginX, m_logicalOriginY;
 448     wxCoord m_deviceOriginX, m_deviceOriginY;           // Usually 0,0, can be change by user
 449
 450     wxCoord m_deviceLocalOriginX, m_deviceLocalOriginY; // non-zero if native top-left corner
 451                                                         // is not at 0,0. This was the case under
 452                                                         // Mac's GrafPorts (coordinate system
 453                                                         // used toplevel window's origin) and
 454                                                         // e.g. for Postscript, where the native
 455                                                         // origin in the bottom left corner.
 456     double m_logicalScaleX, m_logicalScaleY;
 457     double m_userScaleX, m_userScaleY;
 458     double m_scaleX, m_scaleY;  // calculated from logical scale and user scale
 459
 460     int m_signX, m_signY;  // Used by SetAxisOrientation() to invert the axes
 461
 462     // what is a mm on a screen you don't know the size of?
 463     double       m_mm_to_pix_x,
 464                  m_mm_to_pix_y;
 465
 466     // bounding and clipping boxes
 467     wxCoord m_minX, m_minY, m_maxX, m_maxY;
 468     wxCoord m_clipX1, m_clipY1, m_clipX2, m_clipY2;
 469
 470     int m_logicalFunction;
 471     int m_backgroundMode;
 472     int m_mappingMode;
 473
 474     wxPen             m_pen;
 475     wxBrush           m_brush;
 476     wxBrush           m_backgroundBrush;
 477     wxColour          m_textForegroundColour;
 478     wxColour          m_textBackgroundColour;
 479     wxFont            m_font;
 480
 481 #if wxUSE_PALETTE
 482     wxPalette         m_palette;
 483     bool              m_hasCustomPalette;
 484 #endif // wxUSE_PALETTE
 485
 486 private:
 487     DECLARE_ABSTRACT_CLASS(wxImplDC)
 488 }
 489
 490
 491 class wxDC: public wxObject
 492 {
 493 public:
 494     wxDC()   { m_pimpl = NULL; }
 495
 496     bool IsOk() const
 497         { return m_pimpl && m_pimpl->IsOk(); }
 498
 499     // query capabilities
 500
 501     bool CanDrawBitmap() const
 502         { return m_pimpl->CanDrawBitmap(); }
 503     bool CanGetTextExtent() const
 504         { return m_pimpl->CanGetTextExtent(); }
 505
 506     // query dimension, colour deps, resolution
 507
 508     void GetSize(int *width, int *height) const
 509         { m_pimpl->DoGetSize(width, height); }
 510
 511     wxSize GetSize() const
 512     {
 513         int w, h;
 514         m_pimpl->DoGetSize(&w, &h);
 515         return wxSize(w, h);
 516     }
 517
 518     void GetSizeMM(int* width, int* height) const
 519         { m_pimpl->DoGetSizeMM(width, height); }
 520     wxSize GetSizeMM() const
 521     {
 522         int w, h;
 523         m_pimpl->DoGetSizeMM(&w, &h);
 524         return wxSize(w, h);
 525     }
 526
 527     int GetDepth() const
 528         { return m_pimpl->GetDepth(); }
 529     wxSize GetPPI() const
 530         { return m_pimpl->GetPPI(); }
 531
 532     // Right-To-Left (RTL) modes
 533
 534     void SetLayoutDirection(wxLayoutDirection dir)
 535         { m_pimpl->SetLayoutDirection( dir ); }
 536     wxLayoutDirection GetLayoutDirection() const
 537         { return m_pimpl->GetLayoutDirection(); }
 538
 539     // page and document
 540
 541     bool StartDoc(const wxString& message)
 542         { return m_pimpl->StartDoc(message); }
 543     void EndDoc()
 544         { m_pimpl->EndDoc(); }
 545
 546     void StartPage()
 547         { m_pimpl->StartPage(); }
 548     void EndPage()
 549         { m_pimpl->EndPage(); }
 550
 551     // bounding box
 552
 553     void CalcBoundingBox(wxCoord x, wxCoord y)
 554         { m_pimpl->CalcBoundingBox(x,y); }
 555     void ResetBoundingBox()
 556         { m_pimpl->ResetBoundingBox(); }
 557
 558     wxCoord MinX() const
 559         { return m_pimpl->MinX(); }
 560     wxCoord MaxX() const
 561         { return m_pimpl->MaxX(); }
 562     wxCoord MinY() const
 563         { return m_pimpl->MinY(); }
 564     wxCoord MaxY() const
 565         { return m_pimpl->MaxY(); }
 566
 567     // setters and getters
 568
 569     void SetFont(const wxFont& font)
 570         { m_pimpl->SetFont( font ); }
 571     const wxFont&   GetFont() const
 572         { return m_pimpl->GetFont(); }
 573
 574     void SetPen(const wxPen& pen)
 575         { m_pimpl->SetPen( pen ); }
 576     const wxPen&    GetPen() const
 577         { return m_pimpl->GetPen(); }
 578
 579     void SetBrush(const wxBrush& brush)
 580         { m_pimpl->SetBrush( brush ); }
 581     const wxBrush&  GetBrush() const
 582         { return m_pimpl->GetBrush(); }
 583
 584     void SetBackground(const wxBrush& brush)
 585         { m_pimpl->SetBackground( brush ); }
 586     const wxBrush&  GetBackground() const
 587         { return m_pimpl->GetBackground(); }
 588
 589     void SetBackgroundMode(int mode)
 590         { m_pimpl->SetBackground( mode ); }
 591     int GetBackgroundMode() const
 592         { return m_pimpl->GetBackground(); }
 593
 594     void SetTextForeground(const wxColour& colour)
 595         { m_pimpl->SetTextForeground(colour); }
 596     const wxColour& GetTextForeground() const
 597         { return m_pimpl->GetTextForeground(); }
 598
 599     void SetTextBackground(const wxColour& colour)
 600         { m_pimpl->SetTextBackground(colour); }
 601     const wxColour& GetTextBackground() const
 602         { return m_pimpl->GetTextBackground(); }
 603
 604 #if wxUSE_PALETTE
 605     void SetPalette(const wxPalette& palette)
 606         { m_pimpl->SetPalette(palette); }
 607 #endif // wxUSE_PALETTE
 608
 609     // logical functions
 610
 611     void SetLogicalFunction(int function)
 612         { m_pimpl->SetLogicalFunction(function); }
 613     int GetLogicalFunction() const
 614         { return m_pimpl->GetLogicalFunction(); }
 615
 616     // text measurement
 617
 618     wxCoord GetCharHeight() const
 619         { return m_pimpl->GetCharHeight(); }
 620     wxCoord GetCharWidth() const
 621         { return m_pimpl->GetCharWidth(); }
 622
 623     void GetTextExtent(const wxString& string,
 624                        wxCoord *x, wxCoord *y,
 625                        wxCoord *descent = NULL,
 626                        wxCoord *externalLeading = NULL,
 627                        const wxFont *theFont = NULL) const
 628         { m_pimpl->DoGetTextExtent(string, x, y, descent, externalLeading, theFont); }
 629
 630     wxSize GetTextExtent(const wxString& string) const
 631     {
 632         wxCoord w, h;
 633         m_pimpl->DoGetTextExtent(string, &w, &h);
 634         return wxSize(w, h);
 635     }
 636
 637     void GetMultiLineTextExtent(const wxString& string,
 638                                         wxCoord *width,
 639                                         wxCoord *height,
 640                                         wxCoord *heightLine = NULL,
 641                                         const wxFont *font = NULL) const
 642         { m_pimpl->GetMultiLineTextExtent( string, width, height, heightLine, font ); }
 643
 644     wxSize GetMultiLineTextExtent(const wxString& string) const
 645     {
 646         wxCoord w, h;
 647         m_pimpl->GetMultiLineTextExtent(string, &w, &h);
 648         return wxSize(w, h);
 649     }
 650
 651     bool GetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
 652         { return m_pimpl->DoGetPartialTextExtents(text, widths); }
 653
 654     // clearing
 655
 656     void Clear()
 657         { m_pimpl->Clear(); }
 658
 659     // clipping
 660
 661     void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 662         { m_pimpl->DoSetClippingRegion(x, y, width, height); }
 663     void SetClippingRegion(const wxPoint& pt, const wxSize& sz)
 664         { m_pimpl->DoSetClippingRegion(pt.x, pt.y, sz.x, sz.y); }
 665     void SetClippingRegion(const wxRect& rect)
 666         { m_pimpl->DoSetClippingRegion(rect.x, rect.y, rect.width, rect.height); }
 667     void SetClippingRegion(const wxRegion& region)
 668         { m_pimpl->DoSetClippingRegionAsRegion(region); }
 669
 670     void DestroyClippingRegion()
 671         { m_pimpl->DestroyClippingRegion(); }
 672
 673     void GetClippingBox(wxCoord *x, wxCoord *y, wxCoord *w, wxCoord *h) const
 674         { m_pimpl->DoGetClippingBox(x, y, w, h); }
 675     void GetClippingBox(wxRect& rect) const
 676         { m_pimpl->DoGetClippingBox(&rect.x, &rect.y, &rect.width, &rect.height); }
 677
 678     // coordinates conversions and transforms
 679
 680     wxCoord DeviceToLogicalX(wxCoord x) const
 681         { return m_pimpl->DeviceToLogicalX(x); }
 682     wxCoord DeviceToLogicalY(wxCoord y) const;
 683         { return m_pimpl->DeviceToLogicalY(y); }
 684     wxCoord DeviceToLogicalXRel(wxCoord x) const;
 685         { return m_pimpl->DeviceToLogicalXRel(x); }
 686     wxCoord DeviceToLogicalYRel(wxCoord y) const;
 687         { return m_pimpl->DeviceToLogicalYRel(y); }
 688     wxCoord LogicalToDeviceX(wxCoord x) const;
 689         { return m_pimpl->LogicalToDeviceX(x); }
 690     wxCoord LogicalToDeviceY(wxCoord y) const;
 691         { return m_pimpl->LogicalToDeviceY(y); }
 692     wxCoord LogicalToDeviceXRel(wxCoord x) const;
 693         { return m_pimpl->LogicalToDeviceXRel(x); }
 694     wxCoord LogicalToDeviceYRel(wxCoord y) const;
 695         { return m_pimpl->LogicalToDeviceYRel(y); }
 696
 697     void SetMapMode(int mode)
 698         { m_pimpl->SetMapMode(mode); }
 699     int GetMapMode() const
 700         { return m_pimpl->GetMapMode(); }
 701
 702     void SetUserScale(double x, double y)
 703         { m_pimpl->SetUserScale(x,y); }
 704     void GetUserScale(double *x, double *y) const
 705         { m_pimpl->GetUserScale( x, y ); }
 706
 707     void SetLogicalScale(double x, double y)
 708         { m_pimpl->SetLogicalScale( x, y ); }
 709     void GetLogicalScale(double *x, double *y)
 710         { m_pimpl->GetLogicalScale( x, y ); }
 711
 712     void SetLogicalOrigin(wxCoord x, wxCoord y)
 713         { m_pimpl->SetLogicalOrigin(x,y); }
 714     void GetLogicalOrigin(wxCoord *x, wxCoord *y) const
 715         { m_pimpl->DoGetLogicalOrigin(x, y); }
 716     wxPoint GetLogicalOrigin() const
 717         { wxCoord x, y; m_pimpl->DoGetLogicalOrigin(&x, &y); return wxPoint(x, y); }
 718
 719     void SetDeviceOrigin(wxCoord x, wxCoord y)
 720         { m_pimpl->SetDeviceOrigin( x, y); }
 721     void GetDeviceOrigin(wxCoord *x, wxCoord *y) const
 722         { m_pimpl->DoGetDeviceOrigin(x, y); }
 723     wxPoint GetDeviceOrigin() const
 724         { wxCoord x, y; m_pimpl->DoGetDeviceOrigin(&x, &y); return wxPoint(x, y); }
 725
 726     void SetAxisOrientation(bool xLeftRight, bool yBottomUp)
 727         { m_pimpl->SetAxisOrientation(xLeftRight, yBottomUp); }
 728
 729     // mostly internal
 730     void SetDeviceLocalOrigin( wxCoord x, wxCoord y )
 731         { m_pimpl->SetDeviceLocalOrigin( x, y ); }
 732
 733
 734     // draw generic object
 735
 736     void DrawObject(wxDrawObject* drawobject)
 737     {
 738         drawobject->Draw(*this);
 739         CalcBoundingBox(drawobject->MinX(),drawobject->MinY());
 740         CalcBoundingBox(drawobject->MaxX(),drawobject->MaxY());
 741     }
 742
 743     // -----------------------------------------------
 744     // the actual drawing API
 745
 746     bool FloodFill(wxCoord x, wxCoord y, const wxColour& col,
 747                    int style = wxFLOOD_SURFACE)
 748         { return m_pimpl->DoFloodFill(x, y, col, style); }
 749     bool FloodFill(const wxPoint& pt, const wxColour& col,
 750                    int style = wxFLOOD_SURFACE)
 751         { return m_pimpl->DoFloodFill(pt.x, pt.y, col, style); }
 752
 753     // fill the area specified by rect with a radial gradient, starting from
 754     // initialColour in the centre of the cercle and fading to destColour.
 755     void GradientFillConcentric(const wxRect& rect,
 756                                 const wxColour& initialColour,
 757                                 const wxColour& destColour)
 758         { m_pimpl->GradientFillConcentric(rect, initialColour, destColour,
 759                                  wxPoint(rect.GetWidth() / 2,
 760                                          rect.GetHeight() / 2)); }
 761
 762     void GradientFillConcentric(const wxRect& rect,
 763                                 const wxColour& initialColour,
 764                                 const wxColour& destColour,
 765                                 const wxPoint& circleCenter)
 766         { m_pimpl->DoGradientFillConcentric(rect, initialColour, destColour, circleCenter); }
 767
 768     // fill the area specified by rect with a linear gradient
 769     void GradientFillLinear(const wxRect& rect,
 770                             const wxColour& initialColour,
 771                             const wxColour& destColour,
 772                             wxDirection nDirection = wxEAST)
 773         { m_pimpl->DoGradientFillLinear(rect, initialColour, destColour, nDirection); }
 774
 775     bool GetPixel(wxCoord x, wxCoord y, wxColour *col) const
 776         { return m_pimpl->DoGetPixel(x, y, col); }
 777     bool GetPixel(const wxPoint& pt, wxColour *col) const
 778         { return m_pimpl->DoGetPixel(pt.x, pt.y, col); }
 779
 780     void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
 781         { m_pimpl->DoDrawLine(x1, y1, x2, y2); }
 782     void DrawLine(const wxPoint& pt1, const wxPoint& pt2)
 783         { m_pimpl->DoDrawLine(pt1.x, pt1.y, pt2.x, pt2.y); }
 784
 785     void CrossHair(wxCoord x, wxCoord y)
 786         { m_pimpl->DoCrossHair(x, y); }
 787     void CrossHair(const wxPoint& pt)
 788         { m_pimpl->DoCrossHair(pt.x, pt.y); }
 789
 790     void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
 791                  wxCoord xc, wxCoord yc)
 792         { m_pimpl->DoDrawArc(x1, y1, x2, y2, xc, yc); }
 793     void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre)
 794         { m_pimpl->DoDrawArc(pt1.x, pt1.y, pt2.x, pt2.y, centre.x, centre.y); }
 795
 796     void DrawCheckMark(wxCoord x, wxCoord y,
 797                        wxCoord width, wxCoord height)
 798         { m_pimpl->DoDrawCheckMark(x, y, width, height); }
 799     void DrawCheckMark(const wxRect& rect)
 800         { m_pimpl->DoDrawCheckMark(rect.x, rect.y, rect.width, rect.height); }
 801
 802     void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
 803                          double sa, double ea)
 804         { m_pimpl->DoDrawEllipticArc(x, y, w, h, sa, ea); }
 805     void DrawEllipticArc(const wxPoint& pt, const wxSize& sz,
 806                          double sa, double ea)
 807         { m_pimpl->DoDrawEllipticArc(pt.x, pt.y, sz.x, sz.y, sa, ea); }
 808
 809     void DrawPoint(wxCoord x, wxCoord y)
 810         { m_pimpl->DoDrawPoint(x, y); }
 811     void DrawPoint(const wxPoint& pt)
 812         { m_pimpl->DoDrawPoint(pt.x, pt.y); }
 813
 814     void DrawLines(int n, wxPoint points[],
 815                    wxCoord xoffset = 0, wxCoord yoffset = 0)
 816         { m_pimpl->DoDrawLines(n, points, xoffset, yoffset); }
 817     void DrawLines(const wxList *list,
 818                    wxCoord xoffset = 0, wxCoord yoffset = 0)
 819         { m_pimpl->DrawLines( list, xoffset, yoffset ); }
 820
 821     void DrawPolygon(int n, wxPoint points[],
 822                      wxCoord xoffset = 0, wxCoord yoffset = 0,
 823                      int fillStyle = wxODDEVEN_RULE)
 824         { m_pimpl->DoDrawPolygon(n, points, xoffset, yoffset, fillStyle); }
 825
 826     void DrawPolygon(const wxList *list,
 827                      wxCoord xoffset = 0, wxCoord yoffset = 0,
 828                      int fillStyle = wxODDEVEN_RULE)
 829         { m_pimpl->DrawPolygon( list, xoffset, yoffset, fillStyle ); }
 830
 831     void DrawPolyPolygon(int n, int count[], wxPoint points[],
 832                          wxCoord xoffset = 0, wxCoord yoffset = 0,
 833                          int fillStyle = wxODDEVEN_RULE)
 834         { m_pimpl->DoDrawPolyPolygon(n, count, points, xoffset, yoffset, fillStyle); }
 835
 836     void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 837         { m_pimpl->DoDrawRectangle(x, y, width, height); }
 838     void DrawRectangle(const wxPoint& pt, const wxSize& sz)
 839         { m_pimpl->DoDrawRectangle(pt.x, pt.y, sz.x, sz.y); }
 840     void DrawRectangle(const wxRect& rect)
 841         { m_pimpl->DoDrawRectangle(rect.x, rect.y, rect.width, rect.height); }
 842
 843     void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height,
 844                               double radius)
 845         { m_pimpl->DoDrawRoundedRectangle(x, y, width, height, radius); }
 846     void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz,
 847                              double radius)
 848         { m_pimpl->DoDrawRoundedRectangle(pt.x, pt.y, sz.x, sz.y, radius); }
 849     void DrawRoundedRectangle(const wxRect& r, double radius)
 850         { m_pimpl->DoDrawRoundedRectangle(r.x, r.y, r.width, r.height, radius); }
 851
 852     void DrawCircle(wxCoord x, wxCoord y, wxCoord radius)
 853         { m_pimpl->DoDrawEllipse(x - radius, y - radius, 2*radius, 2*radius); }
 854     void DrawCircle(const wxPoint& pt, wxCoord radius)
 855         { m_pimpl->DrawCircle(pt.x, pt.y, radius); }
 856
 857     void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 858         { m_pimpl->DoDrawEllipse(x, y, width, height); }
 859     void DrawEllipse(const wxPoint& pt, const wxSize& sz)
 860         { m_pimpl->DoDrawEllipse(pt.x, pt.y, sz.x, sz.y); }
 861     void DrawEllipse(const wxRect& rect)
 862         { m_pimpl->DoDrawEllipse(rect.x, rect.y, rect.width, rect.height); }
 863
 864     void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
 865         { m_pimpl->DoDrawIcon(icon, x, y); }
 866     void DrawIcon(const wxIcon& icon, const wxPoint& pt)
 867         { m_pimpl->DoDrawIcon(icon, pt.x, pt.y); }
 868
 869     void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
 870                     bool useMask = false)
 871         { m_pimpl->DoDrawBitmap(bmp, x, y, useMask); }
 872     void DrawBitmap(const wxBitmap &bmp, const wxPoint& pt,
 873                     bool useMask = false)
 874         { m_pimpl->DoDrawBitmap(bmp, pt.x, pt.y, useMask); }
 875
 876     void DrawText(const wxString& text, wxCoord x, wxCoord y)
 877         { m_pimpl->DoDrawText(text, x, y); }
 878     void DrawText(const wxString& text, const wxPoint& pt)
 879         { m_pimpl->DoDrawText(text, pt.x, pt.y); }
 880
 881     void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle)
 882         { m_pimpl->DoDrawRotatedText(text, x, y, angle); }
 883     void DrawRotatedText(const wxString& text, const wxPoint& pt, double angle)
 884         { m_pimpl->DoDrawRotatedText(text, pt.x, pt.y, angle); }
 885
 886     // this version puts both optional bitmap and the text into the given
 887     // rectangle and aligns is as specified by alignment parameter; it also
 888     // will emphasize the character with the given index if it is != -1 and
 889     // return the bounding rectangle if required
 890     void DrawLabel(const wxString& text,
 891                            const wxBitmap& image,
 892                            const wxRect& rect,
 893                            int alignment = wxALIGN_LEFT | wxALIGN_TOP,
 894                            int indexAccel = -1,
 895                            wxRect *rectBounding = NULL)
 896         { m_pimpl->DrawLabel( text, image, rect, alignment, indexAccel, rectBounding ); }
 897
 898     void DrawLabel(const wxString& text, const wxRect& rect,
 899                    int alignment = wxALIGN_LEFT | wxALIGN_TOP,
 900                    int indexAccel = -1)
 901         { m_pimpl->DrawLabel(text, wxNullBitmap, rect, alignment, indexAccel); }
 902
 903     bool Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
 904               wxDC *source, wxCoord xsrc, wxCoord ysrc,
 905               int rop = wxCOPY, bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord)
 906     {
 907         return m_pimpl->DoBlit(xdest, ydest, width, height,
 908                       source, xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask);
 909     }
 910     bool Blit(const wxPoint& destPt, const wxSize& sz,
 911               wxDC *source, const wxPoint& srcPt,
 912               int rop = wxCOPY, bool useMask = false, const wxPoint& srcPtMask = wxDefaultPosition)
 913     {
 914         return m_pimpl->DoBlit(destPt.x, destPt.y, sz.x, sz.y,
 915                       source, srcPt.x, srcPt.y, rop, useMask, srcPtMask.x, srcPtMask.y);
 916     }
 917
 918     bool StretchBlit(wxCoord dstX, wxCoord dstY,
 919                      wxCoord dstWidth, wxCoord dstHeight,
 920                      wxDC *source,
 921                      wxCoord srcX, wxCoord srcY,
 922                      wxCoord srcWidth, wxCoord srcHeight,
 923                      int rop = wxCOPY, bool useMask = false,
 924                      wxCoord srcMaskX = wxDefaultCoord, wxCoord srcMaskY = wxDefaultCoord)
 925     {
 926         return m_pimpl->DoStretchBlit(dstX, dstY, dstWidth, dstHeight,
 927                       source, srcX, srcY, srcWidth, srcHeight, rop, useMask, srcMaskX, srcMaskY);
 928     }
 929     bool StretchBlit(const wxPoint& dstPt, const wxSize& dstSize,
 930                      wxDC *source, const wxPoint& srcPt, const wxSize& srcSize,
 931                      int rop = wxCOPY, bool useMask = false, const wxPoint& srcMaskPt = wxDefaultPosition)
 932     {
 933         return m_pimpl->DoStretchBlit(dstPt.x, dstPt.y, dstSize.x, dstSize.y,
 934                       source, srcPt.x, srcPt.y, srcSize.x, srcSize.y, rop, useMask, srcMaskPt.x, srcMaskPt.y);
 935     }
 936
 937     wxBitmap GetAsBitmap(const wxRect *subrect = (const wxRect *) NULL) const
 938     {
 939         return m_pimpl->DoGetAsBitmap(subrect);
 940     }
 941
 942 #if wxUSE_SPLINES
 943     // TODO: this API needs fixing (wxPointList, why (!const) "wxList *"?)
 944     void DrawSpline(wxCoord x1, wxCoord y1,
 945                     wxCoord x2, wxCoord y2,
 946                     wxCoord x3, wxCoord y3)
 947         { m_pimpl->DrawSpline(x1,y1,x2,y2,x3,y3); }
 948     void DrawSpline(int n, wxPoint points[])
 949         { m_pimpl->DrawSpline(n,points); }
 950
 951     void DrawSpline(wxList *points)
 952         { m_pimpl->DoDrawSpline(points); }
 953 #endif // wxUSE_SPLINES
 954
 955
 956 #if WXWIN_COMPATIBILITY_2_8
 957     // for compatibility with the old code when wxCoord was long everywhere
 958     wxDEPRECATED( void GetTextExtent(const wxString& string,
 959                        long *x, long *y,
 960                        long *descent = NULL,
 961                        long *externalLeading = NULL,
 962                        const wxFont *theFont = NULL) const );
 963     wxDEPRECATED( void GetLogicalOrigin(long *x, long *y) const );
 964     wxDEPRECATED( void GetDeviceOrigin(long *x, long *y) const );
 965     wxDEPRECATED( void GetClippingBox(long *x, long *y, long *w, long *h) const );
 966 #endif  // WXWIN_COMPATIBILITY_2_8
 967
 968
 969 protected:
 970     wxImplDC    *m_pimpl;
 971
 972 private:
 973     DECLARE_ABSTRACT_CLASS(wxImplDC)
 974 }
 975
 976
 977 #else  // wxUSE_NEW_DC
 978
 979
 980 class WXDLLIMPEXP_FWD_CORE wxDC;
 981 class WXDLLIMPEXP_FWD_CORE wxDCBase;
 982
 983 class WXDLLEXPORT wxDrawObject
 984 {
 985 public:
 986
 987     wxDrawObject()
 988         : m_isBBoxValid(false)
 989         , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
 990     { }
 991
 992     virtual ~wxDrawObject() { }
 993
 994     virtual void Draw(wxDCBase&) const { }
 995
 996     virtual void CalcBoundingBox(wxCoord x, wxCoord y)
 997     {
 998       if ( m_isBBoxValid )
 999       {
1000          if ( x < m_minX ) m_minX = x;
1001          if ( y < m_minY ) m_minY = y;
1002          if ( x > m_maxX ) m_maxX = x;
1003          if ( y > m_maxY ) m_maxY = y;
1004       }
1005       else
1006       {
1007          m_isBBoxValid = true;
1008
1009          m_minX = x;
1010          m_minY = y;
1011          m_maxX = x;
1012          m_maxY = y;
1013       }
1014     }
1015
1016     void ResetBoundingBox()
1017     {
1018         m_isBBoxValid = false;
1019
1020         m_minX = m_maxX = m_minY = m_maxY = 0;
1021     }
1022
1023     // Get the final bounding box of the PostScript or Metafile picture.
1024
1025     wxCoord MinX() const { return m_minX; }
1026     wxCoord MaxX() const { return m_maxX; }
1027     wxCoord MinY() const { return m_minY; }
1028     wxCoord MaxY() const { return m_maxY; }
1029
1030     //to define the type of object for derived objects
1031     virtual int GetType()=0;
1032
1033 protected:
1034     //for boundingbox calculation
1035     bool m_isBBoxValid:1;
1036     //for boundingbox calculation
1037     wxCoord m_minX, m_minY, m_maxX, m_maxY;
1038 };
1039
1040 // ---------------------------------------------------------------------------
1041 // global variables
1042 // ---------------------------------------------------------------------------
1043
1044 // ---------------------------------------------------------------------------
1045 // wxDC is the device context - object on which any drawing is done
1046 // ---------------------------------------------------------------------------
1047
1048 class WXDLLEXPORT wxDCBase : public wxObject
1049 {
1050 public:
1051     wxDCBase();
1052     virtual ~wxDCBase();
1053
1054     // graphic primitives
1055     // ------------------
1056
1057     virtual void DrawObject(wxDrawObject* drawobject)
1058     {
1059         drawobject->Draw(*this);
1060         CalcBoundingBox(drawobject->MinX(),drawobject->MinY());
1061         CalcBoundingBox(drawobject->MaxX(),drawobject->MaxY());
1062     }
1063
1064     bool FloodFill(wxCoord x, wxCoord y, const wxColour& col,
1065                    int style = wxFLOOD_SURFACE)
1066         { return DoFloodFill(x, y, col, style); }
1067     bool FloodFill(const wxPoint& pt, const wxColour& col,
1068                    int style = wxFLOOD_SURFACE)
1069         { return DoFloodFill(pt.x, pt.y, col, style); }
1070
1071     // fill the area specified by rect with a radial gradient, starting from
1072     // initialColour in the centre of the cercle and fading to destColour.
1073     void GradientFillConcentric(const wxRect& rect,
1074                                 const wxColour& initialColour,
1075                                 const wxColour& destColour)
1076         { GradientFillConcentric(rect, initialColour, destColour,
1077                                  wxPoint(rect.GetWidth() / 2,
1078                                          rect.GetHeight() / 2)); }
1079
1080     void GradientFillConcentric(const wxRect& rect,
1081                                 const wxColour& initialColour,
1082                                 const wxColour& destColour,
1083                                 const wxPoint& circleCenter)
1084         { DoGradientFillConcentric(rect, initialColour, destColour, circleCenter); }
1085
1086     // fill the area specified by rect with a linear gradient
1087     void GradientFillLinear(const wxRect& rect,
1088                             const wxColour& initialColour,
1089                             const wxColour& destColour,
1090                             wxDirection nDirection = wxEAST)
1091         { DoGradientFillLinear(rect, initialColour, destColour, nDirection); }
1092
1093     bool GetPixel(wxCoord x, wxCoord y, wxColour *col) const
1094         { return DoGetPixel(x, y, col); }
1095     bool GetPixel(const wxPoint& pt, wxColour *col) const
1096         { return DoGetPixel(pt.x, pt.y, col); }
1097
1098     void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
1099         { DoDrawLine(x1, y1, x2, y2); }
1100     void DrawLine(const wxPoint& pt1, const wxPoint& pt2)
1101         { DoDrawLine(pt1.x, pt1.y, pt2.x, pt2.y); }
1102
1103     void CrossHair(wxCoord x, wxCoord y)
1104         { DoCrossHair(x, y); }
1105     void CrossHair(const wxPoint& pt)
1106         { DoCrossHair(pt.x, pt.y); }
1107
1108     void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
1109                  wxCoord xc, wxCoord yc)
1110         { DoDrawArc(x1, y1, x2, y2, xc, yc); }
1111     void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre)
1112         { DoDrawArc(pt1.x, pt1.y, pt2.x, pt2.y, centre.x, centre.y); }
1113
1114     void DrawCheckMark(wxCoord x, wxCoord y,
1115                        wxCoord width, wxCoord height)
1116         { DoDrawCheckMark(x, y, width, height); }
1117     void DrawCheckMark(const wxRect& rect)
1118         { DoDrawCheckMark(rect.x, rect.y, rect.width, rect.height); }
1119
1120     void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
1121                          double sa, double ea)
1122         { DoDrawEllipticArc(x, y, w, h, sa, ea); }
1123     void DrawEllipticArc(const wxPoint& pt, const wxSize& sz,
1124                          double sa, double ea)
1125         { DoDrawEllipticArc(pt.x, pt.y, sz.x, sz.y, sa, ea); }
1126
1127     void DrawPoint(wxCoord x, wxCoord y)
1128         { DoDrawPoint(x, y); }
1129     void DrawPoint(const wxPoint& pt)
1130         { DoDrawPoint(pt.x, pt.y); }
1131
1132     void DrawLines(int n, wxPoint points[],
1133                    wxCoord xoffset = 0, wxCoord yoffset = 0)
1134         { DoDrawLines(n, points, xoffset, yoffset); }
1135     void DrawLines(const wxList *list,
1136                    wxCoord xoffset = 0, wxCoord yoffset = 0);
1137
1138     void DrawPolygon(int n, wxPoint points[],
1139                      wxCoord xoffset = 0, wxCoord yoffset = 0,
1140                      int fillStyle = wxODDEVEN_RULE)
1141         { DoDrawPolygon(n, points, xoffset, yoffset, fillStyle); }
1142
1143     void DrawPolygon(const wxList *list,
1144                      wxCoord xoffset = 0, wxCoord yoffset = 0,
1145                      int fillStyle = wxODDEVEN_RULE);
1146
1147     void DrawPolyPolygon(int n, int count[], wxPoint points[],
1148                          wxCoord xoffset = 0, wxCoord yoffset = 0,
1149                          int fillStyle = wxODDEVEN_RULE)
1150         { DoDrawPolyPolygon(n, count, points, xoffset, yoffset, fillStyle); }
1151
1152     void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1153         { DoDrawRectangle(x, y, width, height); }
1154     void DrawRectangle(const wxPoint& pt, const wxSize& sz)
1155         { DoDrawRectangle(pt.x, pt.y, sz.x, sz.y); }
1156     void DrawRectangle(const wxRect& rect)
1157         { DoDrawRectangle(rect.x, rect.y, rect.width, rect.height); }
1158
1159     void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height,
1160                               double radius)
1161         { DoDrawRoundedRectangle(x, y, width, height, radius); }
1162     void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz,
1163                              double radius)
1164         { DoDrawRoundedRectangle(pt.x, pt.y, sz.x, sz.y, radius); }
1165     void DrawRoundedRectangle(const wxRect& r, double radius)
1166         { DoDrawRoundedRectangle(r.x, r.y, r.width, r.height, radius); }
1167
1168     void DrawCircle(wxCoord x, wxCoord y, wxCoord radius)
1169         { DoDrawEllipse(x - radius, y - radius, 2*radius, 2*radius); }
1170     void DrawCircle(const wxPoint& pt, wxCoord radius)
1171         { DrawCircle(pt.x, pt.y, radius); }
1172
1173     void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1174         { DoDrawEllipse(x, y, width, height); }
1175     void DrawEllipse(const wxPoint& pt, const wxSize& sz)
1176         { DoDrawEllipse(pt.x, pt.y, sz.x, sz.y); }
1177     void DrawEllipse(const wxRect& rect)
1178         { DoDrawEllipse(rect.x, rect.y, rect.width, rect.height); }
1179
1180     void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
1181         { DoDrawIcon(icon, x, y); }
1182     void DrawIcon(const wxIcon& icon, const wxPoint& pt)
1183         { DoDrawIcon(icon, pt.x, pt.y); }
1184
1185     void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
1186                     bool useMask = false)
1187         { DoDrawBitmap(bmp, x, y, useMask); }
1188     void DrawBitmap(const wxBitmap &bmp, const wxPoint& pt,
1189                     bool useMask = false)
1190         { DoDrawBitmap(bmp, pt.x, pt.y, useMask); }
1191
1192     void DrawText(const wxString& text, wxCoord x, wxCoord y)
1193         { DoDrawText(text, x, y); }
1194     void DrawText(const wxString& text, const wxPoint& pt)
1195         { DoDrawText(text, pt.x, pt.y); }
1196
1197     void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle)
1198         { DoDrawRotatedText(text, x, y, angle); }
1199     void DrawRotatedText(const wxString& text, const wxPoint& pt, double angle)
1200         { DoDrawRotatedText(text, pt.x, pt.y, angle); }
1201
1202     // this version puts both optional bitmap and the text into the given
1203     // rectangle and aligns is as specified by alignment parameter; it also
1204     // will emphasize the character with the given index if it is != -1 and
1205     // return the bounding rectangle if required
1206     virtual void DrawLabel(const wxString& text,
1207                            const wxBitmap& image,
1208                            const wxRect& rect,
1209                            int alignment = wxALIGN_LEFT | wxALIGN_TOP,
1210                            int indexAccel = -1,
1211                            wxRect *rectBounding = NULL);
1212
1213     void DrawLabel(const wxString& text, const wxRect& rect,
1214                    int alignment = wxALIGN_LEFT | wxALIGN_TOP,
1215                    int indexAccel = -1)
1216         { DrawLabel(text, wxNullBitmap, rect, alignment, indexAccel); }
1217
1218     bool Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
1219               wxDC *source, wxCoord xsrc, wxCoord ysrc,
1220               int rop = wxCOPY, bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord)
1221     {
1222         return DoBlit(xdest, ydest, width, height,
1223                       source, xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask);
1224     }
1225     bool Blit(const wxPoint& destPt, const wxSize& sz,
1226               wxDC *source, const wxPoint& srcPt,
1227               int rop = wxCOPY, bool useMask = false, const wxPoint& srcPtMask = wxDefaultPosition)
1228     {
1229         return DoBlit(destPt.x, destPt.y, sz.x, sz.y,
1230                       source, srcPt.x, srcPt.y, rop, useMask, srcPtMask.x, srcPtMask.y);
1231     }
1232
1233     bool StretchBlit(wxCoord dstX, wxCoord dstY,
1234                      wxCoord dstWidth, wxCoord dstHeight,
1235                      wxDC *source,
1236                      wxCoord srcX, wxCoord srcY,
1237                      wxCoord srcWidth, wxCoord srcHeight,
1238                      int rop = wxCOPY, bool useMask = false,
1239                      wxCoord srcMaskX = wxDefaultCoord, wxCoord srcMaskY = wxDefaultCoord)
1240     {
1241         return DoStretchBlit(dstX, dstY, dstWidth, dstHeight,
1242                       source, srcX, srcY, srcWidth, srcHeight, rop, useMask, srcMaskX, srcMaskY);
1243     }
1244     bool StretchBlit(const wxPoint& dstPt, const wxSize& dstSize,
1245                      wxDC *source, const wxPoint& srcPt, const wxSize& srcSize,
1246                      int rop = wxCOPY, bool useMask = false, const wxPoint& srcMaskPt = wxDefaultPosition)
1247     {
1248         return DoStretchBlit(dstPt.x, dstPt.y, dstSize.x, dstSize.y,
1249                       source, srcPt.x, srcPt.y, srcSize.x, srcSize.y, rop, useMask, srcMaskPt.x, srcMaskPt.y);
1250     }
1251
1252     wxBitmap GetAsBitmap(const wxRect *subrect = (const wxRect *) NULL) const
1253     {
1254         return DoGetAsBitmap(subrect);
1255     }
1256
1257 #if wxUSE_SPLINES
1258     // TODO: this API needs fixing (wxPointList, why (!const) "wxList *"?)
1259     void DrawSpline(wxCoord x1, wxCoord y1,
1260                     wxCoord x2, wxCoord y2,
1261                     wxCoord x3, wxCoord y3);
1262     void DrawSpline(int n, wxPoint points[]);
1263
1264     void DrawSpline(wxList *points) { DoDrawSpline(points); }
1265 #endif // wxUSE_SPLINES
1266
1267     // Eventually we will have wxUSE_GENERIC_DRAWELLIPSE
1268 #ifdef __WXWINCE__
1269     //! Generic method to draw ellipses, circles and arcs with current pen and brush.
1270     /*! \param x Upper left corner of bounding box.
1271      *  \param y Upper left corner of bounding box.
1272      *  \param w Width of bounding box.
1273      *  \param h Height of bounding box.
1274      *  \param sa Starting angle of arc
1275      *            (counterclockwise, start at 3 o'clock, 360 is full circle).
1276      *  \param ea Ending angle of arc.
1277      *  \param angle Rotation angle, the Arc will be rotated after
1278      *               calculating begin and end.
1279      */
1280     void DrawEllipticArcRot( wxCoord x, wxCoord y,
1281                              wxCoord width, wxCoord height,
1282                              double sa = 0, double ea = 0, double angle = 0 )
1283     { DoDrawEllipticArcRot( x, y, width, height, sa, ea, angle ); }
1284
1285     void DrawEllipticArcRot( const wxPoint& pt,
1286                              const wxSize& sz,
1287                              double sa = 0, double ea = 0, double angle = 0 )
1288     { DoDrawEllipticArcRot( pt.x, pt.y, sz.x, sz.y, sa, ea, angle ); }
1289
1290     void DrawEllipticArcRot( const wxRect& rect,
1291                              double sa = 0, double ea = 0, double angle = 0 )
1292     { DoDrawEllipticArcRot( rect.x, rect.y, rect.width, rect.height, sa, ea, angle ); }
1293
1294     virtual void DoDrawEllipticArcRot( wxCoord x, wxCoord y,
1295                                        wxCoord w, wxCoord h,
1296                                        double sa = 0, double ea = 0, double angle = 0 );
1297
1298     //! Rotates points around center.
1299     /*! This is a quite straight method, it calculates in pixels
1300      *  and so it produces rounding errors.
1301      *  \param points The points inside will be rotated.
1302      *  \param angle Rotating angle (counterclockwise, start at 3 o'clock, 360 is full circle).
1303      *  \param center Center of rotation.
1304      */
1305     void Rotate( wxList* points, double angle, wxPoint center = wxPoint(0,0) );
1306
1307     // used by DrawEllipticArcRot
1308     // Careful: wxList gets filled with points you have to delete later.
1309     void CalculateEllipticPoints( wxList* points,
1310                                   wxCoord xStart, wxCoord yStart,
1311                                   wxCoord w, wxCoord h,
1312                                   double sa, double ea );
1313 #endif
1314
1315     // global DC operations
1316     // --------------------
1317
1318     virtual void Clear() = 0;
1319
1320     virtual bool StartDoc(const wxString& WXUNUSED(message)) { return true; }
1321     virtual void EndDoc() { }
1322
1323     virtual void StartPage() { }
1324     virtual void EndPage() { }
1325
1326 #if WXWIN_COMPATIBILITY_2_6
1327     wxDEPRECATED( void BeginDrawing() );
1328     wxDEPRECATED( void EndDrawing() );
1329 #endif // WXWIN_COMPATIBILITY_2_6
1330
1331
1332     // set objects to use for drawing
1333     // ------------------------------
1334
1335     virtual void SetFont(const wxFont& font) = 0;
1336     virtual void SetPen(const wxPen& pen) = 0;
1337     virtual void SetBrush(const wxBrush& brush) = 0;
1338     virtual void SetBackground(const wxBrush& brush) = 0;
1339     virtual void SetBackgroundMode(int mode) = 0;
1340 #if wxUSE_PALETTE
1341     virtual void SetPalette(const wxPalette& palette) = 0;
1342 #endif // wxUSE_PALETTE
1343
1344     // clipping region
1345     // ---------------
1346
1347     void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1348         { DoSetClippingRegion(x, y, width, height); }
1349     void SetClippingRegion(const wxPoint& pt, const wxSize& sz)
1350         { DoSetClippingRegion(pt.x, pt.y, sz.x, sz.y); }
1351     void SetClippingRegion(const wxRect& rect)
1352         { DoSetClippingRegion(rect.x, rect.y, rect.width, rect.height); }
1353     void SetClippingRegion(const wxRegion& region)
1354         { DoSetClippingRegionAsRegion(region); }
1355
1356     virtual void DestroyClippingRegion() { ResetClipping(); }
1357
1358     void GetClippingBox(wxCoord *x, wxCoord *y, wxCoord *w, wxCoord *h) const
1359         { DoGetClippingBox(x, y, w, h); }
1360     void GetClippingBox(wxRect& rect) const
1361         {
1362           DoGetClippingBox(&rect.x, &rect.y, &rect.width, &rect.height);
1363         }
1364
1365     // text extent
1366     // -----------
1367
1368     virtual wxCoord GetCharHeight() const = 0;
1369     virtual wxCoord GetCharWidth() const = 0;
1370
1371     // only works for single line strings
1372     void GetTextExtent(const wxString& string,
1373                        wxCoord *x, wxCoord *y,
1374                        wxCoord *descent = NULL,
1375                        wxCoord *externalLeading = NULL,
1376                        const wxFont *theFont = NULL) const
1377         { DoGetTextExtent(string, x, y, descent, externalLeading, theFont); }
1378
1379     wxSize GetTextExtent(const wxString& string) const
1380     {
1381         wxCoord w, h;
1382         DoGetTextExtent(string, &w, &h);
1383         return wxSize(w, h);
1384     }
1385
1386     // works for single as well as multi-line strings
1387     virtual void GetMultiLineTextExtent(const wxString& string,
1388                                         wxCoord *width,
1389                                         wxCoord *height,
1390                                         wxCoord *heightLine = NULL,
1391                                         const wxFont *font = NULL) const;
1392
1393     wxSize GetMultiLineTextExtent(const wxString& string) const
1394     {
1395         wxCoord w, h;
1396         GetMultiLineTextExtent(string, &w, &h);
1397         return wxSize(w, h);
1398     }
1399
1400     // Measure cumulative width of text after each character
1401     bool GetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
1402         { return DoGetPartialTextExtents(text, widths); }
1403
1404
1405     // size and resolution
1406     // -------------------
1407
1408     // in device units
1409     void GetSize(int *width, int *height) const
1410         { DoGetSize(width, height); }
1411     wxSize GetSize() const
1412     {
1413         int w, h;
1414         DoGetSize(&w, &h);
1415
1416         return wxSize(w, h);
1417     }
1418
1419     // in mm
1420     void GetSizeMM(int* width, int* height) const
1421         { DoGetSizeMM(width, height); }
1422     wxSize GetSizeMM() const
1423     {
1424         int w, h;
1425         DoGetSizeMM(&w, &h);
1426
1427         return wxSize(w, h);
1428     }
1429
1430     // query DC capabilities
1431     // ---------------------
1432
1433     virtual bool CanDrawBitmap() const = 0;
1434     virtual bool CanGetTextExtent() const = 0;
1435
1436     // colour depth
1437     virtual int GetDepth() const = 0;
1438
1439     // Resolution in Pixels per inch
1440     virtual wxSize GetPPI() const = 0;
1441
1442     virtual bool Ok() const { return IsOk(); }
1443     virtual bool IsOk() const { return m_ok; }
1444
1445     // accessors and setters
1446     // ---------------------
1447
1448     virtual int GetBackgroundMode() const { return m_backgroundMode; }
1449     virtual const wxBrush&  GetBackground() const { return m_backgroundBrush; }
1450     virtual const wxBrush&  GetBrush() const { return m_brush; }
1451     virtual const wxFont&   GetFont() const { return m_font; }
1452     virtual const wxPen&    GetPen() const { return m_pen; }
1453
1454     virtual const wxColour& GetTextForeground() const { return m_textForegroundColour; }
1455     virtual const wxColour& GetTextBackground() const { return m_textBackgroundColour; }
1456     virtual void SetTextForeground(const wxColour& colour)
1457         { m_textForegroundColour = colour; }
1458     virtual void SetTextBackground(const wxColour& colour)
1459         { m_textBackgroundColour = colour; }
1460
1461
1462     // coordinates conversions and transforms
1463     // --------------------------------------
1464
1465     virtual wxCoord DeviceToLogicalX(wxCoord x) const;
1466     virtual wxCoord DeviceToLogicalY(wxCoord y) const;
1467     virtual wxCoord DeviceToLogicalXRel(wxCoord x) const;
1468     virtual wxCoord DeviceToLogicalYRel(wxCoord y) const;
1469     virtual wxCoord LogicalToDeviceX(wxCoord x) const;
1470     virtual wxCoord LogicalToDeviceY(wxCoord y) const;
1471     virtual wxCoord LogicalToDeviceXRel(wxCoord x) const;
1472     virtual wxCoord LogicalToDeviceYRel(wxCoord y) const;
1473
1474     virtual void SetMapMode(int mode);
1475     virtual int GetMapMode() const { return m_mappingMode; }
1476
1477     virtual void SetUserScale(double x, double y);
1478     virtual void GetUserScale(double *x, double *y) const
1479     {
1480         if ( x ) *x = m_userScaleX;
1481         if ( y ) *y = m_userScaleY;
1482     }
1483
1484     virtual void SetLogicalScale(double x, double y);
1485     virtual void GetLogicalScale(double *x, double *y)
1486     {
1487         if ( x ) *x = m_logicalScaleX;
1488         if ( y ) *y = m_logicalScaleY;
1489     }
1490
1491     virtual void SetLogicalOrigin(wxCoord x, wxCoord y);
1492     void GetLogicalOrigin(wxCoord *x, wxCoord *y) const
1493         { DoGetLogicalOrigin(x, y); }
1494     wxPoint GetLogicalOrigin() const
1495         { wxCoord x, y; DoGetLogicalOrigin(&x, &y); return wxPoint(x, y); }
1496
1497     virtual void SetDeviceOrigin(wxCoord x, wxCoord y);
1498     void GetDeviceOrigin(wxCoord *x, wxCoord *y) const
1499         { DoGetDeviceOrigin(x, y); }
1500     wxPoint GetDeviceOrigin() const
1501         { wxCoord x, y; DoGetDeviceOrigin(&x, &y); return wxPoint(x, y); }
1502
1503     virtual void SetDeviceLocalOrigin( wxCoord x, wxCoord y );
1504
1505     virtual void ComputeScaleAndOrigin();
1506
1507     // this needs to overidden if the axis is inverted (such
1508     // as when using Postscript, where 0,0 is the lower left
1509     // corner, not the upper left).
1510     virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp);
1511
1512     // logical functions
1513     // ---------------------------
1514
1515     virtual int GetLogicalFunction() const { return m_logicalFunction; }
1516     virtual void SetLogicalFunction(int function) = 0;
1517
1518     // bounding box
1519     // ------------
1520
1521     virtual void CalcBoundingBox(wxCoord x, wxCoord y)
1522     {
1523       if ( m_isBBoxValid )
1524       {
1525          if ( x < m_minX ) m_minX = x;
1526          if ( y < m_minY ) m_minY = y;
1527          if ( x > m_maxX ) m_maxX = x;
1528          if ( y > m_maxY ) m_maxY = y;
1529       }
1530       else
1531       {
1532          m_isBBoxValid = true;
1533
1534          m_minX = x;
1535          m_minY = y;
1536          m_maxX = x;
1537          m_maxY = y;
1538       }
1539     }
1540
1541     void ResetBoundingBox()
1542     {
1543         m_isBBoxValid = false;
1544
1545         m_minX = m_maxX = m_minY = m_maxY = 0;
1546     }
1547
1548     // Get the final bounding box of the PostScript or Metafile picture.
1549     wxCoord MinX() const { return m_minX; }
1550     wxCoord MaxX() const { return m_maxX; }
1551     wxCoord MinY() const { return m_minY; }
1552     wxCoord MaxY() const { return m_maxY; }
1553
1554     // misc old functions
1555     // ------------------
1556
1557 #if WXWIN_COMPATIBILITY_2_8
1558     // for compatibility with the old code when wxCoord was long everywhere
1559     wxDEPRECATED( void GetTextExtent(const wxString& string,
1560                        long *x, long *y,
1561                        long *descent = NULL,
1562                        long *externalLeading = NULL,
1563                        const wxFont *theFont = NULL) const );
1564     wxDEPRECATED( void GetLogicalOrigin(long *x, long *y) const );
1565     wxDEPRECATED( void GetDeviceOrigin(long *x, long *y) const );
1566     wxDEPRECATED( void GetClippingBox(long *x, long *y, long *w, long *h) const );
1567 #endif  // WXWIN_COMPATIBILITY_2_8
1568
1569     // RTL related functions
1570     // ---------------------
1571
1572     // get or change the layout direction (LTR or RTL) for this dc,
1573     // wxLayout_Default is returned if layout direction is not supported
1574     virtual wxLayoutDirection GetLayoutDirection() const
1575         { return wxLayout_Default; }
1576     virtual void SetLayoutDirection(wxLayoutDirection WXUNUSED(dir))
1577         { }
1578
1579 protected:
1580     // the pure virtual functions which should be implemented by wxDC
1581     virtual bool DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,
1582                              int style = wxFLOOD_SURFACE) = 0;
1583
1584     virtual void DoGradientFillLinear(const wxRect& rect,
1585                                       const wxColour& initialColour,
1586                                       const wxColour& destColour,
1587                                       wxDirection nDirection = wxEAST);
1588
1589     virtual void DoGradientFillConcentric(const wxRect& rect,
1590                                         const wxColour& initialColour,
1591                                         const wxColour& destColour,
1592                                         const wxPoint& circleCenter);
1593
1594     virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const = 0;
1595
1596     virtual void DoDrawPoint(wxCoord x, wxCoord y) = 0;
1597     virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2) = 0;
1598
1599     virtual void DoDrawArc(wxCoord x1, wxCoord y1,
1600                            wxCoord x2, wxCoord y2,
1601                            wxCoord xc, wxCoord yc) = 0;
1602     virtual void DoDrawCheckMark(wxCoord x, wxCoord y,
1603                                  wxCoord width, wxCoord height);
1604     virtual void DoDrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
1605                                    double sa, double ea) = 0;
1606
1607     virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height) = 0;
1608     virtual void DoDrawRoundedRectangle(wxCoord x, wxCoord y,
1609                                         wxCoord width, wxCoord height,
1610                                         double radius) = 0;
1611     virtual void DoDrawEllipse(wxCoord x, wxCoord y,
1612                                wxCoord width, wxCoord height) = 0;
1613
1614     virtual void DoCrossHair(wxCoord x, wxCoord y) = 0;
1615
1616     virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y) = 0;
1617     virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
1618                               bool useMask = false) = 0;
1619
1620     virtual void DoDrawText(const wxString& text, wxCoord x, wxCoord y) = 0;
1621     virtual void DoDrawRotatedText(const wxString& text,
1622                                    wxCoord x, wxCoord y, double angle) = 0;
1623
1624     virtual bool DoBlit(wxCoord xdest, wxCoord ydest,
1625                         wxCoord width, wxCoord height,
1626                         wxDC *source,
1627                         wxCoord xsrc, wxCoord ysrc,
1628                         int rop = wxCOPY,
1629                         bool useMask = false,
1630                         wxCoord xsrcMask = wxDefaultCoord,
1631                         wxCoord ysrcMask = wxDefaultCoord) = 0;
1632
1633     virtual bool DoStretchBlit(wxCoord xdest, wxCoord ydest,
1634                                wxCoord dstWidth, wxCoord dstHeight,
1635                                wxDC *source,
1636                                wxCoord xsrc, wxCoord ysrc,
1637                                wxCoord srcWidth, wxCoord srcHeight,
1638                                int rop = wxCOPY,
1639                                bool useMask = false,
1640                                wxCoord xsrcMask = wxDefaultCoord,
1641                                wxCoord ysrcMask = wxDefaultCoord);
1642
1643     virtual wxBitmap DoGetAsBitmap(const wxRect *WXUNUSED(subrect)) const
1644         { return wxNullBitmap; }
1645
1646     virtual void DoGetSize(int *width, int *height) const = 0;
1647     virtual void DoGetSizeMM(int* width, int* height) const = 0;
1648
1649     virtual void DoDrawLines(int n, wxPoint points[],
1650                              wxCoord xoffset, wxCoord yoffset) = 0;
1651     virtual void DoDrawPolygon(int n, wxPoint points[],
1652                                wxCoord xoffset, wxCoord yoffset,
1653                                int fillStyle = wxODDEVEN_RULE) = 0;
1654     virtual void DoDrawPolyPolygon(int n, int count[], wxPoint points[],
1655                                wxCoord xoffset, wxCoord yoffset,
1656                                int fillStyle);
1657
1658     virtual void DoSetClippingRegionAsRegion(const wxRegion& region) = 0;
1659     virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
1660                                      wxCoord width, wxCoord height) = 0;
1661
1662     virtual void DoGetClippingBox(wxCoord *x, wxCoord *y,
1663                                   wxCoord *w, wxCoord *h) const
1664     {
1665         if ( x )
1666             *x = m_clipX1;
1667         if ( y )
1668             *y = m_clipY1;
1669         if ( w )
1670             *w = m_clipX2 - m_clipX1;
1671         if ( h )
1672             *h = m_clipY2 - m_clipY1;
1673     }
1674
1675     virtual void DoGetLogicalOrigin(wxCoord *x, wxCoord *y) const
1676     {
1677         if ( x ) *x = m_logicalOriginX;
1678         if ( y ) *y = m_logicalOriginY;
1679     }
1680
1681     virtual void DoGetDeviceOrigin(wxCoord *x, wxCoord *y) const
1682     {
1683         if ( x ) *x = m_deviceOriginX;
1684         if ( y ) *y = m_deviceOriginY;
1685     }
1686
1687     virtual void DoGetTextExtent(const wxString& string,
1688                                  wxCoord *x, wxCoord *y,
1689                                  wxCoord *descent = NULL,
1690                                  wxCoord *externalLeading = NULL,
1691                                  const wxFont *theFont = NULL) const = 0;
1692
1693     virtual bool DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const;
1694
1695 #if wxUSE_SPLINES
1696     virtual void DoDrawSpline(wxList *points);
1697 #endif
1698
1699 protected:
1700     // unset clipping variables (after clipping region was destroyed)
1701     void ResetClipping()
1702     {
1703         m_clipping = false;
1704
1705         m_clipX1 = m_clipX2 = m_clipY1 = m_clipY2 = 0;
1706     }
1707
1708     // flags
1709     bool m_colour:1;
1710     bool m_ok:1;
1711     bool m_clipping:1;
1712     bool m_isInteractive:1;
1713     bool m_isBBoxValid:1;
1714
1715     // coordinate system variables
1716
1717     // TODO short descriptions of what exactly they are would be nice...
1718
1719     wxCoord m_logicalOriginX, m_logicalOriginY;
1720     wxCoord m_deviceOriginX, m_deviceOriginY;           // Usually 0,0, can be change by user
1721
1722     wxCoord m_deviceLocalOriginX, m_deviceLocalOriginY; // non-zero if native top-left corner
1723                                                         // is not at 0,0. This was the case under
1724                                                         // Mac's GrafPorts (coordinate system
1725                                                         // used toplevel window's origin) and
1726                                                         // e.g. for Postscript, where the native
1727                                                         // origin in the bottom left corner.
1728     double m_logicalScaleX, m_logicalScaleY;
1729     double m_userScaleX, m_userScaleY;
1730     double m_scaleX, m_scaleY;  // calculated from logical scale and user scale
1731
1732     // Used by SetAxisOrientation() to invert the axes
1733     int m_signX, m_signY;
1734
1735     // what is a mm on a screen you don't know the size of?
1736     double       m_mm_to_pix_x,
1737                  m_mm_to_pix_y;
1738
1739     // bounding and clipping boxes
1740     wxCoord m_minX, m_minY, m_maxX, m_maxY;
1741     wxCoord m_clipX1, m_clipY1, m_clipX2, m_clipY2;
1742
1743     int m_logicalFunction;
1744     int m_backgroundMode;
1745     int m_mappingMode;
1746
1747     // GDI objects
1748     wxPen             m_pen;
1749     wxBrush           m_brush;
1750     wxBrush           m_backgroundBrush;
1751     wxColour          m_textForegroundColour;
1752     wxColour          m_textBackgroundColour;
1753     wxFont            m_font;
1754
1755 #if wxUSE_PALETTE
1756     wxPalette         m_palette;
1757     bool              m_hasCustomPalette;
1758 #endif // wxUSE_PALETTE
1759
1760 private:
1761     DECLARE_NO_COPY_CLASS(wxDCBase)
1762     DECLARE_ABSTRACT_CLASS(wxDCBase)
1763 };
1764
1765 #endif // wxUSE_NEW_DC
1766
1767 // ----------------------------------------------------------------------------
1768 // now include the declaration of wxDC class
1769 // ----------------------------------------------------------------------------
1770
1771 #if defined(__WXPALMOS__)
1772     #include "wx/palmos/dc.h"
1773 #elif defined(__WXMSW__)
1774     #include "wx/msw/dc.h"
1775 #elif defined(__WXMOTIF__)
1776     #include "wx/motif/dc.h"
1777 #elif defined(__WXGTK20__)
1778     #include "wx/gtk/dc.h"
1779 #elif defined(__WXGTK__)
1780     #include "wx/gtk1/dc.h"
1781 #elif defined(__WXX11__)
1782     #include "wx/x11/dc.h"
1783 #elif defined(__WXMGL__)
1784     #include "wx/mgl/dc.h"
1785 #elif defined(__WXDFB__)
1786     #include "wx/dfb/dc.h"
1787 #elif defined(__WXMAC__)
1788     #include "wx/mac/dc.h"
1789 #elif defined(__WXCOCOA__)
1790     #include "wx/cocoa/dc.h"
1791 #elif defined(__WXPM__)
1792     #include "wx/os2/dc.h"
1793 #endif
1794
1795 #if wxUSE_GRAPHICS_CONTEXT
1796     #include "wx/dcgraph.h"
1797 #endif
1798
1799 // ----------------------------------------------------------------------------
1800 // helper class: you can use it to temporarily change the DC text colour and
1801 // restore it automatically when the object goes out of scope
1802 // ----------------------------------------------------------------------------
1803
1804 class WXDLLEXPORT wxDCTextColourChanger
1805 {
1806 public:
1807     wxDCTextColourChanger(wxDC& dc) : m_dc(dc), m_colFgOld() { }
1808
1809     wxDCTextColourChanger(wxDC& dc, const wxColour& col) : m_dc(dc)
1810     {
1811         Set(col);
1812     }
1813
1814     ~wxDCTextColourChanger()
1815     {
1816         if ( m_colFgOld.Ok() )
1817             m_dc.SetTextForeground(m_colFgOld);
1818     }
1819
1820     void Set(const wxColour& col)
1821     {
1822         if ( !m_colFgOld.Ok() )
1823             m_colFgOld = m_dc.GetTextForeground();
1824         m_dc.SetTextForeground(col);
1825     }
1826
1827 private:
1828     wxDC& m_dc;
1829
1830     wxColour m_colFgOld;
1831
1832     DECLARE_NO_COPY_CLASS(wxDCTextColourChanger)
1833 };
1834
1835 // ----------------------------------------------------------------------------
1836 // helper class: you can use it to temporarily change the DC pen and
1837 // restore it automatically when the object goes out of scope
1838 // ----------------------------------------------------------------------------
1839
1840 class WXDLLEXPORT wxDCPenChanger
1841 {
1842 public:
1843     wxDCPenChanger(wxDC& dc, const wxPen& pen) : m_dc(dc), m_penOld(dc.GetPen())
1844     {
1845         m_dc.SetPen(pen);
1846     }
1847
1848     ~wxDCPenChanger()
1849     {
1850         if ( m_penOld.Ok() )
1851             m_dc.SetPen(m_penOld);
1852     }
1853
1854 private:
1855     wxDC& m_dc;
1856
1857     wxPen m_penOld;
1858
1859     DECLARE_NO_COPY_CLASS(wxDCPenChanger)
1860 };
1861
1862 // ----------------------------------------------------------------------------
1863 // helper class: you can use it to temporarily change the DC brush and
1864 // restore it automatically when the object goes out of scope
1865 // ----------------------------------------------------------------------------
1866
1867 class WXDLLEXPORT wxDCBrushChanger
1868 {
1869 public:
1870     wxDCBrushChanger(wxDC& dc, const wxBrush& brush) : m_dc(dc), m_brushOld(dc.GetBrush())
1871     {
1872         m_dc.SetBrush(brush);
1873     }
1874
1875     ~wxDCBrushChanger()
1876     {
1877         if ( m_brushOld.Ok() )
1878             m_dc.SetBrush(m_brushOld);
1879     }
1880
1881 private:
1882     wxDC& m_dc;
1883
1884     wxBrush m_brushOld;
1885
1886     DECLARE_NO_COPY_CLASS(wxDCBrushChanger)
1887 };
1888
1889 // ----------------------------------------------------------------------------
1890 // another small helper class: sets the clipping region in its ctor and
1891 // destroys it in the dtor
1892 // ----------------------------------------------------------------------------
1893
1894 class WXDLLEXPORT wxDCClipper
1895 {
1896 public:
1897     wxDCClipper(wxDC& dc, const wxRegion& r) : m_dc(dc)
1898         { dc.SetClippingRegion(r); }
1899     wxDCClipper(wxDC& dc, const wxRect& r) : m_dc(dc)
1900         { dc.SetClippingRegion(r.x, r.y, r.width, r.height); }
1901     wxDCClipper(wxDC& dc, wxCoord x, wxCoord y, wxCoord w, wxCoord h) : m_dc(dc)
1902         { dc.SetClippingRegion(x, y, w, h); }
1903
1904     ~wxDCClipper() { m_dc.DestroyClippingRegion(); }
1905
1906 private:
1907     wxDC& m_dc;
1908
1909     DECLARE_NO_COPY_CLASS(wxDCClipper)
1910 };
1911
1912 #endif // _WX_DC_H_BASE_