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