wxPython/src/_dc.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        _dc.i
   3 // Purpose:     SWIG interface defs for wxDC and releated classes
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     7-July-1997
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 2003 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 // Not a %module
  14
  15
  16
  17 //---------------------------------------------------------------------------
  18
  19 %{
  20 #include "wx/wxPython/pydrawxxx.h"
  21 %}
  22
  23 // TODO: 1. wrappers for wxDrawObject and wxDC::DrawObject
  24
  25
  26 //---------------------------------------------------------------------------
  27
  28 %typemap(in) (int points, wxPoint* points_array ) {
  29     $2 = wxPoint_LIST_helper($input, &$1);
  30     if ($2 == NULL) SWIG_fail;
  31 }
  32 %typemap(freearg) (int points, wxPoint* points_array ) {
  33     if ($2) delete [] $2;
  34 }
  35
  36
  37 //---------------------------------------------------------------------------
  38 %newgroup;
  39
  40
  41 // wxDC is the device context - object on which any drawing is done
  42 class wxDC : public wxObject {
  43 public:
  44 //    wxDC(); **** abstract base class, can't instantiate.
  45     ~wxDC();
  46
  47
  48     virtual void BeginDrawing();
  49     virtual void EndDrawing();
  50
  51
  52 //    virtual void DrawObject(wxDrawObject* drawobject);
  53
  54
  55
  56 #if 1 // The < 2.4 and > 2.5.1.5 way
  57
  58     bool FloodFill(wxCoord x, wxCoord y, const wxColour& col, int style = wxFLOOD_SURFACE);
  59     %name(FloodFillPoint) bool FloodFill(const wxPoint& pt, const wxColour& col, int style = wxFLOOD_SURFACE);
  60
  61     //bool GetPixel(wxCoord x, wxCoord y, wxColour *col) const;
  62     %extend {
  63         wxColour GetPixel(wxCoord x, wxCoord y) {
  64             wxColour col;
  65             self->GetPixel(x, y, &col);
  66             return col;
  67         }
  68         wxColour GetPixelPoint(const wxPoint& pt) {
  69             wxColour col;
  70             self->GetPixel(pt, &col);
  71             return col;
  72         }
  73     }
  74
  75     void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
  76     %name(DrawLinePoint) void DrawLine(const wxPoint& pt1, const wxPoint& pt2);
  77
  78     void CrossHair(wxCoord x, wxCoord y);
  79     %name(CrossHairPoint) void CrossHair(const wxPoint& pt);
  80
  81     void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc);
  82     %name(DrawArcPoint) void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre);
  83
  84     void DrawCheckMark(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
  85     %name(DrawCheckMarkRect) void DrawCheckMark(const wxRect& rect);
  86
  87     void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h, double sa, double ea);
  88     %name(DrawEllipticArcPointSize) void DrawEllipticArc(const wxPoint& pt, const wxSize& sz, double sa, double ea);
  89
  90     void DrawPoint(wxCoord x, wxCoord y);
  91     %name(DrawPointPoint) void DrawPoint(const wxPoint& pt);
  92
  93     void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
  94     %name(DrawRectangleRect)void DrawRectangle(const wxRect& rect);
  95     %name(DrawRectanglePointSize) void DrawRectangle(const wxPoint& pt, const wxSize& sz);
  96
  97     void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius);
  98     %name(DrawRoundedRectangleRect) void DrawRoundedRectangle(const wxRect& r, double radius);
  99     %name(DrawRoundedRectanglePointSize) void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz, double radius);
 100
 101     void DrawCircle(wxCoord x, wxCoord y, wxCoord radius);
 102     %name(DrawCirclePoint) void DrawCircle(const wxPoint& pt, wxCoord radius);
 103
 104     void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
 105     %name(DrawEllipseRect) void DrawEllipse(const wxRect& rect);
 106     %name(DrawEllipsePointSize) void DrawEllipse(const wxPoint& pt, const wxSize& sz);
 107
 108     void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y);
 109     %name(DrawIconPoint) void DrawIcon(const wxIcon& icon, const wxPoint& pt);
 110
 111     void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask = False);
 112     %name(DrawBitmapPoint) void DrawBitmap(const wxBitmap &bmp, const wxPoint& pt, bool useMask = False);
 113
 114     void DrawText(const wxString& text, wxCoord x, wxCoord y);
 115     %name(DrawTextPoint) void DrawText(const wxString& text, const wxPoint& pt);
 116
 117     void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle);
 118     %name(DrawRotatedTextPoint) void DrawRotatedText(const wxString& text, const wxPoint& pt, double angle);
 119
 120     bool Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
 121               wxDC *source, wxCoord xsrc, wxCoord ysrc,
 122               int rop = wxCOPY, bool useMask = False,
 123               wxCoord xsrcMask = -1, wxCoord ysrcMask = -1);
 124     %name(BlitPointSize) bool Blit(const wxPoint& destPt, const wxSize& sz,
 125                                    wxDC *source, const wxPoint& srcPt,
 126                                    int rop = wxCOPY, bool useMask = False,
 127                                    const wxPoint& srcPtMask = wxDefaultPosition);
 128
 129
 130     void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
 131     %name(SetClippingRegionPointSize) void SetClippingRegion(const wxPoint& pt, const wxSize& sz);
 132     %name(SetClippingRegionAsRegion) void SetClippingRegion(const wxRegion& region);
 133     %name(SetClippingRect) void SetClippingRegion(const wxRect& rect);
 134
 135 #else  // The doomed 2.5.1.5
 136
 137     %name(FloodFillXY) bool FloodFill(wxCoord x, wxCoord y, const wxColour& col, int style = wxFLOOD_SURFACE);
 138     bool FloodFill(const wxPoint& pt, const wxColour& col, int style = wxFLOOD_SURFACE);
 139
 140     //%name(GetPixelXY) bool GetPixel(wxCoord x, wxCoord y, wxColour *col) const;
 141     //bool GetPixel(const wxPoint& pt, wxColour *col) const;
 142     %extend {
 143         wxColour GetPixelXY(wxCoord x, wxCoord y) {
 144             wxColour col;
 145             self->GetPixel(x, y, &col);
 146             return col;
 147         }
 148         wxColour GetPixel(const wxPoint& pt) {
 149             wxColour col;
 150             self->GetPixel(pt, &col);
 151             return col;
 152         }
 153     }
 154
 155     %name(DrawLineXY) void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
 156     void DrawLine(const wxPoint& pt1, const wxPoint& pt2);
 157
 158     %name(CrossHairXY) void CrossHair(wxCoord x, wxCoord y);
 159     void CrossHair(const wxPoint& pt);
 160
 161     %name(DrawArcXY) void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc);
 162     void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre);
 163
 164     %name(DrawCheckMarkXY) void DrawCheckMark(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
 165     void DrawCheckMark(const wxRect& rect);
 166
 167     %name(DrawEllipticArcXY) void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h, double sa, double ea);
 168     void DrawEllipticArc(const wxPoint& pt, const wxSize& sz, double sa, double ea);
 169
 170     %name(DrawPointXY) void DrawPoint(wxCoord x, wxCoord y);
 171     void DrawPoint(const wxPoint& pt);
 172
 173     %name(DrawRectangleXY) void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
 174     void DrawRectangle(const wxPoint& pt, const wxSize& sz);
 175     %name(DrawRectangleRect) void DrawRectangle(const wxRect& rect);
 176
 177     %name(DrawRoundedRectangleXY) void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius);
 178     void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz, double radius);
 179     %name(DrawRoundedRectangleRect) void DrawRoundedRectangle(const wxRect& r, double radius);
 180
 181     %name(DrawCircleXY) void DrawCircle(wxCoord x, wxCoord y, wxCoord radius);
 182     void DrawCircle(const wxPoint& pt, wxCoord radius);
 183
 184     %name(DrawEllipseXY) void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
 185     void DrawEllipse(const wxPoint& pt, const wxSize& sz);
 186     %name(DrawEllipseRect) void DrawEllipse(const wxRect& rect);
 187
 188     %name(DrawIconXY) void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y);
 189     void DrawIcon(const wxIcon& icon, const wxPoint& pt);
 190
 191     %name(DrawBitmapXY) void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask = False);
 192     void DrawBitmap(const wxBitmap &bmp, const wxPoint& pt, bool useMask = False);
 193
 194     %name(DrawTextXY) void DrawText(const wxString& text, wxCoord x, wxCoord y);
 195     void DrawText(const wxString& text, const wxPoint& pt);
 196
 197     %name(DrawRotatedTextXY) void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle);
 198     void DrawRotatedText(const wxString& text, const wxPoint& pt, double angle);
 199
 200
 201     %name(BlitXY) bool Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
 202                             wxDC *source, wxCoord xsrc, wxCoord ysrc,
 203                             int rop = wxCOPY, bool useMask = False,
 204                             wxCoord xsrcMask = -1, wxCoord ysrcMask = -1);
 205     bool Blit(const wxPoint& destPt, const wxSize& sz,
 206               wxDC *source, const wxPoint& srcPt,
 207               int rop = wxCOPY, bool useMask = False,
 208               const wxPoint& srcPtMask = wxDefaultPosition);
 209
 210
 211     %name(SetClippingRegionXY)void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
 212     void SetClippingRegion(const wxPoint& pt, const wxSize& sz);
 213     %name(SetClippingRect) void SetClippingRegion(const wxRect& rect);
 214     %name(SetClippingRegionAsRegion) void SetClippingRegion(const wxRegion& region);
 215
 216 #endif
 217
 218     void DrawLines(int points, wxPoint* points_array, wxCoord xoffset = 0, wxCoord yoffset = 0);
 219
 220     void DrawPolygon(int points, wxPoint* points_array,
 221                      wxCoord xoffset = 0, wxCoord yoffset = 0,
 222                      int fillStyle = wxODDEVEN_RULE);
 223
 224     // TODO:  Figure out a good typemap for this...
 225     //        Convert the first 3 args from a sequence of sequences?
 226 //     void DrawPolyPolygon(int n, int count[], wxPoint points[],
 227 //                           wxCoord xoffset = 0, wxCoord yoffset = 0,
 228 //                           int fillStyle = wxODDEVEN_RULE);
 229
 230
 231     // this version puts both optional bitmap and the text into the given
 232     // rectangle and aligns is as specified by alignment parameter; it also
 233     // will emphasize the character with the given index if it is != -1 and
 234     // return the bounding rectangle if required
 235     void DrawLabel(const wxString& text, const wxRect& rect,
 236                    int alignment = wxALIGN_LEFT | wxALIGN_TOP,
 237                    int indexAccel = -1);
 238     %extend {
 239         wxRect DrawImageLabel(const wxString& text,
 240                               const wxBitmap& image,
 241                               const wxRect& rect,
 242                               int alignment = wxALIGN_LEFT | wxALIGN_TOP,
 243                               int indexAccel = -1) {
 244             wxRect rv;
 245             self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
 246             return rv;
 247         }
 248     }
 249
 250
 251
 252     void DrawSpline(int points, wxPoint* points_array);
 253
 254
 255
 256     // global DC operations
 257     // --------------------
 258
 259     virtual void Clear();
 260
 261     virtual bool StartDoc(const wxString& message);
 262     virtual void EndDoc();
 263
 264     virtual void StartPage();
 265     virtual void EndPage();
 266
 267
 268     // set objects to use for drawing
 269     // ------------------------------
 270
 271     virtual void SetFont(const wxFont& font);
 272     virtual void SetPen(const wxPen& pen);
 273     virtual void SetBrush(const wxBrush& brush);
 274     virtual void SetBackground(const wxBrush& brush);
 275     virtual void SetBackgroundMode(int mode);
 276     virtual void SetPalette(const wxPalette& palette);
 277
 278
 279     virtual void DestroyClippingRegion();
 280
 281     DocDeclA(
 282         void, GetClippingBox(wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord *OUTPUT) const,
 283         "GetClippingBox() -> (x, y, width, height)");
 284
 285     %extend {
 286         wxRect GetClippingRect() {
 287             wxRect rect;
 288             self->GetClippingBox(rect);
 289             return rect;
 290         }
 291     }
 292
 293
 294
 295     // text extent
 296     // -----------
 297
 298     virtual wxCoord GetCharHeight() const;
 299     virtual wxCoord GetCharWidth() const;
 300
 301
 302     DocDeclAStr(
 303         void, GetTextExtent(const wxString& string, wxCoord *OUTPUT, wxCoord *OUTPUT),
 304         "GetTextExtent(wxString string) -> (width, height)",
 305         "Get the width and height of the text using the current font. Only
 306 works for single line strings.", "");
 307
 308     DocDeclAStrName(
 309         void, GetTextExtent(const wxString& string,
 310                             wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord* OUTPUT,
 311                             wxFont* font = NULL),
 312         "GetFullTextExtent(wxString string, Font font=None) ->\n   (width, height, descent, externalLeading)",
 313         "Get the width, height, decent and leading of the text using the
 314 current or specified font. Only works for single line strings.", "",
 315         GetFullTextExtent);
 316
 317
 318     // works for single as well as multi-line strings
 319     DocDeclAStr(
 320         void, GetMultiLineTextExtent(const wxString& text,
 321                                      wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord *OUTPUT,
 322                                      wxFont *font = NULL),
 323         "GetMultiLineTextExtent(wxString string, Font font=None) ->\n   (width, height, descent, externalLeading)",
 324         "Get the width, height, decent and leading of the text using the
 325 current or specified font. Works for single as well as multi-line
 326 strings.", "");
 327
 328
 329     %extend {
 330         wxArrayInt GetPartialTextExtents(const wxString& text) {
 331             wxArrayInt widths;
 332             self->GetPartialTextExtents(text, widths);
 333             return widths;
 334         }
 335     }
 336
 337
 338     // size and resolution
 339     // -------------------
 340
 341     DocStr(GetSize, "Get the DC size in device units.", "");
 342     wxSize GetSize();
 343     DocDeclAName(
 344         void, GetSize( int *OUTPUT, int *OUTPUT ),
 345         "GetSizeTuple() -> (width, height)",
 346         GetSizeTuple);
 347
 348
 349     DocStr(GetSizeMM, "Get the DC size in milimeters.", "");
 350     wxSize GetSizeMM() const;
 351     DocDeclAName(
 352         void, GetSizeMM( int *OUTPUT, int *OUTPUT ) const,
 353         "GetSizeMMTuple() -> (width, height)",
 354         GetSizeMMTuple);
 355
 356
 357
 358     // coordinates conversions
 359     // -----------------------
 360
 361     // This group of functions does actual conversion of the input, as you'd
 362     // expect.
 363     wxCoord DeviceToLogicalX(wxCoord x) const;
 364     wxCoord DeviceToLogicalY(wxCoord y) const;
 365     wxCoord DeviceToLogicalXRel(wxCoord x) const;
 366     wxCoord DeviceToLogicalYRel(wxCoord y) const;
 367     wxCoord LogicalToDeviceX(wxCoord x) const;
 368     wxCoord LogicalToDeviceY(wxCoord y) const;
 369     wxCoord LogicalToDeviceXRel(wxCoord x) const;
 370     wxCoord LogicalToDeviceYRel(wxCoord y) const;
 371
 372     // query DC capabilities
 373     // ---------------------
 374
 375     virtual bool CanDrawBitmap() const;
 376     virtual bool CanGetTextExtent() const;
 377
 378     // colour depth
 379     virtual int GetDepth() const;
 380
 381     // Resolution in Pixels per inch
 382     virtual wxSize GetPPI() const;
 383
 384     virtual bool Ok() const;
 385
 386
 387
 388     int GetBackgroundMode() const;
 389     const wxBrush&  GetBackground() const;
 390     const wxBrush&  GetBrush() const;
 391     const wxFont&   GetFont() const;
 392     const wxPen&    GetPen() const;
 393     const wxColour& GetTextBackground() const;
 394     const wxColour& GetTextForeground() const;
 395
 396     virtual void SetTextForeground(const wxColour& colour);
 397     virtual void SetTextBackground(const wxColour& colour);
 398
 399     int GetMapMode() const;
 400     virtual void SetMapMode(int mode);
 401
 402
 403     DocDeclA(
 404         virtual void, GetUserScale(double *OUTPUT, double *OUTPUT) const,
 405         "GetUserScale() -> (xScale, yScale)");
 406
 407     virtual void SetUserScale(double x, double y);
 408
 409
 410     DocDeclA(
 411         virtual void, GetLogicalScale(double *OUTPUT, double *OUTPUT),
 412         "GetLogicalScale() -> (xScale, yScale)");
 413
 414     virtual void SetLogicalScale(double x, double y);
 415
 416
 417     wxPoint GetLogicalOrigin() const;
 418     DocDeclAName(
 419         void, GetLogicalOrigin(wxCoord *OUTPUT, wxCoord *OUTPUT) const,
 420         "GetLogicalOriginTuple() -> (x,y)",
 421         GetLogicalOriginTuple);
 422
 423     virtual void SetLogicalOrigin(wxCoord x, wxCoord y);
 424     %extend {
 425         void SetLogicalOriginPoint(const wxPoint& point) {
 426             self->SetLogicalOrigin(point.x, point.y);
 427         }
 428     }
 429
 430
 431     wxPoint GetDeviceOrigin() const;
 432     DocDeclAName(
 433         void, GetDeviceOrigin(wxCoord *OUTPUT, wxCoord *OUTPUT) const,
 434         "GetDeviceOriginTuple() -> (x,y)",
 435         GetDeviceOriginTuple);
 436
 437     virtual void SetDeviceOrigin(wxCoord x, wxCoord y);
 438     %extend {
 439         void SetDeviceOriginPoint(const wxPoint& point) {
 440             self->SetDeviceOrigin(point.x, point.y);
 441         }
 442     }
 443
 444     virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp);
 445
 446     int GetLogicalFunction() const;
 447     virtual void SetLogicalFunction(int function);
 448
 449     virtual void SetOptimization(bool opt);
 450     virtual bool GetOptimization();
 451
 452
 453     // bounding box
 454     // ------------
 455
 456     virtual void CalcBoundingBox(wxCoord x, wxCoord y);
 457     %extend {
 458         void CalcBoundingBoxPoint(const wxPoint& point) {
 459             self->CalcBoundingBox(point.x, point.y);
 460         }
 461     }
 462
 463     void ResetBoundingBox();
 464
 465     // Get the final bounding box of the PostScript or Metafile picture.
 466     wxCoord MinX() const;
 467     wxCoord MaxX() const;
 468     wxCoord MinY() const;
 469     wxCoord MaxY() const;
 470
 471
 472     DocA(GetBoundingBox,
 473          "GetBoundingBox() -> (x1,y1, x2,y2)");
 474     %extend {
 475         void GetBoundingBox(int* OUTPUT, int* OUTPUT, int* OUTPUT, int* OUTPUT);
 476         // See below for implementation
 477     }
 478     %pythoncode { def __nonzero__(self): return self.Ok() };
 479
 480
 481 #ifdef __WXMSW__
 482     long GetHDC();
 483 #endif
 484
 485
 486     %extend { // See drawlist.cpp for impplementaion of these...
 487         PyObject* _DrawPointList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
 488         {
 489             return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
 490         }
 491
 492         PyObject* _DrawLineList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
 493         {
 494             return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
 495         }
 496
 497         PyObject* _DrawRectangleList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
 498         {
 499             return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
 500         }
 501
 502         PyObject* _DrawEllipseList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
 503         {
 504             return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
 505         }
 506
 507         PyObject* _DrawPolygonList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
 508         {
 509             return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
 510         }
 511
 512         PyObject* _DrawTextList(PyObject* textList, PyObject* pyPoints,
 513                                 PyObject* foregroundList, PyObject* backgroundList) {
 514             return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
 515         }
 516     }
 517
 518     %pythoncode {
 519     def DrawPointList(self, points, pens=None):
 520         if pens is None:
 521            pens = []
 522         elif isinstance(pens, wx.Pen):
 523            pens = [pens]
 524         elif len(pens) != len(points):
 525            raise ValueError('points and pens must have same length')
 526         return self._DrawPointList(points, pens, [])
 527
 528
 529     def DrawLineList(self, lines, pens=None):
 530         if pens is None:
 531            pens = []
 532         elif isinstance(pens, wx.Pen):
 533            pens = [pens]
 534         elif len(pens) != len(lines):
 535            raise ValueError('lines and pens must have same length')
 536         return self._DrawLineList(lines, pens, [])
 537
 538
 539     def DrawRectangleList(self, rectangles, pens=None, brushes=None):
 540         if pens is None:
 541            pens = []
 542         elif isinstance(pens, wx.Pen):
 543            pens = [pens]
 544         elif len(pens) != len(rectangles):
 545            raise ValueError('rectangles and pens must have same length')
 546         if brushes is None:
 547            brushes = []
 548         elif isinstance(brushes, wx.Brush):
 549            brushes = [brushes]
 550         elif len(brushes) != len(rectangles):
 551            raise ValueError('rectangles and brushes must have same length')
 552         return self._DrawRectangleList(rectangles, pens, brushes)
 553
 554
 555     def DrawEllipseList(self, ellipses, pens=None, brushes=None):
 556         if pens is None:
 557            pens = []
 558         elif isinstance(pens, wx.Pen):
 559            pens = [pens]
 560         elif len(pens) != len(ellipses):
 561            raise ValueError('ellipses and pens must have same length')
 562         if brushes is None:
 563            brushes = []
 564         elif isinstance(brushes, wx.Brush):
 565            brushes = [brushes]
 566         elif len(brushes) != len(ellipses):
 567            raise ValueError('ellipses and brushes must have same length')
 568         return self._DrawEllipseList(ellipses, pens, brushes)
 569
 570
 571     def DrawPolygonList(self, polygons, pens=None, brushes=None):
 572         %## Note: This does not currently support fill style or offset
 573         %## you can always use the non-List version if need be.
 574         if pens is None:
 575            pens = []
 576         elif isinstance(pens, wx.Pen):
 577            pens = [pens]
 578         elif len(pens) != len(polygons):
 579            raise ValueError('polygons and pens must have same length')
 580         if brushes is None:
 581            brushes = []
 582         elif isinstance(brushes, wx.Brush):
 583            brushes = [brushes]
 584         elif len(brushes) != len(polygons):
 585            raise ValueError('polygons and brushes must have same length')
 586         return self._DrawPolygonList(polygons, pens, brushes)
 587
 588
 589     def DrawTextList(self, textList, coords, foregrounds = None, backgrounds = None, fonts = None):
 590         %## NOTE: this does not currently support changing the font
 591         %##       Make sure you set Background mode to wxSolid (DC.SetBackgroundMode)
 592         %##       If you want backgounds to do anything.
 593         if type(textList) == type(''):
 594            textList = [textList]
 595         elif len(textList) != len(coords):
 596            raise ValueError('textlist and coords must have same length')
 597         if foregrounds is None:
 598            foregrounds = []
 599         elif isinstance(foregrounds, wx.Colour):
 600            foregrounds = [foregrounds]
 601         elif len(foregrounds) != len(coords):
 602            raise ValueError('foregrounds and coords must have same length')
 603         if backgrounds is None:
 604            backgrounds = []
 605         elif isinstance(backgrounds, wx.Colour):
 606            backgrounds = [backgrounds]
 607         elif len(backgrounds) != len(coords):
 608            raise ValueError('backgrounds and coords must have same length')
 609         return  self._DrawTextList(textList, coords, foregrounds, backgrounds)
 610     }
 611
 612 };
 613
 614
 615
 616 %{
 617 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
 618     *x1 = dc->MinX();
 619     *y1 = dc->MinY();
 620     *x2 = dc->MaxX();
 621     *y2 = dc->MaxY();
 622 }
 623 %}
 624
 625
 626 //---------------------------------------------------------------------------
 627 %newgroup
 628
 629 MustHaveApp(wxMemoryDC);
 630
 631 class wxMemoryDC : public wxDC {
 632 public:
 633     wxMemoryDC();
 634     %name(MemoryDCFromDC) wxMemoryDC(wxDC* oldDC);
 635
 636     void SelectObject(const wxBitmap& bitmap);
 637 };
 638
 639 //---------------------------------------------------------------------------
 640 %newgroup
 641
 642
 643 %{
 644 #include <wx/dcbuffer.h>
 645 %}
 646
 647
 648 MustHaveApp(wxBufferedDC);
 649
 650 class wxBufferedDC : public wxMemoryDC
 651 {
 652 public:
 653     %pythonAppend wxBufferedDC
 654         "self._dc = args[0] # save a ref so the other dc will not be deleted before self";
 655
 656     %nokwargs wxBufferedDC;
 657
 658     // Construct a wxBufferedDC using a user supplied buffer.
 659     wxBufferedDC( wxDC *dc, const wxBitmap &buffer );
 660
 661     // Construct a wxBufferedDC with an internal buffer of 'area'
 662     // (where area is usually something like the size of the window
 663     // being buffered)
 664     wxBufferedDC( wxDC *dc, const wxSize &area );
 665
 666
 667     // TODO: Keep this one too?
 668     %pythonAppend wxBufferedDC( wxDC *dc, const wxSize &area )
 669         "val._dc = args[0] # save a ref so the other dc will not be deleted before self";
 670     %name(BufferedDCInternalBuffer) wxBufferedDC( wxDC *dc, const wxSize &area );
 671
 672
 673     // The buffer is blit to the real DC when the BufferedDC is destroyed.
 674     ~wxBufferedDC();
 675
 676
 677     // Blits the buffer to the dc, and detaches the dc from
 678     // the buffer.  Usually called in the dtor or by the dtor
 679     // of derived classes if the BufferedDC must blit before
 680     // the derived class (which may own the dc it's blitting
 681     // to) is destroyed.
 682     void UnMask();
 683 };
 684
 685
 686
 687 MustHaveApp(wxBufferedPaintDC);
 688
 689 // Creates a double buffered wxPaintDC, optionally allowing the
 690 // user to specify their own buffer to use.
 691 class wxBufferedPaintDC : public wxBufferedDC
 692 {
 693 public:
 694
 695     // If no bitmap is supplied by the user, a temporary one will be created.
 696     wxBufferedPaintDC( wxWindow *window, const wxBitmap &buffer = wxNullBitmap );
 697
 698 };
 699
 700
 701 //---------------------------------------------------------------------------
 702 %newgroup
 703
 704 MustHaveApp(wxScreenDC);
 705
 706 class wxScreenDC : public wxDC {
 707 public:
 708     wxScreenDC();
 709
 710     %name(StartDrawingOnTopWin) bool StartDrawingOnTop(wxWindow* window);
 711     bool StartDrawingOnTop(wxRect* rect = NULL);
 712     bool EndDrawingOnTop();
 713 };
 714
 715 //---------------------------------------------------------------------------
 716 %newgroup
 717
 718 MustHaveApp(wxClientDC);
 719
 720 class wxClientDC : public wxDC {
 721 public:
 722       wxClientDC(wxWindow* win);
 723 };
 724
 725 //---------------------------------------------------------------------------
 726 %newgroup
 727
 728 MustHaveApp(wxPaintDC);
 729
 730 class wxPaintDC : public wxDC {
 731 public:
 732       wxPaintDC(wxWindow* win);
 733 };
 734
 735 //---------------------------------------------------------------------------
 736 %newgroup
 737
 738 MustHaveApp(wxWindowDC);
 739
 740 class wxWindowDC : public wxDC {
 741 public:
 742       wxWindowDC(wxWindow* win);
 743 };
 744
 745 //---------------------------------------------------------------------------
 746 %newgroup
 747
 748 MustHaveApp(wxMirrorDC);
 749
 750 class wxMirrorDC : public wxDC
 751 {
 752 public:
 753     // constructs a mirror DC associated with the given real DC
 754     //
 755     // if mirror parameter is True, all vertical and horizontal coordinates are
 756     // exchanged, otherwise this class behaves in exactly the same way as a
 757     // plain DC
 758     //
 759     wxMirrorDC(wxDC& dc, bool mirror);
 760 };
 761
 762 //---------------------------------------------------------------------------
 763 %newgroup
 764
 765 %{
 766 #include <wx/dcps.h>
 767 %}
 768
 769 MustHaveApp(wxPostScriptDC);
 770
 771 class wxPostScriptDC : public wxDC {
 772 public:
 773     wxPostScriptDC(const wxPrintData& printData);
 774 //     %name(PostScriptDC2)wxPostScriptDC(const wxString& output,
 775 //                                          bool interactive = True,
 776 //                                          wxWindow* parent = NULL);
 777
 778     wxPrintData& GetPrintData();
 779     void SetPrintData(const wxPrintData& data);
 780
 781     static void SetResolution(int ppi);
 782     static int GetResolution();
 783 };
 784
 785 //---------------------------------------------------------------------------
 786 %newgroup
 787
 788
 789 MustHaveApp(wxMetaFile);
 790 MustHaveApp(wxMetaFileDC);
 791
 792
 793 #if defined(__WXMSW__) || defined(__WXMAC__)
 794
 795 %{
 796 #include <wx/metafile.h>
 797 %}
 798
 799 class wxMetaFile : public wxObject {
 800 public:
 801     wxMetaFile(const wxString& filename = wxPyEmptyString);
 802     ~wxMetaFile();
 803
 804     bool Ok();
 805     bool SetClipboard(int width = 0, int height = 0);
 806
 807     wxSize GetSize();
 808     int GetWidth();
 809     int GetHeight();
 810
 811 #ifdef __WXMSW__
 812     const wxString& GetFileName() const;
 813 #endif
 814
 815     %pythoncode { def __nonzero__(self): return self.Ok() }
 816 };
 817
 818 // bool wxMakeMetaFilePlaceable(const wxString& filename,
 819 //                              int minX, int minY, int maxX, int maxY, float scale=1.0);
 820
 821
 822 class wxMetaFileDC : public wxDC {
 823 public:
 824     wxMetaFileDC(const wxString& filename = wxPyEmptyString,
 825                  int width = 0, int height = 0,
 826                  const wxString& description = wxPyEmptyString);
 827     wxMetaFile* Close();
 828 };
 829
 830
 831
 832 #else  // Make some dummies for the other platforms
 833
 834 %{
 835 class wxMetaFile : public wxObject {
 836 public:
 837     wxMetaFile(const wxString&)
 838         { wxPyRaiseNotImplemented(); }
 839 };
 840
 841 class wxMetaFileDC : public wxClientDC {
 842 public:
 843     wxMetaFileDC(const wxString&, int, int, const wxString&)
 844         { wxPyRaiseNotImplemented(); }
 845 };
 846
 847 %}
 848
 849 class wxMetaFile : public wxObject {
 850 public:
 851     wxMetaFile(const wxString& filename = wxPyEmptyString);
 852 };
 853
 854 class wxMetaFileDC : public wxDC {
 855 public:
 856     wxMetaFileDC(const wxString& filename = wxPyEmptyString,
 857                  int width = 0, int height = 0,
 858                  const wxString& description = wxPyEmptyString);
 859 };
 860
 861
 862 #endif
 863
 864
 865 //---------------------------------------------------------------------------
 866
 867 MustHaveApp(wxPrinterDC);
 868
 869 #if defined(__WXMSW__) || defined(__WXMAC__)
 870
 871 class  wxPrinterDC : public wxDC {
 872 public:
 873     wxPrinterDC(const wxPrintData& printData);
 874 //     %name(PrinterDC2) wxPrinterDC(const wxString& driver,
 875 //                                     const wxString& device,
 876 //                                     const wxString& output,
 877 //                                     bool interactive = True,
 878 //                                     int orientation = wxPORTRAIT);
 879 };
 880
 881 #else
 882 %{
 883 class  wxPrinterDC : public wxClientDC {
 884 public:
 885     wxPrinterDC(const wxPrintData&)
 886         { wxPyRaiseNotImplemented(); }
 887
 888 //     wxPrinterDC(const wxString&, const wxString&, const wxString&, bool, int)
 889 //         { wxPyRaiseNotImplemented(); }
 890 };
 891 %}
 892
 893 class  wxPrinterDC : public wxDC {
 894 public:
 895     wxPrinterDC(const wxPrintData& printData);
 896 //     %name(PrinterDC2) wxPrinterDC(const wxString& driver,
 897 //                                     const wxString& device,
 898 //                                     const wxString& output,
 899 //                                     bool interactive = True,
 900 //                                     int orientation = wxPORTRAIT);
 901 };
 902 #endif
 903
 904 //---------------------------------------------------------------------------
 905 //---------------------------------------------------------------------------
 906
 907 // Now define some Python classes that rename the Draw methods to be
 908 // compatible with the DC Draw methods in 2.4.  See also wxPython/_wx.py.
 909
 910
 911 #if 0
 912
 913 %define MAKE_OLD_DC_CLASS(classname)
 914     %pythoncode {
 915     class classname##_old(classname):
 916         """DC class that has methods with 2.4 compatible parameters."""
 917         FloodFill = classname.FloodFillXY
 918         GetPixel = classname.GetPixelXY
 919         DrawLine = classname.DrawLineXY
 920         CrossHair = classname.CrossHairXY
 921         DrawArc = classname.DrawArcXY
 922         DrawCheckMark = classname.DrawCheckMarkXY
 923         DrawEllipticArc = classname.DrawEllipticArcXY
 924         DrawPoint = classname.DrawPointXY
 925         DrawRectangle = classname.DrawRectangleXY
 926         DrawRoundedRectangle = classname.DrawRoundedRectangleXY
 927         DrawCircle = classname.DrawCircleXY
 928         DrawEllipse = classname.DrawEllipseXY
 929         DrawIcon = classname.DrawIconXY
 930         DrawBitmap = classname.DrawBitmapXY
 931         DrawText = classname.DrawTextXY
 932         DrawRotatedText = classname.DrawRotatedTextXY
 933         Blit = classname.BlitXY
 934     }
 935 %enddef
 936
 937 MAKE_OLD_DC_CLASS(DC);
 938 MAKE_OLD_DC_CLASS(MemoryDC);
 939 MAKE_OLD_DC_CLASS(BufferedDC);
 940 MAKE_OLD_DC_CLASS(BufferedPaintDC);
 941 MAKE_OLD_DC_CLASS(ScreenDC);
 942 MAKE_OLD_DC_CLASS(ClientDC);
 943 MAKE_OLD_DC_CLASS(PaintDC);
 944 MAKE_OLD_DC_CLASS(WindowDC);
 945 MAKE_OLD_DC_CLASS(MirrorDC);
 946 MAKE_OLD_DC_CLASS(PostScriptDC);
 947 MAKE_OLD_DC_CLASS(MetaFileDC);
 948 MAKE_OLD_DC_CLASS(PrinterDC);
 949
 950 #endif
 951
 952 //---------------------------------------------------------------------------