]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/_dc.i
Update SWIG patch to output "True" ("False") in the autodoc string
[wxWidgets.git] / 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 DocStr(wxDC,
42 "A wx.DC is a device context onto which graphics and text can be
43 drawn. It is intended to represent a number of output devices in a
44 generic way, so a window can have a device context associated with it,
45 and a printer also has a device context. In this way, the same piece
46 of code may write to a number of different devices, if the device
47 context is used as a parameter.
48
49 Derived types of wxDC have documentation for specific features only,
50 so refer to this section for most device context information.
51
52 The wx.DC class is abstract and can not be instantiated, you must use
53 one of the derived classes instead. Which one will depend on the
54 situation in which it is used.", "");
55
56 class wxDC : public wxObject {
57 public:
58 // wxDC(); **** abstract base class, can't instantiate.
59 ~wxDC();
60
61
62 DocDeclStr(
63 virtual void , BeginDrawing(),
64 "Allows for optimization of drawing code on platforms that need it. On
65 other platforms this is just an empty function and is harmless. To
66 take advantage of this postential optimization simply enclose each
67 group of calls to the drawing primitives within calls to
68 `BeginDrawing` and `EndDrawing`.", "");
69
70 DocDeclStr(
71 virtual void , EndDrawing(),
72 "Ends the group of drawing primitives started with `BeginDrawing`, and
73 invokes whatever optimization is available for this DC type on the
74 current platform.", "");
75
76
77
78 // TODO virtual void DrawObject(wxDrawObject* drawobject);
79
80
81 DocStr(
82 FloodFill,
83 "Flood fills the device context starting from the given point, using
84 the current brush colour, and using a style:
85
86 - **wxFLOOD_SURFACE**: the flooding occurs until a colour other than
87 the given colour is encountered.
88
89 - **wxFLOOD_BORDER**: the area to be flooded is bounded by the given
90 colour.
91
92 Returns False if the operation failed.
93
94 Note: The present implementation for non-Windows platforms may fail to
95 find colour borders if the pixels do not match the colour
96 exactly. However the function will still return true.", "");
97 bool FloodFill(wxCoord x, wxCoord y, const wxColour& col, int style = wxFLOOD_SURFACE);
98 %name(FloodFillPoint) bool FloodFill(const wxPoint& pt, const wxColour& col, int style = wxFLOOD_SURFACE);
99
100
101 DocStr(
102 GetPixel,
103 "Gets the colour at the specified location on the DC.","");
104 %extend {
105 wxColour GetPixel(wxCoord x, wxCoord y) {
106 wxColour col;
107 self->GetPixel(x, y, &col);
108 return col;
109 }
110 wxColour GetPixelPoint(const wxPoint& pt) {
111 wxColour col;
112 self->GetPixel(pt, &col);
113 return col;
114 }
115 }
116
117
118 DocStr(
119 DrawLine,
120 "Draws a line from the first point to the second. The current pen is
121 used for drawing the line. Note that the second point is *not* part of
122 the line and is not drawn by this function (this is consistent with
123 the behaviour of many other toolkits).", "");
124 void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
125 %name(DrawLinePoint) void DrawLine(const wxPoint& pt1, const wxPoint& pt2);
126
127
128 DocStr(
129 CrossHair,
130 "Displays a cross hair using the current pen. This is a vertical and
131 horizontal line the height and width of the window, centred on the
132 given point.", "");
133 void CrossHair(wxCoord x, wxCoord y);
134 %name(CrossHairPoint) void CrossHair(const wxPoint& pt);
135
136
137 DocStr(
138 DrawArc,
139 "Draws an arc of a circle, centred on the *center* point (xc, yc), from
140 the first point to the second. The current pen is used for the outline
141 and the current brush for filling the shape.
142
143 The arc is drawn in an anticlockwise direction from the start point to
144 the end point.", "");
145 void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc);
146 %name(DrawArcPoint) void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& center);
147
148
149 DocStr(
150 DrawCheckMark,
151 "Draws a check mark inside the given rectangle.", "");
152 void DrawCheckMark(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
153 %name(DrawCheckMarkRect) void DrawCheckMark(const wxRect& rect);
154
155 DocStr(
156 DrawEllipticArc,
157 "Draws an arc of an ellipse, with the given rectangle defining the
158 bounds of the ellipse. The current pen is used for drawing the arc and
159 the current brush is used for drawing the pie.
160
161 The *start* and *end* parameters specify the start and end of the arc
162 relative to the three-o'clock position from the center of the
163 rectangle. Angles are specified in degrees (360 is a complete
164 circle). Positive values mean counter-clockwise motion. If start is
165 equal to end, a complete ellipse will be drawn.", "");
166 void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h, double start, double end);
167 %name(DrawEllipticArcPointSize) void DrawEllipticArc(const wxPoint& pt, const wxSize& sz, double start, double end);
168
169
170 DocStr(
171 DrawPoint,
172 "Draws a point using the current pen.", "");
173 void DrawPoint(wxCoord x, wxCoord y);
174 %name(DrawPointPoint) void DrawPoint(const wxPoint& pt);
175
176
177 DocStr(
178 DrawRectangle,
179 "Draws a rectangle with the given top left corner, and with the given
180 size. The current pen is used for the outline and the current brush
181 for filling the shape.", "");
182 void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
183 %name(DrawRectangleRect)void DrawRectangle(const wxRect& rect);
184 %name(DrawRectanglePointSize) void DrawRectangle(const wxPoint& pt, const wxSize& sz);
185
186
187 DocStr(
188 DrawRoundedRectangle,
189 "Draws a rectangle with the given top left corner, and with the given
190 size. The corners are quarter-circles using the given radius. The
191 current pen is used for the outline and the current brush for filling
192 the shape.
193
194 If radius is positive, the value is assumed to be the radius of the
195 rounded corner. If radius is negative, the absolute value is assumed
196 to be the proportion of the smallest dimension of the rectangle. This
197 means that the corner can be a sensible size relative to the size of
198 the rectangle, and also avoids the strange effects X produces when the
199 corners are too big for the rectangle.", "");
200 void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius);
201 %name(DrawRoundedRectangleRect) void DrawRoundedRectangle(const wxRect& r, double radius);
202 %name(DrawRoundedRectanglePointSize) void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz, double radius);
203
204
205 DocStr(
206 DrawCircle,
207 "Draws a circle with the given center point and radius. The current
208 pen is used for the outline and the current brush for filling the
209 shape.", "
210
211 :see: `DrawEllipse`");
212 void DrawCircle(wxCoord x, wxCoord y, wxCoord radius);
213 %name(DrawCirclePoint) void DrawCircle(const wxPoint& pt, wxCoord radius);
214
215
216 DocStr(
217 DrawEllipse,
218 "Draws an ellipse contained in the specified rectangle. The current pen
219 is used for the outline and the current brush for filling the shape.", "
220
221 :see: `DrawCircle`");
222 void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
223 %name(DrawEllipseRect) void DrawEllipse(const wxRect& rect);
224 %name(DrawEllipsePointSize) void DrawEllipse(const wxPoint& pt, const wxSize& sz);
225
226
227 DocStr(
228 DrawIcon,
229 "Draw an icon on the display (does nothing if the device context is
230 PostScript). This can be the simplest way of drawing bitmaps on a
231 window.", "");
232 void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y);
233 %name(DrawIconPoint) void DrawIcon(const wxIcon& icon, const wxPoint& pt);
234
235
236 DocStr(
237 DrawBitmap,
238 "Draw a bitmap on the device context at the specified point. If
239 *transparent* is true and the bitmap has a transparency mask, (or
240 alpha channel on the platforms that support it) then the bitmap will
241 be drawn transparently.", "
242
243 When drawing a mono-bitmap, the current text foreground colour will be
244 used to draw the foreground of the bitmap (all bits set to 1), and the
245 current text background colour to draw the background (all bits set to
246 0).
247
248 :see: `SetTextForeground`, `SetTextBackground` and `wx.MemoryDC`");
249 void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask = false);
250 %name(DrawBitmapPoint) void DrawBitmap(const wxBitmap &bmp, const wxPoint& pt, bool useMask = false);
251
252
253 DocStr(
254 DrawText,
255 "Draws a text string at the specified point, using the current text
256 font, and the current text foreground and background colours.
257
258 The coordinates refer to the top-left corner of the rectangle bounding
259 the string. See `GetTextExtent` for how to get the dimensions of a
260 text string, which can be used to position the text more precisely.
261
262 **NOTE**: under wxGTK the current logical function is used by this
263 function but it is ignored by wxMSW. Thus, you should avoid using
264 logical functions with this function in portable programs.", "
265
266 :see: `DrawRotatedText`");
267 void DrawText(const wxString& text, wxCoord x, wxCoord y);
268 %name(DrawTextPoint) void DrawText(const wxString& text, const wxPoint& pt);
269
270
271 DocStr(
272 DrawRotatedText,
273 "Draws the text rotated by *angle* degrees, if supported by the platform.
274
275 **NOTE**: Under Win9x only TrueType fonts can be drawn by this
276 function. In particular, a font different from ``wx.NORMAL_FONT``
277 should be used as the it is not normally a TrueType
278 font. ``wx.SWISS_FONT`` is an example of a font which is.","
279
280 :see: `DrawText`");
281 void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle);
282 %name(DrawRotatedTextPoint) void DrawRotatedText(const wxString& text, const wxPoint& pt, double angle);
283
284
285 DocDeclStr(
286 bool , Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
287 wxDC *source, wxCoord xsrc, wxCoord ysrc,
288 int rop = wxCOPY, bool useMask = false,
289 wxCoord xsrcMask = -1, wxCoord ysrcMask = -1),
290 "Copy from a source DC to this DC. Parameters specify the destination
291 coordinates, size of area to copy, source DC, source coordinates,
292 logical function, whether to use a bitmap mask, and mask source
293 position.", "
294
295 :param xdest: Destination device context x position.
296 :param ydest: Destination device context y position.
297 :param width: Width of source area to be copied.
298 :param height: Height of source area to be copied.
299 :param source: Source device context.
300 :param xsrc: Source device context x position.
301 :param ysrc: Source device context y position.
302 :param rop: Logical function to use: see `SetLogicalFunction`.
303 :param useMask: If true, Blit does a transparent blit using the mask
304 that is associated with the bitmap selected into the
305 source device context.
306 :param xsrcMask: Source x position on the mask. If both xsrcMask and
307 ysrcMask are -1, xsrc and ysrc will be assumed for
308 the mask source position.
309 :param ysrcMask: Source y position on the mask.
310 ");
311
312 DocDeclStrName(
313 bool , Blit(const wxPoint& destPt, const wxSize& sz,
314 wxDC *source, const wxPoint& srcPt,
315 int rop = wxCOPY, bool useMask = false,
316 const wxPoint& srcPtMask = wxDefaultPosition),
317 "Copy from a source DC to this DC. Parameters specify the destination
318 coordinates, size of area to copy, source DC, source coordinates,
319 logical function, whether to use a bitmap mask, and mask source
320 position.", "
321
322 :param destPt: Destination device context position.
323 :param sz: Size of source area to be copied.
324 :param source: Source device context.
325 :param srcPt: Source device context position.
326 :param rop: Logical function to use: see `SetLogicalFunction`.
327 :param useMask: If true, Blit does a transparent blit using the mask
328 that is associated with the bitmap selected into the
329 source device context.
330 :param srcPtMask: Source position on the mask.
331 ",
332 BlitPointSize);
333
334
335 DocStr(
336 SetClippingRegion,
337 "Sets the clipping region for this device context to the intersection
338 of the given region described by the parameters of this method and the
339 previously set clipping region. You should call `DestroyClippingRegion`
340 if you want to set the clipping region exactly to the region
341 specified.
342
343 The clipping region is an area to which drawing is
344 restricted. Possible uses for the clipping region are for clipping
345 text or for speeding up window redraws when only a known area of the
346 screen is damaged.", "
347
348 :see: `DestroyClippingRegion`, `wx.Region`");
349 void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
350 %name(SetClippingRegionPointSize) void SetClippingRegion(const wxPoint& pt, const wxSize& sz);
351 %name(SetClippingRegionAsRegion) void SetClippingRegion(const wxRegion& region);
352 %name(SetClippingRect) void SetClippingRegion(const wxRect& rect);
353
354
355
356 DocDeclAStr(
357 void , DrawLines(int points, wxPoint* points_array,
358 wxCoord xoffset = 0, wxCoord yoffset = 0),
359 "DrawLines(self, List points, int xoffset=0, int yoffset=0)",
360 "Draws lines using a sequence of `wx.Point` objects, adding the
361 optional offset coordinate. The current pen is used for drawing the
362 lines.", "");
363
364
365 DocDeclAStr(
366 void , DrawPolygon(int points, wxPoint* points_array,
367 wxCoord xoffset = 0, wxCoord yoffset = 0,
368 int fillStyle = wxODDEVEN_RULE),
369 "DrawPolygon(self, List points, int xoffset=0, int yoffset=0,
370 int fillStyle=ODDEVEN_RULE)",
371 "Draws a filled polygon using a sequence of `wx.Point` objects, adding
372 the optional offset coordinate. The last argument specifies the fill
373 rule: ``wx.ODDEVEN_RULE`` (the default) or ``wx.WINDING_RULE``.
374
375 The current pen is used for drawing the outline, and the current brush
376 for filling the shape. Using a transparent brush suppresses
377 filling. Note that wxWidgets automatically closes the first and last
378 points.", "");
379
380
381 // TODO: Figure out a good typemap for this...
382 // Convert the first 3 args from a sequence of sequences?
383 // void DrawPolyPolygon(int n, int count[], wxPoint points[],
384 // wxCoord xoffset = 0, wxCoord yoffset = 0,
385 // int fillStyle = wxODDEVEN_RULE);
386
387
388 DocDeclStr(
389 void , DrawLabel(const wxString& text, const wxRect& rect,
390 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
391 int indexAccel = -1),
392 "Draw *text* within the specified rectangle, abiding by the alignment
393 flags. Will additionally emphasize the character at *indexAccel* if
394 it is not -1.", "
395
396 :see: `DrawImageLabel`");
397
398
399 %extend {
400 DocStr(DrawImageLabel,
401 "Draw *text* and an image (which may be ``wx.NullBitmap`` to skip
402 drawing it) within the specified rectangle, abiding by the alignment
403 flags. Will additionally emphasize the character at *indexAccel* if
404 it is not -1. Returns the bounding rectangle.", "");
405 wxRect DrawImageLabel(const wxString& text,
406 const wxBitmap& image,
407 const wxRect& rect,
408 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
409 int indexAccel = -1) {
410 wxRect rv;
411 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
412 return rv;
413 }
414 }
415
416
417
418 DocDeclAStr(
419 void , DrawSpline(int points, wxPoint* points_array),
420 "DrawSpline(self, List points)",
421 "Draws a spline between all given control points, (a list of `wx.Point`
422 objects) using the current pen. The spline is drawn using a series of
423 lines, using an algorithm taken from the X drawing program 'XFIG'.", "");
424
425
426
427
428 // global DC operations
429 // --------------------
430
431 DocDeclStr(
432 virtual void , Clear(),
433 "Clears the device context using the current background brush.", "");
434
435
436 DocDeclStr(
437 virtual bool , StartDoc(const wxString& message),
438 "Starts a document (only relevant when outputting to a
439 printer). *Message* is a message to show whilst printing.", "");
440
441 DocDeclStr(
442 virtual void , EndDoc(),
443 "Ends a document (only relevant when outputting to a printer).", "");
444
445
446 DocDeclStr(
447 virtual void , StartPage(),
448 "Starts a document page (only relevant when outputting to a printer).", "");
449
450 DocDeclStr(
451 virtual void , EndPage(),
452 "Ends a document page (only relevant when outputting to a printer).", "");
453
454
455
456 // set objects to use for drawing
457 // ------------------------------
458
459 DocDeclStr(
460 virtual void , SetFont(const wxFont& font),
461 "Sets the current font for the DC. It must be a valid font, in
462 particular you should not pass ``wx.NullFont`` to this method.","
463
464 :see: `wx.Font`");
465
466 DocDeclStr(
467 virtual void , SetPen(const wxPen& pen),
468 "Sets the current pen for the DC.
469
470 If the argument is ``wx.NullPen``, the current pen is selected out of the
471 device context, and the original pen restored.", "
472
473 :see: `wx.Pen`");
474
475 DocDeclStr(
476 virtual void , SetBrush(const wxBrush& brush),
477 "Sets the current brush for the DC.
478
479 If the argument is ``wx.NullBrush``, the current brush is selected out
480 of the device context, and the original brush restored, allowing the
481 current brush to be destroyed safely.","
482
483 :see: `wx.Brush`");
484
485 DocDeclStr(
486 virtual void , SetBackground(const wxBrush& brush),
487 "Sets the current background brush for the DC.", "");
488
489 DocDeclStr(
490 virtual void , SetBackgroundMode(int mode),
491 "*mode* may be one of ``wx.SOLID`` and ``wx.TRANSPARENT``. This setting
492 determines whether text will be drawn with a background colour or
493 not.", "");
494
495 DocDeclStr(
496 virtual void , SetPalette(const wxPalette& palette),
497 "If this is a window DC or memory DC, assigns the given palette to the
498 window or bitmap associated with the DC. If the argument is
499 ``wx.NullPalette``, the current palette is selected out of the device
500 context, and the original palette restored.", "
501
502 :see: `wx.Palette`");
503
504
505
506 DocDeclStr(
507 virtual void , DestroyClippingRegion(),
508 "Destroys the current clipping region so that none of the DC is
509 clipped.", "
510
511 :see: `SetClippingRegion`");
512
513
514 DocDeclAStr(
515 void, GetClippingBox(wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord *OUTPUT) const,
516 "GetClippingBox() -> (x, y, width, height)",
517 "Gets the rectangle surrounding the current clipping region.", "");
518
519 %extend {
520 DocStr(
521 GetClippingRect,
522 "Gets the rectangle surrounding the current clipping region.", "");
523 wxRect GetClippingRect() {
524 wxRect rect;
525 self->GetClippingBox(rect);
526 return rect;
527 }
528 }
529
530
531
532 // text extent
533 // -----------
534
535 DocDeclStr(
536 virtual wxCoord , GetCharHeight() const,
537 "Gets the character height of the currently set font.", "");
538
539 DocDeclStr(
540 virtual wxCoord , GetCharWidth() const,
541 "Gets the average character width of the currently set font.", "");
542
543
544
545 DocDeclAStr(
546 void, GetTextExtent(const wxString& string, wxCoord *OUTPUT, wxCoord *OUTPUT),
547 "GetTextExtent(wxString string) -> (width, height)",
548 "Get the width and height of the text using the current font. Only
549 works for single line strings.", "");
550
551 DocDeclAStrName(
552 void, GetTextExtent(const wxString& string,
553 wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord* OUTPUT,
554 wxFont* font = NULL),
555 "GetFullTextExtent(wxString string, Font font=None) ->\n (width, height, descent, externalLeading)",
556 "Get the width, height, decent and leading of the text using the
557 current or specified font. Only works for single line strings.", "",
558 GetFullTextExtent);
559
560
561 // works for single as well as multi-line strings
562 DocDeclAStr(
563 void, GetMultiLineTextExtent(const wxString& text,
564 wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord *OUTPUT,
565 wxFont *font = NULL),
566 "GetMultiLineTextExtent(wxString string, Font font=None) ->\n (width, height, descent, externalLeading)",
567 "Get the width, height, decent and leading of the text using the
568 current or specified font. Works for single as well as multi-line
569 strings.", "");
570
571
572 %extend {
573 DocAStr(GetPartialTextExtents,
574 "GetPartialTextExtents(self, text) -> [widths]",
575 "Returns a list of integers such that each value is the distance in
576 pixels from the begining of text to the coresponding character of
577 *text*. The generic version simply builds a running total of the widths
578 of each character using GetTextExtent, however if the various
579 platforms have a native API function that is faster or more accurate
580 than the generic implementaiton then it will be used instead.", "");
581 wxArrayInt GetPartialTextExtents(const wxString& text) {
582 wxArrayInt widths;
583 self->GetPartialTextExtents(text, widths);
584 return widths;
585 }
586 }
587
588
589 // size and resolution
590 // -------------------
591
592 DocStr(
593 GetSize,
594 "This gets the horizontal and vertical resolution in device units. It
595 can be used to scale graphics to fit the page. For example, if *maxX*
596 and *maxY* represent the maximum horizontal and vertical 'pixel' values
597 used in your application, the following code will scale the graphic to
598 fit on the printer page::
599
600 w, h = dc.GetSize()
601 scaleX = maxX*1.0 / w
602 scaleY = maxY*1.0 / h
603 dc.SetUserScale(min(scaleX,scaleY),min(scaleX,scaleY))
604 ", "");
605 wxSize GetSize();
606 DocDeclAName(
607 void, GetSize( int *OUTPUT, int *OUTPUT ),
608 "GetSizeTuple() -> (width, height)",
609 GetSizeTuple);
610
611
612 DocStr(GetSizeMM, "Get the DC size in milimeters.", "");
613 wxSize GetSizeMM() const;
614 DocDeclAName(
615 void, GetSizeMM( int *OUTPUT, int *OUTPUT ) const,
616 "GetSizeMMTuple() -> (width, height)",
617 GetSizeMMTuple);
618
619
620
621 // coordinates conversions
622 // -----------------------
623
624 DocDeclStr(
625 wxCoord , DeviceToLogicalX(wxCoord x) const,
626 "Convert device X coordinate to logical coordinate, using the current
627 mapping mode.", "");
628
629 DocDeclStr(
630 wxCoord , DeviceToLogicalY(wxCoord y) const,
631 "Converts device Y coordinate to logical coordinate, using the current
632 mapping mode.", "");
633
634 DocDeclStr(
635 wxCoord , DeviceToLogicalXRel(wxCoord x) const,
636 "Convert device X coordinate to relative logical coordinate, using the
637 current mapping mode but ignoring the x axis orientation. Use this
638 function for converting a width, for example.", "");
639
640 DocDeclStr(
641 wxCoord , DeviceToLogicalYRel(wxCoord y) const,
642 "Convert device Y coordinate to relative logical coordinate, using the
643 current mapping mode but ignoring the y axis orientation. Use this
644 function for converting a height, for example.", "");
645
646 DocDeclStr(
647 wxCoord , LogicalToDeviceX(wxCoord x) const,
648 "Converts logical X coordinate to device coordinate, using the current
649 mapping mode.", "");
650
651 DocDeclStr(
652 wxCoord , LogicalToDeviceY(wxCoord y) const,
653 "Converts logical Y coordinate to device coordinate, using the current
654 mapping mode.", "");
655
656 DocDeclStr(
657 wxCoord , LogicalToDeviceXRel(wxCoord x) const,
658 "Converts logical X coordinate to relative device coordinate, using the
659 current mapping mode but ignoring the x axis orientation. Use this for
660 converting a width, for example.", "");
661
662 DocDeclStr(
663 wxCoord , LogicalToDeviceYRel(wxCoord y) const,
664 "Converts logical Y coordinate to relative device coordinate, using the
665 current mapping mode but ignoring the y axis orientation. Use this for
666 converting a height, for example.", "");
667
668
669
670 // query DC capabilities
671 // ---------------------
672
673 virtual bool CanDrawBitmap() const;
674 virtual bool CanGetTextExtent() const;
675
676
677 DocDeclStr(
678 virtual int , GetDepth() const,
679 "Returns the colour depth of the DC.", "");
680
681
682 DocDeclStr(
683 virtual wxSize , GetPPI() const,
684 "Resolution in Pixels per inch", "");
685
686
687 DocDeclStr(
688 virtual bool , Ok() const,
689 "Returns true if the DC is ok to use.", "");
690
691
692
693 DocDeclStr(
694 int , GetBackgroundMode() const,
695 "Returns the current background mode, either ``wx.SOLID`` or
696 ``wx.TRANSPARENT``.","
697
698 :see: `SetBackgroundMode`");
699
700 DocDeclStr(
701 const wxBrush& , GetBackground() const,
702 "Gets the brush used for painting the background.","
703
704 :see: `SetBackground`");
705
706 DocDeclStr(
707 const wxBrush& , GetBrush() const,
708 "Gets the current brush", "");
709
710 DocDeclStr(
711 const wxFont& , GetFont() const,
712 "Gets the current font", "");
713
714 DocDeclStr(
715 const wxPen& , GetPen() const,
716 "Gets the current pen", "");
717
718 DocDeclStr(
719 const wxColour& , GetTextBackground() const,
720 "Gets the current text background colour", "");
721
722 DocDeclStr(
723 const wxColour& , GetTextForeground() const,
724 "Gets the current text foreground colour", "");
725
726
727 DocDeclStr(
728 virtual void , SetTextForeground(const wxColour& colour),
729 "Sets the current text foreground colour for the DC.", "");
730
731 DocDeclStr(
732 virtual void , SetTextBackground(const wxColour& colour),
733 "Sets the current text background colour for the DC.", "");
734
735
736 DocDeclStr(
737 int , GetMapMode() const,
738 "Gets the current *mapping mode* for the device context ", "");
739
740 DocDeclStr(
741 virtual void , SetMapMode(int mode),
742 "The *mapping mode* of the device context defines the unit of
743 measurement used to convert logical units to device units. The
744 mapping mode can be one of the following:
745
746 ================ =============================================
747 wx.MM_TWIPS Each logical unit is 1/20 of a point, or 1/1440
748 of an inch.
749 wx.MM_POINTS Each logical unit is a point, or 1/72 of an inch.
750 wx.MM_METRIC Each logical unit is 1 mm.
751 wx.MM_LOMETRIC Each logical unit is 1/10 of a mm.
752 wx.MM_TEXT Each logical unit is 1 pixel.
753 ================ =============================================
754 ","
755 Note that in X, text drawing isn't handled consistently with the
756 mapping mode; a font is always specified in point size. However,
757 setting the user scale (see `SetUserScale`) scales the text
758 appropriately. In Windows, scalable TrueType fonts are always used; in
759 X, results depend on availability of fonts, but usually a reasonable
760 match is found.
761
762 The coordinate origin is always at the top left of the screen/printer.
763
764 Drawing to a Windows printer device context uses the current mapping
765 mode, but mapping mode is currently ignored for PostScript output.
766 ");
767
768
769
770 DocDeclAStr(
771 virtual void, GetUserScale(double *OUTPUT, double *OUTPUT) const,
772 "GetUserScale(self) -> (xScale, yScale)",
773 "Gets the current user scale factor (set by `SetUserScale`).", "");
774
775 DocDeclStr(
776 virtual void , SetUserScale(double x, double y),
777 "Sets the user scaling factor, useful for applications which require
778 'zooming'.", "");
779
780
781
782 DocDeclA(
783 virtual void, GetLogicalScale(double *OUTPUT, double *OUTPUT),
784 "GetLogicalScale() -> (xScale, yScale)");
785
786 virtual void SetLogicalScale(double x, double y);
787
788
789 wxPoint GetLogicalOrigin() const;
790 DocDeclAName(
791 void, GetLogicalOrigin(wxCoord *OUTPUT, wxCoord *OUTPUT) const,
792 "GetLogicalOriginTuple() -> (x,y)",
793 GetLogicalOriginTuple);
794
795 virtual void SetLogicalOrigin(wxCoord x, wxCoord y);
796 %extend {
797 void SetLogicalOriginPoint(const wxPoint& point) {
798 self->SetLogicalOrigin(point.x, point.y);
799 }
800 }
801
802
803 wxPoint GetDeviceOrigin() const;
804 DocDeclAName(
805 void, GetDeviceOrigin(wxCoord *OUTPUT, wxCoord *OUTPUT) const,
806 "GetDeviceOriginTuple() -> (x,y)",
807 GetDeviceOriginTuple);
808
809 virtual void SetDeviceOrigin(wxCoord x, wxCoord y);
810 %extend {
811 void SetDeviceOriginPoint(const wxPoint& point) {
812 self->SetDeviceOrigin(point.x, point.y);
813 }
814 }
815
816 DocDeclStr(
817 virtual void , SetAxisOrientation(bool xLeftRight, bool yBottomUp),
818 "Sets the x and y axis orientation (i.e., the direction from lowest to
819 highest values on the axis). The default orientation is the natural
820 orientation, e.g. x axis from left to right and y axis from bottom up.", "");
821
822
823 DocDeclStr(
824 int , GetLogicalFunction() const,
825 "Gets the current logical function (set by `SetLogicalFunction`).", "");
826
827 DocDeclStr(
828 virtual void , SetLogicalFunction(int function),
829 "Sets the current logical function for the device context. This
830 determines how a source pixel (from a pen or brush colour, or source
831 device context if using `Blit`) combines with a destination pixel in
832 the current device context.
833
834 The possible values and their meaning in terms of source and
835 destination pixel values are as follows:
836
837 ================ ==========================
838 wx.AND src AND dst
839 wx.AND_INVERT (NOT src) AND dst
840 wx.AND_REVERSE src AND (NOT dst)
841 wx.CLEAR 0
842 wx.COPY src
843 wx.EQUIV (NOT src) XOR dst
844 wx.INVERT NOT dst
845 wx.NAND (NOT src) OR (NOT dst)
846 wx.NOR (NOT src) AND (NOT dst)
847 wx.NO_OP dst
848 wx.OR src OR dst
849 wx.OR_INVERT (NOT src) OR dst
850 wx.OR_REVERSE src OR (NOT dst)
851 wx.SET 1
852 wx.SRC_INVERT NOT src
853 wx.XOR src XOR dst
854 ================ ==========================
855
856 The default is wx.COPY, which simply draws with the current
857 colour. The others combine the current colour and the background using
858 a logical operation. wx.INVERT is commonly used for drawing rubber
859 bands or moving outlines, since drawing twice reverts to the original
860 colour.
861 ", "");
862
863
864 DocDeclStr(
865 virtual void , SetOptimization(bool optimize),
866 "If *optimize* is true this function sets optimization mode on. This
867 currently means that under X, the device context will not try to set a
868 pen or brush property if it is known to be set already. This approach
869 can fall down if non-wxWidgets code is using the same device context
870 or window, for example when the window is a panel on which the
871 windowing system draws panel items. The wxWidgets device context
872 'memory' will now be out of step with reality.
873
874 Setting optimization off, drawing, then setting it back on again, is a
875 trick that must occasionally be employed.", "");
876
877 DocDeclStr(
878 virtual bool , GetOptimization(),
879 "Returns true if device context optimization is on. See
880 `SetOptimization` for details.", "");
881
882
883
884 // bounding box
885 // ------------
886
887 DocDeclStr(
888 virtual void , CalcBoundingBox(wxCoord x, wxCoord y),
889 "Adds the specified point to the bounding box which can be retrieved
890 with `MinX`, `MaxX` and `MinY`, `MaxY` or `GetBoundingBox` functions.", "");
891
892 %extend {
893 DocStr(CalcBoundingBoxPoint,
894 "Adds the specified point to the bounding box which can be retrieved
895 with `MinX`, `MaxX` and `MinY`, `MaxY` or `GetBoundingBox` functions.","");
896 void CalcBoundingBoxPoint(const wxPoint& point) {
897 self->CalcBoundingBox(point.x, point.y);
898 }
899 }
900
901 DocDeclStr(
902 void , ResetBoundingBox(),
903 "Resets the bounding box: after a call to this function, the bounding
904 box doesn't contain anything.", "");
905
906
907 // Get the final bounding box of the PostScript or Metafile picture.
908 DocDeclStr(
909 wxCoord , MinX() const,
910 "Gets the minimum horizontal extent used in drawing commands so far.", "");
911
912 DocDeclStr(
913 wxCoord , MaxX() const,
914 "Gets the maximum horizontal extent used in drawing commands so far.", "");
915
916 DocDeclStr(
917 wxCoord , MinY() const,
918 "Gets the minimum vertical extent used in drawing commands so far.", "");
919
920 DocDeclStr(
921 wxCoord , MaxY() const,
922 "Gets the maximum vertical extent used in drawing commands so far.", "");
923
924
925
926 DocAStr(GetBoundingBox,
927 "GetBoundingBox() -> (x1,y1, x2,y2)",
928 "Returns the min and max points used in drawing commands so far.", "");
929 %extend {
930 void GetBoundingBox(int* OUTPUT, int* OUTPUT, int* OUTPUT, int* OUTPUT);
931 // See below for implementation
932 }
933
934 %pythoncode { def __nonzero__(self): return self.Ok() };
935
936
937 #ifdef __WXMSW__
938 long GetHDC();
939 #endif
940
941
942 %extend { // See drawlist.cpp for impplementaion of these...
943 PyObject* _DrawPointList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
944 {
945 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
946 }
947
948 PyObject* _DrawLineList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
949 {
950 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
951 }
952
953 PyObject* _DrawRectangleList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
954 {
955 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
956 }
957
958 PyObject* _DrawEllipseList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
959 {
960 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
961 }
962
963 PyObject* _DrawPolygonList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
964 {
965 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
966 }
967
968 PyObject* _DrawTextList(PyObject* textList, PyObject* pyPoints,
969 PyObject* foregroundList, PyObject* backgroundList) {
970 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
971 }
972 }
973
974 %pythoncode {
975 def DrawPointList(self, points, pens=None):
976 """
977 Draw a list of points as quickly as possible.
978
979 :param points: A sequence of 2-element sequences representing
980 each point to draw, (x,y).
981 :param pens: If None, then the current pen is used. If a
982 single pen then it will be used for all points. If
983 a list of pens then there should be one for each point
984 in points.
985 """
986 if pens is None:
987 pens = []
988 elif isinstance(pens, wx.Pen):
989 pens = [pens]
990 elif len(pens) != len(points):
991 raise ValueError('points and pens must have same length')
992 return self._DrawPointList(points, pens, [])
993
994
995 def DrawLineList(self, lines, pens=None):
996 """
997 Draw a list of lines as quickly as possible.
998
999 :param lines: A sequence of 4-element sequences representing
1000 each line to draw, (x1,y1, x2,y2).
1001 :param pens: If None, then the current pen is used. If a
1002 single pen then it will be used for all lines. If
1003 a list of pens then there should be one for each line
1004 in lines.
1005 """
1006 if pens is None:
1007 pens = []
1008 elif isinstance(pens, wx.Pen):
1009 pens = [pens]
1010 elif len(pens) != len(lines):
1011 raise ValueError('lines and pens must have same length')
1012 return self._DrawLineList(lines, pens, [])
1013
1014
1015 def DrawRectangleList(self, rectangles, pens=None, brushes=None):
1016 """
1017 Draw a list of rectangles as quickly as possible.
1018
1019 :param rectangles: A sequence of 4-element sequences representing
1020 each rectangle to draw, (x,y, w,h).
1021 :param pens: If None, then the current pen is used. If a
1022 single pen then it will be used for all rectangles.
1023 If a list of pens then there should be one for each
1024 rectangle in rectangles.
1025 :param brushes: A brush or brushes to be used to fill the rectagles,
1026 with similar semantics as the pens parameter.
1027 """
1028 if pens is None:
1029 pens = []
1030 elif isinstance(pens, wx.Pen):
1031 pens = [pens]
1032 elif len(pens) != len(rectangles):
1033 raise ValueError('rectangles and pens must have same length')
1034 if brushes is None:
1035 brushes = []
1036 elif isinstance(brushes, wx.Brush):
1037 brushes = [brushes]
1038 elif len(brushes) != len(rectangles):
1039 raise ValueError('rectangles and brushes must have same length')
1040 return self._DrawRectangleList(rectangles, pens, brushes)
1041
1042
1043 def DrawEllipseList(self, ellipses, pens=None, brushes=None):
1044 """
1045 Draw a list of ellipses as quickly as possible.
1046
1047 :param ellipses: A sequence of 4-element sequences representing
1048 each ellipse to draw, (x,y, w,h).
1049 :param pens: If None, then the current pen is used. If a
1050 single pen then it will be used for all ellipses.
1051 If a list of pens then there should be one for each
1052 ellipse in ellipses.
1053 :param brushes: A brush or brushes to be used to fill the ellipses,
1054 with similar semantics as the pens parameter.
1055 """
1056 if pens is None:
1057 pens = []
1058 elif isinstance(pens, wx.Pen):
1059 pens = [pens]
1060 elif len(pens) != len(ellipses):
1061 raise ValueError('ellipses and pens must have same length')
1062 if brushes is None:
1063 brushes = []
1064 elif isinstance(brushes, wx.Brush):
1065 brushes = [brushes]
1066 elif len(brushes) != len(ellipses):
1067 raise ValueError('ellipses and brushes must have same length')
1068 return self._DrawEllipseList(ellipses, pens, brushes)
1069
1070
1071 def DrawPolygonList(self, polygons, pens=None, brushes=None):
1072 """
1073 Draw a list of polygons, each of which is a list of points.
1074
1075 :param polygons: A sequence of sequences of sequences.
1076 [[(x1,y1),(x2,y2),(x3,y3)...],
1077 [(x1,y1),(x2,y2),(x3,y3)...]]
1078
1079 :param pens: If None, then the current pen is used. If a
1080 single pen then it will be used for all polygons.
1081 If a list of pens then there should be one for each
1082 polygon.
1083 :param brushes: A brush or brushes to be used to fill the polygons,
1084 with similar semantics as the pens parameter.
1085 """
1086 if pens is None:
1087 pens = []
1088 elif isinstance(pens, wx.Pen):
1089 pens = [pens]
1090 elif len(pens) != len(polygons):
1091 raise ValueError('polygons and pens must have same length')
1092 if brushes is None:
1093 brushes = []
1094 elif isinstance(brushes, wx.Brush):
1095 brushes = [brushes]
1096 elif len(brushes) != len(polygons):
1097 raise ValueError('polygons and brushes must have same length')
1098 return self._DrawPolygonList(polygons, pens, brushes)
1099
1100
1101 def DrawTextList(self, textList, coords, foregrounds = None, backgrounds = None):
1102 """
1103 Draw a list of strings using a list of coordinants for positioning each string.
1104
1105 :param textList: A list of strings
1106 :param coords: A list of (x,y) positions
1107 :param foregrounds: A list of `wx.Colour` objects to use for the
1108 foregrounds of the strings.
1109 :param backgrounds: A list of `wx.Colour` objects to use for the
1110 backgrounds of the strings.
1111
1112 NOTE: Make sure you set Background mode to wx.Solid (DC.SetBackgroundMode)
1113 If you want backgrounds to do anything.
1114 """
1115 if type(textList) == type(''):
1116 textList = [textList]
1117 elif len(textList) != len(coords):
1118 raise ValueError('textlist and coords must have same length')
1119 if foregrounds is None:
1120 foregrounds = []
1121 elif isinstance(foregrounds, wx.Colour):
1122 foregrounds = [foregrounds]
1123 elif len(foregrounds) != len(coords):
1124 raise ValueError('foregrounds and coords must have same length')
1125 if backgrounds is None:
1126 backgrounds = []
1127 elif isinstance(backgrounds, wx.Colour):
1128 backgrounds = [backgrounds]
1129 elif len(backgrounds) != len(coords):
1130 raise ValueError('backgrounds and coords must have same length')
1131 return self._DrawTextList(textList, coords, foregrounds, backgrounds)
1132 }
1133
1134 };
1135
1136
1137
1138 %{
1139 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
1140 *x1 = dc->MinX();
1141 *y1 = dc->MinY();
1142 *x2 = dc->MaxX();
1143 *y2 = dc->MaxY();
1144 }
1145 %}
1146
1147
1148 //---------------------------------------------------------------------------
1149 %newgroup
1150
1151 MustHaveApp(wxMemoryDC);
1152
1153 DocStr(wxMemoryDC,
1154 "A memory device context provides a means to draw graphics onto a
1155 bitmap. A bitmap must be selected into the new memory DC before it may
1156 be used for anything. Typical usage is as follows::
1157
1158 dc = wx.MemoryDC()
1159 dc.SelectObject(bitmap)
1160 # draw on the dc usign any of the Draw methods
1161 dc.SelectObject(wx.NullBitmap)
1162 # the bitmap now contains wahtever was drawn upon it
1163
1164 Note that the memory DC *must* be deleted (or the bitmap selected out
1165 of it) before a bitmap can be reselected into another memory DC.
1166 ", "");
1167
1168 class wxMemoryDC : public wxDC {
1169 public:
1170 DocCtorStr(
1171 wxMemoryDC(),
1172 "Constructs a new memory device context.
1173
1174 Use the Ok member to test whether the constructor was successful in
1175 creating a usable device context. Don't forget to select a bitmap into
1176 the DC before drawing on it.", "
1177
1178 :see: `MemoryDCFromDC`");
1179
1180 DocCtorStrName(
1181 wxMemoryDC(wxDC* oldDC),
1182 "Creates a DC that is compatible with the oldDC.", "",
1183 MemoryDCFromDC);
1184
1185
1186 DocDeclStr(
1187 void , SelectObject(const wxBitmap& bitmap),
1188 "Selects the bitmap into the device context, to use as the memory
1189 bitmap. Selecting the bitmap into a memory DC allows you to draw into
1190 the DC, and therefore the bitmap, and also to use Blit to copy the
1191 bitmap to a window.
1192
1193 If the argument is wx.NullBitmap (or some other uninitialised
1194 `wx.Bitmap`) the current bitmap is selected out of the device context,
1195 and the original bitmap restored, allowing the current bitmap to be
1196 destroyed safely.", "");
1197
1198 };
1199
1200 //---------------------------------------------------------------------------
1201 %newgroup
1202
1203
1204 %{
1205 #include <wx/dcbuffer.h>
1206 %}
1207
1208
1209 MustHaveApp(wxBufferedDC);
1210
1211 DocStr(wxBufferedDC,
1212 "This simple class provides a simple way to avoid flicker: when drawing
1213 on it, everything is in fact first drawn on an in-memory buffer (a
1214 `wx.Bitmap`) and then copied to the screen only once, when this object
1215 is destroyed.
1216
1217 It can be used in the same way as any other device
1218 context. wx.BufferedDC itself typically replaces `wx.ClientDC`, if you
1219 want to use it in your EVT_PAINT handler, you should look at
1220 `wx.BufferedPaintDC`.
1221 ", "");
1222
1223 class wxBufferedDC : public wxMemoryDC
1224 {
1225 public:
1226 %pythonAppend wxBufferedDC
1227 "self.__dc = args[0] # save a ref so the other dc will not be deleted before self";
1228 %nokwargs wxBufferedDC;
1229
1230 DocStr(
1231 wxBufferedDC,
1232 "Constructs a buffered DC.", "
1233
1234 :param dc: The underlying DC: everything drawn to this object will
1235 be flushed to this DC when this object is destroyed. You may
1236 pass ``None`` in order to just initialize the buffer, and not
1237 flush it.
1238
1239 :param buffer: If a `wx.Size` object is passed as the 2nd arg then
1240 it is the size of the bitmap that will be created internally
1241 and used for an implicit buffer. If the 2nd arg is a
1242 `wx.Bitmap` then it is the explicit buffer that will be
1243 used. Using an explicit buffer is the most efficient solution
1244 as the bitmap doesn't have to be recreated each time but it
1245 also requires more memory as the bitmap is never freed. The
1246 bitmap should have appropriate size, anything drawn outside of
1247 its bounds is clipped.
1248 ");
1249 wxBufferedDC( wxDC *dc, const wxBitmap &buffer );
1250 wxBufferedDC( wxDC *dc, const wxSize &area );
1251
1252
1253
1254 // // TODO: Keep this one too?
1255 // %pythonAppend wxBufferedDC( wxDC *dc, const wxSize &area )
1256 // "val.__dc = args[0] # save a ref so the other dc will not be deleted before self";
1257 // %name(BufferedDCInternalBuffer) wxBufferedDC( wxDC *dc, const wxSize &area );
1258
1259
1260 // The buffer is blit to the real DC when the BufferedDC is destroyed.
1261 DocCtorStr(
1262 ~wxBufferedDC(),
1263 "Copies everything drawn on the DC so far to the underlying DC
1264 associated with this object, if any.", "");
1265
1266
1267 DocDeclStr(
1268 void , UnMask(),
1269 "Blits the buffer to the dc, and detaches the dc from the buffer (so it
1270 can be effectively used once only). This is usually only called in
1271 the destructor.", "");
1272
1273 };
1274
1275
1276
1277
1278 MustHaveApp(wxBufferedPaintDC);
1279
1280 DocStr(wxBufferedPaintDC,
1281 "This is a subclass of `wx.BufferedDC` which can be used inside of an
1282 EVT_PAINT event handler. Just create an object of this class instead
1283 of `wx.PaintDC` and that's all you have to do to (mostly) avoid
1284 flicker. The only thing to watch out for is that if you are using this
1285 class together with `wx.ScrolledWindow`, you probably do **not** want
1286 to call `wx.Window.PrepareDC` on it as it already does this internally
1287 for the real underlying `wx.PaintDC`.
1288
1289 If your window is already fully buffered in a `wx.Bitmap` then your
1290 EVT_PAINT handler can be as simple as just creating a
1291 ``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
1292 automatically when it is destroyed. For example::
1293
1294 def OnPaint(self, event):
1295 dc = wx.BufferedPaintDC(self, self.buffer)
1296
1297
1298 ", "");
1299
1300 class wxBufferedPaintDC : public wxBufferedDC
1301 {
1302 public:
1303
1304 DocCtorStr(
1305 wxBufferedPaintDC( wxWindow *window, const wxBitmap &buffer = wxNullBitmap ),
1306 "Create a buffered paint DC. As with `wx.BufferedDC`, you may either
1307 provide the bitmap to be used for buffering or let this object create
1308 one internally (in the latter case, the size of the client part of the
1309 window is automatically used).
1310
1311 ", "");
1312
1313 };
1314
1315
1316 //---------------------------------------------------------------------------
1317 %newgroup
1318
1319 MustHaveApp(wxScreenDC);
1320
1321 DocStr(wxScreenDC,
1322 "A wxScreenDC can be used to paint anywhere on the screen. This should
1323 normally be constructed as a temporary stack object; don't store a
1324 wxScreenDC object.
1325 ", "");
1326 class wxScreenDC : public wxDC {
1327 public:
1328 wxScreenDC();
1329
1330 DocDeclStrName(
1331 bool , StartDrawingOnTop(wxWindow* window),
1332 "Specify that the area of the screen to be drawn upon coincides with
1333 the given window.
1334
1335 :see: `EndDrawingOnTop`", "",
1336 StartDrawingOnTopWin);
1337
1338
1339 DocDeclStr(
1340 bool , StartDrawingOnTop(wxRect* rect = NULL),
1341 "Specify that the area is the given rectangle, or the whole screen if
1342 ``None`` is passed.
1343
1344 :see: `EndDrawingOnTop`", "");
1345
1346
1347 DocDeclStr(
1348 bool , EndDrawingOnTop(),
1349 "Use this in conjunction with `StartDrawingOnTop` or
1350 `StartDrawingOnTopWin` to ensure that drawing to the screen occurs on
1351 top of existing windows. Without this, some window systems (such as X)
1352 only allow drawing to take place underneath other windows.
1353
1354 You might use this pair of functions when implementing a drag feature,
1355 for example as in the `wx.SplitterWindow` implementation.
1356
1357 These functions are probably obsolete since the X implementations
1358 allow drawing directly on the screen now. However, the fact that this
1359 function allows the screen to be refreshed afterwards may be useful
1360 to some applications.", "");
1361
1362 };
1363
1364 //---------------------------------------------------------------------------
1365 %newgroup
1366
1367 MustHaveApp(wxClientDC);
1368
1369 DocStr(wxClientDC,
1370 "A wx.ClientDC must be constructed if an application wishes to paint on
1371 the client area of a window from outside an EVT_PAINT event. This should
1372 normally be constructed as a temporary stack object; don't store a
1373 wx.ClientDC object long term.
1374
1375 To draw on a window from within an EVT_PAINT handler, construct a
1376 `wx.PaintDC` object.
1377
1378 To draw on the whole window including decorations, construct a
1379 `wx.WindowDC` object (Windows only).
1380 ", "");
1381 class wxClientDC : public wxDC {
1382 public:
1383 DocCtorStr(
1384 wxClientDC(wxWindow* win),
1385 "Constructor. Pass the window on which you wish to paint.", "");
1386 };
1387
1388 //---------------------------------------------------------------------------
1389 %newgroup
1390
1391 MustHaveApp(wxPaintDC);
1392
1393 DocStr(wxPaintDC,
1394 "A wx.PaintDC must be constructed if an application wishes to paint on
1395 the client area of a window from within an EVT_PAINT event
1396 handler. This should normally be constructed as a temporary stack
1397 object; don't store a wx.PaintDC object. If you have an EVT_PAINT
1398 handler, you **must** create a wx.PaintDC object within it even if you
1399 don't actually use it.
1400
1401 Using wx.PaintDC within EVT_PAINT handlers is important because it
1402 automatically sets the clipping area to the damaged area of the
1403 window. Attempts to draw outside this area do not appear.
1404
1405 To draw on a window from outside EVT_PAINT handlers, construct a
1406 `wx.ClientDC` object.
1407 ","");
1408 class wxPaintDC : public wxDC {
1409 public:
1410 DocCtorStr(
1411 wxPaintDC(wxWindow* win),
1412 "Constructor. Pass the window on which you wish to paint.", "");
1413 };
1414
1415 //---------------------------------------------------------------------------
1416 %newgroup
1417
1418 MustHaveApp(wxWindowDC);
1419
1420 DocStr(wxWindowDC,
1421 "A wx.WindowDC must be constructed if an application wishes to paint on
1422 the whole area of a window (client and decorations). This should
1423 normally be constructed as a temporary stack object; don't store a
1424 wx.WindowDC object.","");
1425 class wxWindowDC : public wxDC {
1426 public:
1427 DocCtorStr(
1428 wxWindowDC(wxWindow* win),
1429 "Constructor. Pass the window on which you wish to paint.","");
1430 };
1431
1432 //---------------------------------------------------------------------------
1433 %newgroup
1434
1435 MustHaveApp(wxMirrorDC);
1436
1437 DocStr(wxMirrorDC,
1438 "wx.MirrorDC is a simple wrapper class which is always associated with a
1439 real `wx.DC` object and either forwards all of its operations to it
1440 without changes (no mirroring takes place) or exchanges x and y
1441 coordinates which makes it possible to reuse the same code to draw a
1442 figure and its mirror -- i.e. reflection related to the diagonal line
1443 x == y.", "");
1444 class wxMirrorDC : public wxDC
1445 {
1446 public:
1447 DocCtorStr(
1448 wxMirrorDC(wxDC& dc, bool mirror),
1449 "Creates a mirrored DC associated with the real *dc*. Everything drawn
1450 on the wx.MirrorDC will appear on the *dc*, and will be mirrored if
1451 *mirror* is True.","");
1452 };
1453
1454 //---------------------------------------------------------------------------
1455 %newgroup
1456
1457 %{
1458 #include <wx/dcps.h>
1459 %}
1460
1461 MustHaveApp(wxPostScriptDC);
1462
1463 DocStr(wxPostScriptDC,
1464 "This is a `wx.DC` that can write to PostScript files on any platform.","");
1465
1466 class wxPostScriptDC : public wxDC {
1467 public:
1468 DocCtorStr(
1469 wxPostScriptDC(const wxPrintData& printData),
1470 "Constructs a PostScript printer device context from a `wx.PrintData`
1471 object.", "");
1472
1473 wxPrintData& GetPrintData();
1474 void SetPrintData(const wxPrintData& data);
1475
1476 DocDeclStr(
1477 static void , SetResolution(int ppi),
1478 "Set resolution (in pixels per inch) that will be used in PostScript
1479 output. Default is 720ppi.", "");
1480
1481 DocDeclStr(
1482 static int , GetResolution(),
1483 "Return resolution used in PostScript output.", "");
1484 };
1485
1486 //---------------------------------------------------------------------------
1487 %newgroup
1488
1489
1490 MustHaveApp(wxMetaFile);
1491 MustHaveApp(wxMetaFileDC);
1492
1493
1494 #if defined(__WXMSW__) || defined(__WXMAC__)
1495
1496 %{
1497 #include <wx/metafile.h>
1498 %}
1499
1500 class wxMetaFile : public wxObject {
1501 public:
1502 wxMetaFile(const wxString& filename = wxPyEmptyString);
1503 ~wxMetaFile();
1504
1505 bool Ok();
1506 bool SetClipboard(int width = 0, int height = 0);
1507
1508 wxSize GetSize();
1509 int GetWidth();
1510 int GetHeight();
1511
1512 #ifdef __WXMSW__
1513 const wxString& GetFileName() const;
1514 #endif
1515
1516 %pythoncode { def __nonzero__(self): return self.Ok() }
1517 };
1518
1519 // bool wxMakeMetaFilePlaceable(const wxString& filename,
1520 // int minX, int minY, int maxX, int maxY, float scale=1.0);
1521
1522
1523 class wxMetaFileDC : public wxDC {
1524 public:
1525 wxMetaFileDC(const wxString& filename = wxPyEmptyString,
1526 int width = 0, int height = 0,
1527 const wxString& description = wxPyEmptyString);
1528 wxMetaFile* Close();
1529 };
1530
1531
1532
1533 #else // Make some dummies for the other platforms
1534
1535 %{
1536 class wxMetaFile : public wxObject {
1537 public:
1538 wxMetaFile(const wxString&)
1539 { wxPyRaiseNotImplemented(); }
1540 };
1541
1542 class wxMetaFileDC : public wxClientDC {
1543 public:
1544 wxMetaFileDC(const wxString&, int, int, const wxString&)
1545 { wxPyRaiseNotImplemented(); }
1546 };
1547
1548 %}
1549
1550 class wxMetaFile : public wxObject {
1551 public:
1552 wxMetaFile(const wxString& filename = wxPyEmptyString);
1553 };
1554
1555 class wxMetaFileDC : public wxDC {
1556 public:
1557 wxMetaFileDC(const wxString& filename = wxPyEmptyString,
1558 int width = 0, int height = 0,
1559 const wxString& description = wxPyEmptyString);
1560 };
1561
1562
1563 #endif
1564
1565
1566 //---------------------------------------------------------------------------
1567
1568 MustHaveApp(wxPrinterDC);
1569
1570 #if defined(__WXMSW__) || defined(__WXMAC__)
1571
1572 class wxPrinterDC : public wxDC {
1573 public:
1574 wxPrinterDC(const wxPrintData& printData);
1575 // %name(PrinterDC2) wxPrinterDC(const wxString& driver,
1576 // const wxString& device,
1577 // const wxString& output,
1578 // bool interactive = true,
1579 // int orientation = wxPORTRAIT);
1580 };
1581
1582 #else
1583 %{
1584 class wxPrinterDC : public wxClientDC {
1585 public:
1586 wxPrinterDC(const wxPrintData&)
1587 { wxPyRaiseNotImplemented(); }
1588
1589 // wxPrinterDC(const wxString&, const wxString&, const wxString&, bool, int)
1590 // { wxPyRaiseNotImplemented(); }
1591 };
1592 %}
1593
1594 class wxPrinterDC : public wxDC {
1595 public:
1596 wxPrinterDC(const wxPrintData& printData);
1597 // %name(PrinterDC2) wxPrinterDC(const wxString& driver,
1598 // const wxString& device,
1599 // const wxString& output,
1600 // bool interactive = true,
1601 // int orientation = wxPORTRAIT);
1602 };
1603 #endif
1604
1605 //---------------------------------------------------------------------------
1606 //---------------------------------------------------------------------------