wxPython/include/wx/wxPython/pseudodc.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        pseudodc.h
   3 // Purpose:     wxPseudoDC class
   4 // Author:      Paul Lanier
   5 // Modified by:
   6 // Created:     05/25/06
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) wxWidgets team
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11 #ifndef _WX_PSUEDO_DC_H_BASE_
  12 #define _WX_PSUEDO_DC_H_BASE_
  13
  14 #include "wx/wx.h"
  15 #include "wx/dc.h"
  16
  17 //----------------------------------------------------------------------------
  18 // Base class for all pdcOp classes
  19 //----------------------------------------------------------------------------
  20 class pdcOp
  21 {
  22     public:
  23         // Constructor and Destructor
  24         pdcOp() {}
  25         virtual ~pdcOp() {}
  26
  27         // Virtual Drawing Methods
  28         virtual void DrawToDC(wxDC *dc)=0;
  29         virtual void Translate(wxCoord WXUNUSED(dx), wxCoord WXUNUSED(dy)) {}
  30 };
  31
  32 //----------------------------------------------------------------------------
  33 // declare a list class for list of pdcOps
  34 //----------------------------------------------------------------------------
  35 WX_DECLARE_LIST(pdcOp, pdcOpList);
  36
  37 //----------------------------------------------------------------------------
  38 // Classes derived from pdcOp
  39 // There is one class for each method mirrored from wxDC to wxPseudoDC
  40 //----------------------------------------------------------------------------
  41 class pdcSetFontOp : public pdcOp
  42 {
  43     public:
  44         pdcSetFontOp(const wxFont& font)
  45             {m_font=font;}
  46         virtual void DrawToDC(wxDC *dc) {dc->SetFont(m_font);}
  47     protected:
  48         wxFont m_font;
  49 };
  50
  51 class pdcSetBrushOp : public pdcOp
  52 {
  53     public:
  54         pdcSetBrushOp(const wxBrush& brush)
  55             {m_brush=brush;}
  56         virtual void DrawToDC(wxDC *dc) {dc->SetBrush(m_brush);}
  57     protected:
  58         wxBrush m_brush;
  59 };
  60
  61 class pdcSetBackgroundOp : public pdcOp
  62 {
  63     public:
  64         pdcSetBackgroundOp(const wxBrush& brush)
  65             {m_brush=brush;}
  66         virtual void DrawToDC(wxDC *dc) {dc->SetBackground(m_brush);}
  67     protected:
  68         wxBrush m_brush;
  69 };
  70
  71 class pdcSetPenOp : public pdcOp
  72 {
  73     public:
  74         pdcSetPenOp(const wxPen& pen)
  75             {m_pen=pen;}
  76         virtual void DrawToDC(wxDC *dc) {dc->SetPen(m_pen);}
  77     protected:
  78         wxPen m_pen;
  79 };
  80
  81 class pdcSetTextBackgroundOp : public pdcOp
  82 {
  83     public:
  84         pdcSetTextBackgroundOp(const wxColour& colour)
  85             {m_colour=colour;}
  86         virtual void DrawToDC(wxDC *dc) {dc->SetTextBackground(m_colour);}
  87     protected:
  88         wxColour m_colour;
  89 };
  90
  91 class pdcSetTextForegroundOp : public pdcOp
  92 {
  93     public:
  94         pdcSetTextForegroundOp(const wxColour& colour)
  95             {m_colour=colour;}
  96         virtual void DrawToDC(wxDC *dc) {dc->SetTextForeground(m_colour);}
  97     protected:
  98         wxColour m_colour;
  99 };
 100
 101 class pdcDrawRectangleOp : public pdcOp
 102 {
 103     public:
 104         pdcDrawRectangleOp(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
 105             {m_x=x; m_y=y; m_w=w; m_h=h;}
 106         virtual void DrawToDC(wxDC *dc) {dc->DrawRectangle(m_x,m_y,m_w,m_h);}
 107         virtual void Translate(wxCoord dx, wxCoord dy)
 108             {m_x+=dx;m_y+=dy;}
 109     protected:
 110         wxCoord m_x,m_y,m_w,m_h;
 111 };
 112
 113 class pdcDrawLineOp : public pdcOp
 114 {
 115     public:
 116         pdcDrawLineOp(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
 117             {m_x1=x1; m_y1=y1; m_x2=x2; m_y2=y2;}
 118         virtual void DrawToDC(wxDC *dc) {dc->DrawLine(m_x1,m_y1,m_x2,m_y2);}
 119         virtual void Translate(wxCoord dx, wxCoord dy)
 120             {m_x1+=dx; m_y1+=dy; m_x2+=dx; m_y2+=dy;}
 121     protected:
 122         wxCoord m_x1,m_y1,m_x2,m_y2;
 123 };
 124
 125 class pdcSetBackgroundModeOp : public pdcOp
 126 {
 127     public:
 128         pdcSetBackgroundModeOp(int mode) {m_mode=mode;}
 129         virtual void DrawToDC(wxDC *dc) {dc->SetBackgroundMode(m_mode);}
 130     protected:
 131         int m_mode;
 132 };
 133
 134 class pdcDrawTextOp : public pdcOp
 135 {
 136     public:
 137         pdcDrawTextOp(const wxString& text, wxCoord x, wxCoord y)
 138             {m_text=text; m_x=x; m_y=y;}
 139         virtual void DrawToDC(wxDC *dc) {dc->DrawText(m_text, m_x, m_y);}
 140         virtual void Translate(wxCoord dx, wxCoord dy)
 141             {m_x+=dx; m_y+=dy;}
 142     protected:
 143         wxString m_text;
 144         wxCoord m_x, m_y;
 145 };
 146
 147 class pdcClearOp : public pdcOp
 148 {
 149     public:
 150         pdcClearOp() {}
 151         virtual void DrawToDC(wxDC *dc) {dc->Clear();}
 152 };
 153
 154 class pdcBeginDrawingOp : public pdcOp
 155 {
 156     public:
 157         pdcBeginDrawingOp() {}
 158         virtual void DrawToDC(wxDC *dc) {dc->BeginDrawing();}
 159 };
 160
 161 class pdcEndDrawingOp : public pdcOp
 162 {
 163     public:
 164         pdcEndDrawingOp() {}
 165         virtual void DrawToDC(wxDC *dc) {dc->EndDrawing();}
 166 };
 167
 168 class pdcFloodFillOp : public pdcOp
 169 {
 170     public:
 171         pdcFloodFillOp(wxCoord x, wxCoord y, const wxColour& col,
 172                    int style) {m_x=x; m_y=y; m_col=col; m_style=style;}
 173         virtual void DrawToDC(wxDC *dc) {dc->FloodFill(m_x,m_y,m_col,m_style);}
 174         virtual void Translate(wxCoord dx, wxCoord dy)
 175             {m_x+=dx; m_y+=dy;}
 176     protected:
 177         wxCoord m_x,m_y;
 178         wxColour m_col;
 179         int m_style;
 180 };
 181
 182 class pdcCrossHairOp : public pdcOp
 183 {
 184     public:
 185         pdcCrossHairOp(wxCoord x, wxCoord y) {m_x=x; m_y=y;}
 186         virtual void DrawToDC(wxDC *dc) {dc->CrossHair(m_x,m_y);}
 187         virtual void Translate(wxCoord dx, wxCoord dy)
 188             {m_x+=dx; m_y+=dy;}
 189     protected:
 190         wxCoord m_x,m_y;
 191 };
 192
 193 class pdcDrawArcOp : public pdcOp
 194 {
 195     public:
 196         pdcDrawArcOp(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
 197                          wxCoord xc, wxCoord yc)
 198             {m_x1=x1; m_y1=y1; m_x2=x2; m_y2=y2; m_xc=xc; m_yc=yc;}
 199         virtual void DrawToDC(wxDC *dc)
 200             {dc->DrawArc(m_x1,m_y1,m_x2,m_y2,m_xc,m_yc);}
 201         virtual void Translate(wxCoord dx, wxCoord dy)
 202             {m_x1+=dx; m_x2+=dx; m_y1+=dy; m_y2+=dy;}
 203     protected:
 204         wxCoord m_x1,m_x2,m_xc;
 205         wxCoord m_y1,m_y2,m_yc;
 206 };
 207
 208 class pdcDrawCheckMarkOp : public pdcOp
 209 {
 210     public:
 211         pdcDrawCheckMarkOp(wxCoord x, wxCoord y,
 212                        wxCoord width, wxCoord height)
 213             {m_x=x; m_y=y; m_w=width; m_h=height;}
 214         virtual void DrawToDC(wxDC *dc)
 215             {dc->DrawCheckMark(m_x,m_y,m_w,m_h);}
 216         virtual void Translate(wxCoord dx, wxCoord dy)
 217             {m_x+=dx; m_y+=dy;}
 218     protected:
 219         wxCoord m_x,m_y,m_w,m_h;
 220 };
 221
 222 class pdcDrawEllipticArcOp : public pdcOp
 223 {
 224     public:
 225         pdcDrawEllipticArcOp(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
 226                          double sa, double ea)
 227             {m_x=x; m_y=y; m_w=w; m_h=h; m_sa=sa; m_ea=ea;}
 228         virtual void DrawToDC(wxDC *dc)
 229             {dc->DrawEllipticArc(m_x,m_y,m_w,m_h,m_sa,m_ea);}
 230         virtual void Translate(wxCoord dx, wxCoord dy)
 231             {m_x+=dx; m_y+=dy;}
 232     protected:
 233         wxCoord m_x,m_y,m_w,m_h;
 234         double m_sa,m_ea;
 235 };
 236
 237 class pdcDrawPointOp : public pdcOp
 238 {
 239     public:
 240         pdcDrawPointOp(wxCoord x, wxCoord y)
 241             {m_x=x; m_y=y;}
 242         virtual void DrawToDC(wxDC *dc) {dc->DrawPoint(m_x,m_y);}
 243         virtual void Translate(wxCoord dx, wxCoord dy)
 244             {m_x+=dx; m_y+=dy;}
 245     protected:
 246         wxCoord m_x,m_y;
 247 };
 248
 249 class pdcDrawRoundedRectangleOp : public pdcOp
 250 {
 251     public:
 252         pdcDrawRoundedRectangleOp(wxCoord x, wxCoord y, wxCoord width,
 253                                   wxCoord height, double radius)
 254             {m_x=x; m_y=y; m_w=width; m_h=height; m_r=radius;}
 255         virtual void DrawToDC(wxDC *dc)
 256             {dc->DrawRoundedRectangle(m_x,m_y,m_w,m_h,m_r);}
 257         virtual void Translate(wxCoord dx, wxCoord dy)
 258             {m_x+=dx; m_y+=dy;}
 259     protected:
 260         wxCoord m_x,m_y,m_w,m_h;
 261         double m_r;
 262 };
 263
 264 class pdcDrawEllipseOp : public pdcOp
 265 {
 266     public:
 267         pdcDrawEllipseOp(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 268             {m_x=x; m_y=y; m_w=width; m_h=height;}
 269         virtual void DrawToDC(wxDC *dc) {dc->DrawEllipse(m_x,m_y,m_w,m_h);}
 270         virtual void Translate(wxCoord dx, wxCoord dy)
 271             {m_x+=dx; m_y+=dy;}
 272     protected:
 273         wxCoord m_x,m_y,m_w,m_h;
 274 };
 275
 276 class pdcDrawIconOp : public pdcOp
 277 {
 278     public:
 279         pdcDrawIconOp(const wxIcon& icon, wxCoord x, wxCoord y)
 280             {m_icon=icon; m_x=x; m_y=y;}
 281         virtual void DrawToDC(wxDC *dc) {dc->DrawIcon(m_icon,m_x,m_y);}
 282         virtual void Translate(wxCoord dx, wxCoord dy)
 283             {m_x+=dx; m_y+=dy;}
 284     protected:
 285         wxIcon m_icon;
 286         wxCoord m_x,m_y;
 287 };
 288
 289 class pdcDrawLinesOp : public pdcOp
 290 {
 291     public:
 292         pdcDrawLinesOp(int n, wxPoint points[],
 293                wxCoord xoffset = 0, wxCoord yoffset = 0);
 294         virtual ~pdcDrawLinesOp();
 295         virtual void DrawToDC(wxDC *dc)
 296             {dc->DrawLines(m_n,m_points,m_xoffset,m_yoffset);}
 297         virtual void Translate(wxCoord dx, wxCoord dy)
 298         {
 299             for(int i=0; i<m_n; i++)
 300             {
 301                 m_points[i].x+=dx;
 302                 m_points[i].y+=dy;
 303             }
 304         }
 305     protected:
 306         int m_n;
 307         wxPoint *m_points;
 308         wxCoord m_xoffset,m_yoffset;
 309 };
 310
 311 class pdcDrawPolygonOp : public pdcOp
 312 {
 313     public:
 314         pdcDrawPolygonOp(int n, wxPoint points[],
 315                      wxCoord xoffset = 0, wxCoord yoffset = 0,
 316                      int fillStyle = wxODDEVEN_RULE);
 317         virtual ~pdcDrawPolygonOp();
 318         virtual void DrawToDC(wxDC *dc)
 319             { dc->DrawPolygon(m_n,m_points,m_xoffset,m_yoffset,m_fillStyle); }
 320
 321         virtual void Translate(wxCoord dx, wxCoord dy)
 322         {
 323             for(int i=0; i<m_n; i++)
 324             {
 325                 m_points[i].x+=dx;
 326                 m_points[i].y+=dy;
 327             }
 328         }
 329     protected:
 330         int m_n;
 331         wxPoint *m_points;
 332         wxCoord m_xoffset,m_yoffset;
 333         int m_fillStyle;
 334 };
 335
 336 class pdcDrawPolyPolygonOp : public pdcOp
 337 {
 338     public:
 339         pdcDrawPolyPolygonOp(int n, int count[], wxPoint points[],
 340                          wxCoord xoffset = 0, wxCoord yoffset = 0,
 341                          int fillStyle = wxODDEVEN_RULE);
 342         virtual ~pdcDrawPolyPolygonOp();
 343         virtual void DrawToDC(wxDC *dc)
 344             {dc->DrawPolyPolygon(m_n,m_count,m_points,
 345                     m_xoffset,m_yoffset,m_fillStyle);}
 346         virtual void Translate(wxCoord dx, wxCoord dy)
 347         {
 348             for(int i=0; i<m_totaln; i++)
 349             {
 350                 m_points[i].x += dx;
 351                 m_points[i].y += dy;
 352             }
 353         }
 354     protected:
 355         int m_n;
 356         int m_totaln;
 357         int *m_count;
 358         wxPoint *m_points;
 359         wxCoord m_xoffset, m_yoffset;
 360         int m_fillStyle;
 361 };
 362
 363 class pdcDrawRotatedTextOp : public pdcOp
 364 {
 365     public:
 366         pdcDrawRotatedTextOp(const wxString& text, wxCoord x, wxCoord y, double angle)
 367             {m_text=text; m_x=x; m_y=y; m_angle=angle;}
 368         virtual void DrawToDC(wxDC *dc)
 369             {dc->DrawRotatedText(m_text,m_x,m_y,m_angle);}
 370         virtual void Translate(wxCoord dx, wxCoord dy)
 371             {m_x+=dx; m_y+=dy;}
 372     protected:
 373         wxString m_text;
 374         wxCoord m_x,m_y;
 375         double m_angle;
 376 };
 377
 378 class pdcDrawBitmapOp : public pdcOp
 379 {
 380     public:
 381         pdcDrawBitmapOp(const wxBitmap &bmp, wxCoord x, wxCoord y,
 382                         bool useMask = false)
 383             {m_bmp=bmp; m_x=x; m_y=y; m_useMask=useMask;}
 384         virtual void DrawToDC(wxDC *dc) {dc->DrawBitmap(m_bmp,m_x,m_y,m_useMask);}
 385         virtual void Translate(wxCoord dx, wxCoord dy)
 386             {m_x+=dx; m_y+=dy;}
 387     protected:
 388         wxBitmap m_bmp;
 389         wxCoord m_x,m_y;
 390         bool m_useMask;
 391 };
 392
 393 class pdcDrawLabelOp : public pdcOp
 394 {
 395     public:
 396         pdcDrawLabelOp(const wxString& text,
 397                            const wxBitmap& image,
 398                            const wxRect& rect,
 399                            int alignment = wxALIGN_LEFT | wxALIGN_TOP,
 400                            int indexAccel = -1)
 401             {m_text=text; m_image=image; m_rect=rect;
 402              m_align=alignment; m_iAccel=indexAccel;}
 403         virtual void DrawToDC(wxDC *dc)
 404             {dc->DrawLabel(m_text,m_image,m_rect,m_align,m_iAccel);}
 405         virtual void Translate(wxCoord dx, wxCoord dy)
 406             {m_rect.x+=dx; m_rect.y+=dy;}
 407     protected:
 408         wxString m_text;
 409         wxBitmap m_image;
 410         wxRect m_rect;
 411         int m_align;
 412         int m_iAccel;
 413 };
 414
 415 #if wxUSE_SPLINES
 416 class pdcDrawSplineOp : public pdcOp
 417 {
 418     public:
 419         pdcDrawSplineOp(int n, wxPoint points[]);
 420         virtual ~pdcDrawSplineOp();
 421         virtual void DrawToDC(wxDC *dc) {dc->DrawSpline(m_n,m_points);}
 422         virtual void Translate(wxCoord dx, wxCoord dy)
 423         {
 424             int i;
 425             for(i=0; i<m_n; i++)
 426                 m_points[i].x+=dx; m_points[i].y+=dy;
 427         }
 428     protected:
 429         wxPoint *m_points;
 430         int m_n;
 431 };
 432 #endif // wxUSE_SPLINES
 433
 434 #if wxUSE_PALETTE
 435 class pdcSetPaletteOp : public pdcOp
 436 {
 437     public:
 438         pdcSetPaletteOp(const wxPalette& palette) {m_palette=palette;}
 439         virtual void DrawToDC(wxDC *dc) {dc->SetPalette(m_palette);}
 440     protected:
 441         wxPalette m_palette;
 442 };
 443 #endif // wxUSE_PALETTE
 444
 445 class pdcSetLogicalFunctionOp : public pdcOp
 446 {
 447     public:
 448         pdcSetLogicalFunctionOp(int function) {m_function=function;}
 449         virtual void DrawToDC(wxDC *dc) {dc->SetLogicalFunction(m_function);}
 450     protected:
 451         int m_function;
 452 };
 453
 454 //----------------------------------------------------------------------------
 455 // pdcObject type to contain list of operations for each real (Python) object
 456 //----------------------------------------------------------------------------
 457 class pdcObject
 458 {
 459     public:
 460         pdcObject(int id)
 461             {m_id=id; m_bounded=false; m_oplist.DeleteContents(true);}
 462
 463         virtual ~pdcObject() {m_oplist.Clear();}
 464
 465         // Protected Member Access
 466         void SetId(int id) {m_id=id;}
 467         int  GetId() {return m_id;}
 468         void   SetBounds(wxRect& rect) {m_bounds=rect; m_bounded=true;}
 469         wxRect GetBounds() {return m_bounds;}
 470         void SetBounded(bool bounded) {m_bounded=bounded;}
 471         bool IsBounded() {return m_bounded;}
 472
 473         // Op List Management Methods
 474         void Clear() {m_oplist.Clear();}
 475         void AddOp(pdcOp *op) {m_oplist.Append(op);}
 476         int  GetLen() {return m_oplist.GetCount();}
 477         virtual void Translate(wxCoord dx, wxCoord dy);
 478
 479         // Drawing Method
 480         virtual void DrawToDC(wxDC *dc);
 481     protected:
 482         int m_id; // id of object (associates this pdcObject
 483                   //               with a Python object with same id)
 484         wxRect m_bounds;  // bounding rect of this object
 485         bool m_bounded;   // true if bounds is valid, false by default
 486         pdcOpList m_oplist; // list of operations for this object
 487 };
 488
 489
 490 //----------------------------------------------------------------------------
 491 // Declare a wxList to hold all the objects.  List order reflects drawing
 492 // order (Z order) and is the same order as objects are added to the list
 493 //----------------------------------------------------------------------------
 494 class pdcObjectList;
 495 WX_DECLARE_LIST(pdcObject, pdcObjectList);
 496
 497
 498 // ----------------------------------------------------------------------------
 499 // wxPseudoDC class
 500 // ----------------------------------------------------------------------------
 501 // This is the actual PseudoDC class
 502 // This class stores a list of recorded dc operations in m_list
 503 // and plays them back to a real dc using DrawToDC or DrawToDCClipped.
 504 // Drawing methods are mirrored from wxDC but add nodes to m_list
 505 // instead of doing any real drawing.
 506 // ----------------------------------------------------------------------------
 507 class wxPseudoDC : public wxObject
 508 {
 509 public:
 510     wxPseudoDC()
 511         {m_currId=-1; m_lastObjNode=NULL; m_objectlist.DeleteContents(true);}
 512     ~wxPseudoDC();
 513     // ------------------------------------------------------------------------
 514     // List managment methods
 515     //
 516     void RemoveAll();
 517     int GetLen();
 518
 519     // ------------------------------------------------------------------------
 520     // methods for managing operations by ID
 521     //
 522     // Set the Id for all subsequent operations (until SetId is called again)
 523     void SetId(int id) {m_currId = id;}
 524     // Remove all the operations associated with an id so it can be redrawn
 525     void ClearId(int id);
 526     // Remove the object node (and all operations) associated with an id
 527     void RemoveId(int id);
 528     // Set the bounding rect of a given object
 529     // This will create an object node if one doesn't exist
 530     void SetIdBounds(int id, wxRect& rect);
 531     void GetIdBounds(int id, wxRect& rect);
 532     // Translate all the operations for this id
 533     void TranslateId(int id, wxCoord dx, wxCoord dy);
 534
 535     // ------------------------------------------------------------------------
 536     // Playback Methods
 537     //
 538     // draw to dc but skip objects known to be outside of rect
 539     // This is a coarse level of clipping to speed things up
 540     // when lots of objects are off screen and doesn't affect the dc level
 541     // clipping
 542     void DrawToDCClipped(wxDC *dc, const wxRect& rect);
 543         void DrawToDCClippedRgn(wxDC *dc, const wxRegion& region);
 544     // draw to dc with no clipping (well the dc will still clip)
 545     void DrawToDC(wxDC *dc);
 546     // draw a single object to the dc
 547     void DrawIdToDC(int id, wxDC *dc);
 548
 549     // ------------------------------------------------------------------------
 550     // Methods mirrored from wxDC
 551     //
 552     void FloodFill(wxCoord x, wxCoord y, const wxColour& col,
 553                    int style = wxFLOOD_SURFACE)
 554         {AddToList(new pdcFloodFillOp(x,y,col,style));}
 555     void FloodFill(const wxPoint& pt, const wxColour& col,
 556                    int style = wxFLOOD_SURFACE)
 557         { FloodFill(pt.x, pt.y, col, style); }
 558
 559     void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
 560         {AddToList(new pdcDrawLineOp(x1, y1, x2, y2));}
 561     void DrawLine(const wxPoint& pt1, const wxPoint& pt2)
 562         { DrawLine(pt1.x, pt1.y, pt2.x, pt2.y); }
 563
 564     void CrossHair(wxCoord x, wxCoord y)
 565         {AddToList(new pdcCrossHairOp(x,y));}
 566     void CrossHair(const wxPoint& pt)
 567         { CrossHair(pt.x, pt.y); }
 568
 569     void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
 570                  wxCoord xc, wxCoord yc)
 571         {AddToList(new pdcDrawArcOp(x1,y1,x2,y2,xc,yc));}
 572     void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre)
 573         { DrawArc(pt1.x, pt1.y, pt2.x, pt2.y, centre.x, centre.y); }
 574
 575     void DrawCheckMark(wxCoord x, wxCoord y,
 576                        wxCoord width, wxCoord height)
 577         {AddToList(new pdcDrawCheckMarkOp(x,y,width,height));}
 578     void DrawCheckMark(const wxRect& rect)
 579         { DrawCheckMark(rect.x, rect.y, rect.width, rect.height); }
 580
 581     void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
 582                          double sa, double ea)
 583         {AddToList(new pdcDrawEllipticArcOp(x,y,w,h,sa,ea));}
 584     void DrawEllipticArc(const wxPoint& pt, const wxSize& sz,
 585                          double sa, double ea)
 586         { DrawEllipticArc(pt.x, pt.y, sz.x, sz.y, sa, ea); }
 587
 588     void DrawPoint(wxCoord x, wxCoord y)
 589         {AddToList(new pdcDrawPointOp(x,y));}
 590     void DrawPoint(const wxPoint& pt)
 591         { DrawPoint(pt.x, pt.y); }
 592
 593     void DrawPolygon(int n, wxPoint points[],
 594                      wxCoord xoffset = 0, wxCoord yoffset = 0,
 595                      int fillStyle = wxODDEVEN_RULE)
 596         {AddToList(new pdcDrawPolygonOp(n,points,xoffset,yoffset,fillStyle));}
 597
 598     void DrawPolyPolygon(int n, int count[], wxPoint points[],
 599                          wxCoord xoffset = 0, wxCoord yoffset = 0,
 600                          int fillStyle = wxODDEVEN_RULE)
 601         {AddToList(new pdcDrawPolyPolygonOp(n,count,points,xoffset,yoffset,fillStyle));}
 602
 603     void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 604         {AddToList(new pdcDrawRectangleOp(x, y, width, height));}
 605     void DrawRectangle(const wxPoint& pt, const wxSize& sz)
 606         { DrawRectangle(pt.x, pt.y, sz.x, sz.y); }
 607     void DrawRectangle(const wxRect& rect)
 608         { DrawRectangle(rect.x, rect.y, rect.width, rect.height); }
 609
 610     void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height,
 611                               double radius)
 612         {AddToList(new pdcDrawRoundedRectangleOp(x,y,width,height,radius));}
 613     void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz,
 614                              double radius)
 615         { DrawRoundedRectangle(pt.x, pt.y, sz.x, sz.y, radius); }
 616     void DrawRoundedRectangle(const wxRect& r, double radius)
 617         { DrawRoundedRectangle(r.x, r.y, r.width, r.height, radius); }
 618
 619     void DrawCircle(wxCoord x, wxCoord y, wxCoord radius)
 620         { DrawEllipse(x - radius, y - radius, 2*radius, 2*radius); }
 621     void DrawCircle(const wxPoint& pt, wxCoord radius)
 622         { DrawCircle(pt.x, pt.y, radius); }
 623
 624     void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 625         {AddToList(new pdcDrawEllipseOp(x,y,width,height));}
 626     void DrawEllipse(const wxPoint& pt, const wxSize& sz)
 627         { DrawEllipse(pt.x, pt.y, sz.x, sz.y); }
 628     void DrawEllipse(const wxRect& rect)
 629         { DrawEllipse(rect.x, rect.y, rect.width, rect.height); }
 630
 631     void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
 632         {AddToList(new pdcDrawIconOp(icon,x,y));}
 633     void DrawIcon(const wxIcon& icon, const wxPoint& pt)
 634         { DrawIcon(icon, pt.x, pt.y); }
 635
 636     void DrawLines(int n, wxPoint points[],
 637                wxCoord xoffset = 0, wxCoord yoffset = 0)
 638         {AddToList(new pdcDrawLinesOp(n,points,xoffset,yoffset));}
 639
 640     void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
 641                     bool useMask = false)
 642         {AddToList(new pdcDrawBitmapOp(bmp,x,y,useMask));}
 643     void DrawBitmap(const wxBitmap &bmp, const wxPoint& pt,
 644                     bool useMask = false)
 645         { DrawBitmap(bmp, pt.x, pt.y, useMask); }
 646
 647     void DrawText(const wxString& text, wxCoord x, wxCoord y)
 648         {AddToList(new pdcDrawTextOp(text, x, y));}
 649     void DrawText(const wxString& text, const wxPoint& pt)
 650         { DrawText(text, pt.x, pt.y); }
 651
 652     void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle)
 653         {AddToList(new pdcDrawRotatedTextOp(text,x,y,angle));}
 654     void DrawRotatedText(const wxString& text, const wxPoint& pt, double angle)
 655         { DrawRotatedText(text, pt.x, pt.y, angle); }
 656
 657     // this version puts both optional bitmap and the text into the given
 658     // rectangle and aligns is as specified by alignment parameter; it also
 659     // will emphasize the character with the given index if it is != -1
 660     void DrawLabel(const wxString& text,
 661                            const wxBitmap& image,
 662                            const wxRect& rect,
 663                            int alignment = wxALIGN_LEFT | wxALIGN_TOP,
 664                            int indexAccel = -1)
 665         {AddToList(new pdcDrawLabelOp(text,image,rect,alignment,indexAccel));}
 666
 667     void DrawLabel(const wxString& text, const wxRect& rect,
 668                    int alignment = wxALIGN_LEFT | wxALIGN_TOP,
 669                    int indexAccel = -1)
 670         { DrawLabel(text, wxNullBitmap, rect, alignment, indexAccel); }
 671
 672 /*?????? I don't think that the source dc would stick around
 673     void Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
 674               wxDC *source, wxCoord xsrc, wxCoord ysrc,
 675               int rop = wxCOPY, bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord)
 676                 {AddToList(new pdcBlitOp(xdest,ydest,width,height,source,xsrc,
 677                                          ysrc,rop,useMask,xsrcMask,ysrcMask));}
 678     void Blit(const wxPoint& destPt, const wxSize& sz,
 679               wxDC *source, const wxPoint& srcPt,
 680               int rop = wxCOPY, bool useMask = false, const wxPoint& srcPtMask = wxDefaultPosition)
 681     {
 682         Blit(destPt.x, destPt.y, sz.x, sz.y, source, srcPt.x, srcPt.y,
 683              rop, useMask, srcPtMask.x, srcPtMask.y);
 684     }
 685 ??????*/
 686
 687 #if wxUSE_SPLINES
 688     void DrawSpline(int n, wxPoint points[])
 689         {AddToList(new pdcDrawSplineOp(n,points));}
 690 #endif // wxUSE_SPLINES
 691
 692 #if wxUSE_PALETTE
 693     void SetPalette(const wxPalette& palette)
 694         {AddToList(new pdcSetPaletteOp(palette));}
 695 #endif // wxUSE_PALETTE
 696
 697     void SetLogicalFunction(int function)
 698         {AddToList(new pdcSetLogicalFunctionOp(function));}
 699     void SetFont(const wxFont& font)
 700         {AddToList(new pdcSetFontOp(font));}
 701     void SetPen(const wxPen& pen)
 702         {AddToList(new pdcSetPenOp(pen));}
 703     void SetBrush(const wxBrush& brush)
 704         {AddToList(new pdcSetBrushOp(brush));}
 705     void SetBackground(const wxBrush& brush)
 706         {AddToList(new pdcSetBackgroundOp(brush));}
 707     void SetBackgroundMode(int mode)
 708         {AddToList(new pdcSetBackgroundModeOp(mode));}
 709     void SetTextBackground(const wxColour& colour)
 710         {AddToList(new pdcSetTextBackgroundOp(colour));}
 711     void SetTextForeground(const wxColour& colour)
 712         {AddToList(new pdcSetTextForegroundOp(colour));}
 713
 714     void Clear()
 715         {AddToList(new pdcClearOp());}
 716         void BeginDrawing()
 717                 {AddToList(new pdcBeginDrawingOp());}
 718         void EndDrawing()
 719                 {AddToList(new pdcEndDrawingOp());}
 720
 721 protected:
 722     // ------------------------------------------------------------------------
 723     // protected helper methods
 724     void AddToList(pdcOp *newOp);
 725     pdcObjectList::Node *FindObjNode(int id, bool create=false);
 726
 727     // ------------------------------------------------------------------------
 728     // Data members
 729     //
 730     int m_currId; // id to use for operations done on the PseudoDC
 731     pdcObjectList::Node *m_lastObjNode; // used to find last used object quickly
 732     pdcObjectList m_objectlist; // list of objects
 733 };
 734
 735 #endif
 736