1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: SWIG interface defs for wxDC and releated classes
7 // Created: 7-July-1997
9 // Copyright: (c) 2003 by Total Control Software
10 // Licence: wxWindows license
11 /////////////////////////////////////////////////////////////////////////////
17 //---------------------------------------------------------------------------
20 #include "wx/wxPython/pydrawxxx.h"
23 // TODO: 1. wrappers for wxDrawObject and wxDC::DrawObject
26 //---------------------------------------------------------------------------
28 %typemap(in) (int points, wxPoint* points_array ) {
29 $2 = wxPoint_LIST_helper($input, &$1);
30 if ($2 == NULL) SWIG_fail;
32 %typemap(freearg) (int points, wxPoint* points_array ) {
37 //---------------------------------------------------------------------------
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.
49 Derived types of wxDC have documentation for specific features only,
50 so refer to this section for most device context information.
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.", "");
56 class wxDC : public wxObject {
58 // wxDC(); **** abstract base class, can't instantiate.
63 %# These have been deprecated in wxWidgets. Since they never
64 %# really did anything to begin with, just make them be NOPs.
65 def BeginDrawing(self): pass
66 def EndDrawing(self): pass
71 // TODO virtual void DrawObject(wxDrawObject* drawobject);
76 "Flood fills the device context starting from the given point, using
77 the current brush colour, and using a style:
79 - **wxFLOOD_SURFACE**: the flooding occurs until a colour other than
80 the given colour is encountered.
82 - **wxFLOOD_BORDER**: the area to be flooded is bounded by the given
85 Returns False if the operation failed.
87 Note: The present implementation for non-Windows platforms may fail to
88 find colour borders if the pixels do not match the colour
89 exactly. However the function will still return true.", "");
90 bool FloodFill(wxCoord x, wxCoord y, const wxColour& col, int style = wxFLOOD_SURFACE);
91 %Rename(FloodFillPoint, bool, FloodFill(const wxPoint& pt, const wxColour& col, int style = wxFLOOD_SURFACE));
93 // fill the area specified by rect with a radial gradient, starting from
94 // initialColour in the centre of the cercle and fading to destColour.
97 void , GradientFillConcentric(const wxRect& rect,
98 const wxColour& initialColour,
99 const wxColour& destColour,
100 const wxPoint& circleCenter),
101 "Fill the area specified by rect with a radial gradient, starting from
102 initialColour in the center of the circle and fading to destColour on
103 the outside of the circle. The circleCenter argument is the relative
104 coordinants of the center of the circle in the specified rect.
106 Note: Currently this function is very slow, don't use it for real-time
111 void , GradientFillLinear(const wxRect& rect,
112 const wxColour& initialColour,
113 const wxColour& destColour,
114 wxDirection nDirection = wxEAST),
115 "Fill the area specified by rect with a linear gradient, starting from
116 initialColour and eventually fading to destColour. The nDirection
117 parameter specifies the direction of the colour change, default is to
118 use initialColour on the left part of the rectangle and destColour on
119 the right side.", "");
125 "Gets the colour at the specified location on the DC.","");
127 wxColour GetPixel(wxCoord x, wxCoord y) {
129 self->GetPixel(x, y, &col);
132 wxColour GetPixelPoint(const wxPoint& pt) {
134 self->GetPixel(pt, &col);
142 "Draws a line from the first point to the second. The current pen is
143 used for drawing the line. Note that the second point is *not* part of
144 the line and is not drawn by this function (this is consistent with
145 the behaviour of many other toolkits).", "");
146 void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
147 %Rename(DrawLinePoint, void, DrawLine(const wxPoint& pt1, const wxPoint& pt2));
152 "Displays a cross hair using the current pen. This is a vertical and
153 horizontal line the height and width of the window, centred on the
155 void CrossHair(wxCoord x, wxCoord y);
156 %Rename(CrossHairPoint, void, CrossHair(const wxPoint& pt));
161 "Draws an arc of a circle, centred on the *center* point (xc, yc), from
162 the first point to the second. The current pen is used for the outline
163 and the current brush for filling the shape.
165 The arc is drawn in an anticlockwise direction from the start point to
166 the end point.", "");
167 void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc);
168 %Rename(DrawArcPoint, void, DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& center));
173 "Draws a check mark inside the given rectangle.", "");
174 void DrawCheckMark(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
175 %Rename(DrawCheckMarkRect, void, DrawCheckMark(const wxRect& rect));
179 "Draws an arc of an ellipse, with the given rectangle defining the
180 bounds of the ellipse. The current pen is used for drawing the arc and
181 the current brush is used for drawing the pie.
183 The *start* and *end* parameters specify the start and end of the arc
184 relative to the three-o'clock position from the center of the
185 rectangle. Angles are specified in degrees (360 is a complete
186 circle). Positive values mean counter-clockwise motion. If start is
187 equal to end, a complete ellipse will be drawn.", "");
188 void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h, double start, double end);
189 %Rename(DrawEllipticArcPointSize, void, DrawEllipticArc(const wxPoint& pt, const wxSize& sz, double start, double end));
194 "Draws a point using the current pen.", "");
195 void DrawPoint(wxCoord x, wxCoord y);
196 %Rename(DrawPointPoint, void, DrawPoint(const wxPoint& pt));
201 "Draws a rectangle with the given top left corner, and with the given
202 size. The current pen is used for the outline and the current brush
203 for filling the shape.", "");
204 void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
205 %Rename(DrawRectangleRect,void, DrawRectangle(const wxRect& rect));
206 %Rename(DrawRectanglePointSize, void, DrawRectangle(const wxPoint& pt, const wxSize& sz));
210 DrawRoundedRectangle,
211 "Draws a rectangle with the given top left corner, and with the given
212 size. The corners are quarter-circles using the given radius. The
213 current pen is used for the outline and the current brush for filling
216 If radius is positive, the value is assumed to be the radius of the
217 rounded corner. If radius is negative, the absolute value is assumed
218 to be the proportion of the smallest dimension of the rectangle. This
219 means that the corner can be a sensible size relative to the size of
220 the rectangle, and also avoids the strange effects X produces when the
221 corners are too big for the rectangle.", "");
222 void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius);
223 %Rename(DrawRoundedRectangleRect, void, DrawRoundedRectangle(const wxRect& r, double radius));
224 %Rename(DrawRoundedRectanglePointSize, void, DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz, double radius));
229 "Draws a circle with the given center point and radius. The current
230 pen is used for the outline and the current brush for filling the
233 :see: `DrawEllipse`");
234 void DrawCircle(wxCoord x, wxCoord y, wxCoord radius);
235 %Rename(DrawCirclePoint, void, DrawCircle(const wxPoint& pt, wxCoord radius));
240 "Draws an ellipse contained in the specified rectangle. The current pen
241 is used for the outline and the current brush for filling the shape.", "
243 :see: `DrawCircle`");
244 void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
245 %Rename(DrawEllipseRect, void, DrawEllipse(const wxRect& rect));
246 %Rename(DrawEllipsePointSize, void, DrawEllipse(const wxPoint& pt, const wxSize& sz));
251 "Draw an icon on the display (does nothing if the device context is
252 PostScript). This can be the simplest way of drawing bitmaps on a
254 void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y);
255 %Rename(DrawIconPoint, void, DrawIcon(const wxIcon& icon, const wxPoint& pt));
260 "Draw a bitmap on the device context at the specified point. If
261 *transparent* is true and the bitmap has a transparency mask, (or
262 alpha channel on the platforms that support it) then the bitmap will
263 be drawn transparently.", "
265 When drawing a mono-bitmap, the current text foreground colour will be
266 used to draw the foreground of the bitmap (all bits set to 1), and the
267 current text background colour to draw the background (all bits set to
270 :see: `SetTextForeground`, `SetTextBackground` and `wx.MemoryDC`");
271 void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask = false);
272 %Rename(DrawBitmapPoint, void, DrawBitmap(const wxBitmap &bmp, const wxPoint& pt, bool useMask = false));
277 "Draws a text string at the specified point, using the current text
278 font, and the current text foreground and background colours.
280 The coordinates refer to the top-left corner of the rectangle bounding
281 the string. See `GetTextExtent` for how to get the dimensions of a
282 text string, which can be used to position the text more precisely.
284 **NOTE**: under wxGTK the current logical function is used by this
285 function but it is ignored by wxMSW. Thus, you should avoid using
286 logical functions with this function in portable programs.", "
288 :see: `DrawRotatedText`");
289 void DrawText(const wxString& text, wxCoord x, wxCoord y);
290 %Rename(DrawTextPoint, void, DrawText(const wxString& text, const wxPoint& pt));
295 "Draws the text rotated by *angle* degrees, if supported by the platform.
297 **NOTE**: Under Win9x only TrueType fonts can be drawn by this
298 function. In particular, a font different from ``wx.NORMAL_FONT``
299 should be used as the it is not normally a TrueType
300 font. ``wx.SWISS_FONT`` is an example of a font which is.","
303 void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle);
304 %Rename(DrawRotatedTextPoint, void, DrawRotatedText(const wxString& text, const wxPoint& pt, double angle));
308 bool , Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
309 wxDC *source, wxCoord xsrc, wxCoord ysrc,
310 int rop = wxCOPY, bool useMask = false,
311 wxCoord xsrcMask = -1, wxCoord ysrcMask = -1),
312 "Copy from a source DC to this DC. Parameters specify the destination
313 coordinates, size of area to copy, source DC, source coordinates,
314 logical function, whether to use a bitmap mask, and mask source
317 :param xdest: Destination device context x position.
318 :param ydest: Destination device context y position.
319 :param width: Width of source area to be copied.
320 :param height: Height of source area to be copied.
321 :param source: Source device context.
322 :param xsrc: Source device context x position.
323 :param ysrc: Source device context y position.
324 :param rop: Logical function to use: see `SetLogicalFunction`.
325 :param useMask: If true, Blit does a transparent blit using the mask
326 that is associated with the bitmap selected into the
327 source device context.
328 :param xsrcMask: Source x position on the mask. If both xsrcMask and
329 ysrcMask are -1, xsrc and ysrc will be assumed for
330 the mask source position.
331 :param ysrcMask: Source y position on the mask.
335 bool , Blit(const wxPoint& destPt, const wxSize& sz,
336 wxDC *source, const wxPoint& srcPt,
337 int rop = wxCOPY, bool useMask = false,
338 const wxPoint& srcPtMask = wxDefaultPosition),
339 "Copy from a source DC to this DC. Parameters specify the destination
340 coordinates, size of area to copy, source DC, source coordinates,
341 logical function, whether to use a bitmap mask, and mask source
344 :param destPt: Destination device context position.
345 :param sz: Size of source area to be copied.
346 :param source: Source device context.
347 :param srcPt: Source device context position.
348 :param rop: Logical function to use: see `SetLogicalFunction`.
349 :param useMask: If true, Blit does a transparent blit using the mask
350 that is associated with the bitmap selected into the
351 source device context.
352 :param srcPtMask: Source position on the mask.
359 "Sets the clipping region for this device context to the intersection
360 of the given region described by the parameters of this method and the
361 previously set clipping region. You should call `DestroyClippingRegion`
362 if you want to set the clipping region exactly to the region
365 The clipping region is an area to which drawing is
366 restricted. Possible uses for the clipping region are for clipping
367 text or for speeding up window redraws when only a known area of the
368 screen is damaged.", "
370 :see: `DestroyClippingRegion`, `wx.Region`");
371 void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
372 %Rename(SetClippingRegionPointSize, void, SetClippingRegion(const wxPoint& pt, const wxSize& sz));
373 %Rename(SetClippingRegionAsRegion, void, SetClippingRegion(const wxRegion& region));
374 %Rename(SetClippingRect, void, SetClippingRegion(const wxRect& rect));
379 void , DrawLines(int points, wxPoint* points_array,
380 wxCoord xoffset = 0, wxCoord yoffset = 0),
381 "DrawLines(self, List points, int xoffset=0, int yoffset=0)",
382 "Draws lines using a sequence of `wx.Point` objects, adding the
383 optional offset coordinate. The current pen is used for drawing the
388 void , DrawPolygon(int points, wxPoint* points_array,
389 wxCoord xoffset = 0, wxCoord yoffset = 0,
390 int fillStyle = wxODDEVEN_RULE),
391 "DrawPolygon(self, List points, int xoffset=0, int yoffset=0,
392 int fillStyle=ODDEVEN_RULE)",
393 "Draws a filled polygon using a sequence of `wx.Point` objects, adding
394 the optional offset coordinate. The last argument specifies the fill
395 rule: ``wx.ODDEVEN_RULE`` (the default) or ``wx.WINDING_RULE``.
397 The current pen is used for drawing the outline, and the current brush
398 for filling the shape. Using a transparent brush suppresses
399 filling. Note that wxWidgets automatically closes the first and last
403 // TODO: Figure out a good typemap for this...
404 // Convert the first 3 args from a sequence of sequences?
405 // void DrawPolyPolygon(int n, int count[], wxPoint points[],
406 // wxCoord xoffset = 0, wxCoord yoffset = 0,
407 // int fillStyle = wxODDEVEN_RULE);
411 void , DrawLabel(const wxString& text, const wxRect& rect,
412 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
413 int indexAccel = -1),
414 "Draw *text* within the specified rectangle, abiding by the alignment
415 flags. Will additionally emphasize the character at *indexAccel* if
418 :see: `DrawImageLabel`");
422 DocStr(DrawImageLabel,
423 "Draw *text* and an image (which may be ``wx.NullBitmap`` to skip
424 drawing it) within the specified rectangle, abiding by the alignment
425 flags. Will additionally emphasize the character at *indexAccel* if
426 it is not -1. Returns the bounding rectangle.", "");
427 wxRect DrawImageLabel(const wxString& text,
428 const wxBitmap& image,
430 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
431 int indexAccel = -1) {
433 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
441 void , DrawSpline(int points, wxPoint* points_array),
442 "DrawSpline(self, List points)",
443 "Draws a spline between all given control points, (a list of `wx.Point`
444 objects) using the current pen. The spline is drawn using a series of
445 lines, using an algorithm taken from the X drawing program 'XFIG'.", "");
450 // global DC operations
451 // --------------------
454 virtual void , Clear(),
455 "Clears the device context using the current background brush.", "");
459 virtual bool , StartDoc(const wxString& message),
460 "Starts a document (only relevant when outputting to a
461 printer). *Message* is a message to show whilst printing.", "");
464 virtual void , EndDoc(),
465 "Ends a document (only relevant when outputting to a printer).", "");
469 virtual void , StartPage(),
470 "Starts a document page (only relevant when outputting to a printer).", "");
473 virtual void , EndPage(),
474 "Ends a document page (only relevant when outputting to a printer).", "");
478 // set objects to use for drawing
479 // ------------------------------
482 virtual void , SetFont(const wxFont& font),
483 "Sets the current font for the DC. It must be a valid font, in
484 particular you should not pass ``wx.NullFont`` to this method.","
489 virtual void , SetPen(const wxPen& pen),
490 "Sets the current pen for the DC.
492 If the argument is ``wx.NullPen``, the current pen is selected out of the
493 device context, and the original pen restored.", "
498 virtual void , SetBrush(const wxBrush& brush),
499 "Sets the current brush for the DC.
501 If the argument is ``wx.NullBrush``, the current brush is selected out
502 of the device context, and the original brush restored, allowing the
503 current brush to be destroyed safely.","
508 virtual void , SetBackground(const wxBrush& brush),
509 "Sets the current background brush for the DC.", "");
512 virtual void , SetBackgroundMode(int mode),
513 "*mode* may be one of ``wx.SOLID`` and ``wx.TRANSPARENT``. This setting
514 determines whether text will be drawn with a background colour or
518 virtual void , SetPalette(const wxPalette& palette),
519 "If this is a window DC or memory DC, assigns the given palette to the
520 window or bitmap associated with the DC. If the argument is
521 ``wx.NullPalette``, the current palette is selected out of the device
522 context, and the original palette restored.", "
524 :see: `wx.Palette`");
529 virtual void , DestroyClippingRegion(),
530 "Destroys the current clipping region so that none of the DC is
533 :see: `SetClippingRegion`");
537 void, GetClippingBox(wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord *OUTPUT) const,
538 "GetClippingBox() -> (x, y, width, height)",
539 "Gets the rectangle surrounding the current clipping region.", "");
544 "Gets the rectangle surrounding the current clipping region.", "");
545 wxRect GetClippingRect() {
547 self->GetClippingBox(rect);
558 virtual wxCoord , GetCharHeight() const,
559 "Gets the character height of the currently set font.", "");
562 virtual wxCoord , GetCharWidth() const,
563 "Gets the average character width of the currently set font.", "");
568 void, GetTextExtent(const wxString& string, wxCoord *OUTPUT, wxCoord *OUTPUT),
569 "GetTextExtent(wxString string) -> (width, height)",
570 "Get the width and height of the text using the current font. Only
571 works for single line strings.", "");
574 void, GetTextExtent(const wxString& string,
575 wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord* OUTPUT,
576 wxFont* font = NULL),
577 "GetFullTextExtent(wxString string, Font font=None) ->\n (width, height, descent, externalLeading)",
578 "Get the width, height, decent and leading of the text using the
579 current or specified font. Only works for single line strings.", "",
583 // works for single as well as multi-line strings
585 void, GetMultiLineTextExtent(const wxString& text,
586 wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord *OUTPUT,
587 wxFont *font = NULL),
588 "GetMultiLineTextExtent(wxString string, Font font=None) ->\n (width, height, lineHeight)",
589 "Get the width, height, and line height of the text using the
590 current or specified font. Works for single as well as multi-line
595 DocAStr(GetPartialTextExtents,
596 "GetPartialTextExtents(self, text) -> [widths]",
597 "Returns a list of integers such that each value is the distance in
598 pixels from the begining of text to the coresponding character of
599 *text*. The generic version simply builds a running total of the widths
600 of each character using GetTextExtent, however if the various
601 platforms have a native API function that is faster or more accurate
602 than the generic implementation then it will be used instead.", "");
603 wxArrayInt GetPartialTextExtents(const wxString& text) {
605 self->GetPartialTextExtents(text, widths);
611 // size and resolution
612 // -------------------
616 "This gets the horizontal and vertical resolution in device units. It
617 can be used to scale graphics to fit the page. For example, if *maxX*
618 and *maxY* represent the maximum horizontal and vertical 'pixel' values
619 used in your application, the following code will scale the graphic to
620 fit on the printer page::
623 scaleX = maxX*1.0 / w
624 scaleY = maxY*1.0 / h
625 dc.SetUserScale(min(scaleX,scaleY),min(scaleX,scaleY))
629 void, GetSize( int *OUTPUT, int *OUTPUT ),
630 "GetSizeTuple() -> (width, height)",
634 DocStr(GetSizeMM, "Get the DC size in milimeters.", "");
635 wxSize GetSizeMM() const;
637 void, GetSizeMM( int *OUTPUT, int *OUTPUT ) const,
638 "GetSizeMMTuple() -> (width, height)",
643 // coordinates conversions
644 // -----------------------
647 wxCoord , DeviceToLogicalX(wxCoord x) const,
648 "Convert device X coordinate to logical coordinate, using the current
652 wxCoord , DeviceToLogicalY(wxCoord y) const,
653 "Converts device Y coordinate to logical coordinate, using the current
657 wxCoord , DeviceToLogicalXRel(wxCoord x) const,
658 "Convert device X coordinate to relative logical coordinate, using the
659 current mapping mode but ignoring the x axis orientation. Use this
660 function for converting a width, for example.", "");
663 wxCoord , DeviceToLogicalYRel(wxCoord y) const,
664 "Convert device Y coordinate to relative logical coordinate, using the
665 current mapping mode but ignoring the y axis orientation. Use this
666 function for converting a height, for example.", "");
669 wxCoord , LogicalToDeviceX(wxCoord x) const,
670 "Converts logical X coordinate to device coordinate, using the current
674 wxCoord , LogicalToDeviceY(wxCoord y) const,
675 "Converts logical Y coordinate to device coordinate, using the current
679 wxCoord , LogicalToDeviceXRel(wxCoord x) const,
680 "Converts logical X coordinate to relative device coordinate, using the
681 current mapping mode but ignoring the x axis orientation. Use this for
682 converting a width, for example.", "");
685 wxCoord , LogicalToDeviceYRel(wxCoord y) const,
686 "Converts logical Y coordinate to relative device coordinate, using the
687 current mapping mode but ignoring the y axis orientation. Use this for
688 converting a height, for example.", "");
692 // query DC capabilities
693 // ---------------------
695 virtual bool CanDrawBitmap() const;
696 virtual bool CanGetTextExtent() const;
700 virtual int , GetDepth() const,
701 "Returns the colour depth of the DC.", "");
705 virtual wxSize , GetPPI() const,
706 "Resolution in pixels per inch", "");
710 virtual bool , IsOk() const,
711 "Returns true if the DC is ok to use.", "");
712 %pythoncode { Ok = IsOk }
717 int , GetBackgroundMode() const,
718 "Returns the current background mode, either ``wx.SOLID`` or
719 ``wx.TRANSPARENT``.","
721 :see: `SetBackgroundMode`");
724 const wxBrush& , GetBackground() const,
725 "Gets the brush used for painting the background.","
727 :see: `SetBackground`");
730 const wxBrush& , GetBrush() const,
731 "Gets the current brush", "");
734 const wxFont& , GetFont() const,
735 "Gets the current font", "");
738 const wxPen& , GetPen() const,
739 "Gets the current pen", "");
742 const wxColour& , GetTextBackground() const,
743 "Gets the current text background colour", "");
746 const wxColour& , GetTextForeground() const,
747 "Gets the current text foreground colour", "");
751 virtual void , SetTextForeground(const wxColour& colour),
752 "Sets the current text foreground colour for the DC.", "");
755 virtual void , SetTextBackground(const wxColour& colour),
756 "Sets the current text background colour for the DC.", "");
760 int , GetMapMode() const,
761 "Gets the current *mapping mode* for the device context ", "");
764 virtual void , SetMapMode(int mode),
765 "The *mapping mode* of the device context defines the unit of
766 measurement used to convert logical units to device units. The
767 mapping mode can be one of the following:
769 ================ =============================================
770 wx.MM_TWIPS Each logical unit is 1/20 of a point, or 1/1440
772 wx.MM_POINTS Each logical unit is a point, or 1/72 of an inch.
773 wx.MM_METRIC Each logical unit is 1 mm.
774 wx.MM_LOMETRIC Each logical unit is 1/10 of a mm.
775 wx.MM_TEXT Each logical unit is 1 pixel.
776 ================ =============================================
778 Note that in X, text drawing isn't handled consistently with the
779 mapping mode; a font is always specified in point size. However,
780 setting the user scale (see `SetUserScale`) scales the text
781 appropriately. In Windows, scalable TrueType fonts are always used; in
782 X, results depend on availability of fonts, but usually a reasonable
785 The coordinate origin is always at the top left of the screen/printer.
787 Drawing to a Windows printer device context uses the current mapping
788 mode, but mapping mode is currently ignored for PostScript output.
794 virtual void, GetUserScale(double *OUTPUT, double *OUTPUT) const,
795 "GetUserScale(self) -> (xScale, yScale)",
796 "Gets the current user scale factor (set by `SetUserScale`).", "");
799 virtual void , SetUserScale(double x, double y),
800 "Sets the user scaling factor, useful for applications which require
806 virtual void, GetLogicalScale(double *OUTPUT, double *OUTPUT),
807 "GetLogicalScale() -> (xScale, yScale)");
809 virtual void SetLogicalScale(double x, double y);
812 wxPoint GetLogicalOrigin() const;
814 void, GetLogicalOrigin(wxCoord *OUTPUT, wxCoord *OUTPUT) const,
815 "GetLogicalOriginTuple() -> (x,y)",
816 GetLogicalOriginTuple);
818 virtual void SetLogicalOrigin(wxCoord x, wxCoord y);
820 void SetLogicalOriginPoint(const wxPoint& point) {
821 self->SetLogicalOrigin(point.x, point.y);
826 wxPoint GetDeviceOrigin() const;
828 void, GetDeviceOrigin(wxCoord *OUTPUT, wxCoord *OUTPUT) const,
829 "GetDeviceOriginTuple() -> (x,y)",
830 GetDeviceOriginTuple);
832 virtual void SetDeviceOrigin(wxCoord x, wxCoord y);
834 void SetDeviceOriginPoint(const wxPoint& point) {
835 self->SetDeviceOrigin(point.x, point.y);
840 virtual void , SetAxisOrientation(bool xLeftRight, bool yBottomUp),
841 "Sets the x and y axis orientation (i.e., the direction from lowest to
842 highest values on the axis). The default orientation is the natural
843 orientation, e.g. x axis from left to right and y axis from bottom up.", "");
847 int , GetLogicalFunction() const,
848 "Gets the current logical function (set by `SetLogicalFunction`).", "");
851 virtual void , SetLogicalFunction(int function),
852 "Sets the current logical function for the device context. This
853 determines how a source pixel (from a pen or brush colour, or source
854 device context if using `Blit`) combines with a destination pixel in
855 the current device context.
857 The possible values and their meaning in terms of source and
858 destination pixel values are as follows:
860 ================ ==========================
862 wx.AND_INVERT (NOT src) AND dst
863 wx.AND_REVERSE src AND (NOT dst)
866 wx.EQUIV (NOT src) XOR dst
868 wx.NAND (NOT src) OR (NOT dst)
869 wx.NOR (NOT src) AND (NOT dst)
872 wx.OR_INVERT (NOT src) OR dst
873 wx.OR_REVERSE src OR (NOT dst)
875 wx.SRC_INVERT NOT src
877 ================ ==========================
879 The default is wx.COPY, which simply draws with the current
880 colour. The others combine the current colour and the background using
881 a logical operation. wx.INVERT is commonly used for drawing rubber
882 bands or moving outlines, since drawing twice reverts to the original
888 void , ComputeScaleAndOrigin(),
889 "Performs all necessary computations for given platform and context
890 type after each change of scale and origin parameters. Usually called
891 automatically internally after such changes.
897 // virtual void , SetOptimization(bool optimize),
898 // "If *optimize* is true this function sets optimization mode on. This
899 // currently means that under X, the device context will not try to set a
900 // pen or brush property if it is known to be set already. This approach
901 // can fall down if non-wxWidgets code is using the same device context
902 // or window, for example when the window is a panel on which the
903 // windowing system draws panel items. The wxWidgets device context
904 // 'memory' will now be out of step with reality.
906 // Setting optimization off, drawing, then setting it back on again, is a
907 // trick that must occasionally be employed.", "");
910 // virtual bool , GetOptimization(),
911 // "Returns true if device context optimization is on. See
912 // `SetOptimization` for details.", "");
915 def SetOptimization(self, optimize):
917 def GetOptimization(self):
920 SetOptimization = wx._deprecated(SetOptimization)
921 GetOptimization = wx._deprecated(GetOptimization)
929 virtual void , CalcBoundingBox(wxCoord x, wxCoord y),
930 "Adds the specified point to the bounding box which can be retrieved
931 with `MinX`, `MaxX` and `MinY`, `MaxY` or `GetBoundingBox` functions.", "");
934 DocStr(CalcBoundingBoxPoint,
935 "Adds the specified point to the bounding box which can be retrieved
936 with `MinX`, `MaxX` and `MinY`, `MaxY` or `GetBoundingBox` functions.","");
937 void CalcBoundingBoxPoint(const wxPoint& point) {
938 self->CalcBoundingBox(point.x, point.y);
943 void , ResetBoundingBox(),
944 "Resets the bounding box: after a call to this function, the bounding
945 box doesn't contain anything.", "");
948 // Get the final bounding box of the PostScript or Metafile picture.
950 wxCoord , MinX() const,
951 "Gets the minimum horizontal extent used in drawing commands so far.", "");
954 wxCoord , MaxX() const,
955 "Gets the maximum horizontal extent used in drawing commands so far.", "");
958 wxCoord , MinY() const,
959 "Gets the minimum vertical extent used in drawing commands so far.", "");
962 wxCoord , MaxY() const,
963 "Gets the maximum vertical extent used in drawing commands so far.", "");
967 DocAStr(GetBoundingBox,
968 "GetBoundingBox() -> (x1,y1, x2,y2)",
969 "Returns the min and max points used in drawing commands so far.", "");
971 void GetBoundingBox(int* OUTPUT, int* OUTPUT, int* OUTPUT, int* OUTPUT);
972 // See below for implementation
975 %pythoncode { def __nonzero__(self): return self.IsOk() };
978 // RTL related functions
979 // ---------------------
982 virtual wxLayoutDirection , GetLayoutDirection() const,
983 "Get the layout direction (LTR or RTL)_ for this dc. On platforms
984 where RTL layout is supported, the return value will either be
985 ``wx.Layout_LeftToRight`` or ``wx.Layout_RightToLeft``.
986 ``wx.Layout_Default`` is returned if layout direction is not
990 virtual void , SetLayoutDirection(wxLayoutDirection dir),
991 "Change the layout direction for this dc.", "");
1001 %extend { // See drawlist.cpp for impplementaion of these...
1002 PyObject* _DrawPointList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
1004 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
1007 PyObject* _DrawLineList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
1009 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
1012 PyObject* _DrawRectangleList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
1014 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
1017 PyObject* _DrawEllipseList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
1019 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
1022 PyObject* _DrawPolygonList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
1024 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
1027 PyObject* _DrawTextList(PyObject* textList, PyObject* pyPoints,
1028 PyObject* foregroundList, PyObject* backgroundList) {
1029 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
1034 def DrawPointList(self, points, pens=None):
1036 Draw a list of points as quickly as possible.
1038 :param points: A sequence of 2-element sequences representing
1039 each point to draw, (x,y).
1040 :param pens: If None, then the current pen is used. If a
1041 single pen then it will be used for all points. If
1042 a list of pens then there should be one for each point
1047 elif isinstance(pens, wx.Pen):
1049 elif len(pens) != len(points):
1050 raise ValueError('points and pens must have same length')
1051 return self._DrawPointList(points, pens, [])
1054 def DrawLineList(self, lines, pens=None):
1056 Draw a list of lines as quickly as possible.
1058 :param lines: A sequence of 4-element sequences representing
1059 each line to draw, (x1,y1, x2,y2).
1060 :param pens: If None, then the current pen is used. If a
1061 single pen then it will be used for all lines. If
1062 a list of pens then there should be one for each line
1067 elif isinstance(pens, wx.Pen):
1069 elif len(pens) != len(lines):
1070 raise ValueError('lines and pens must have same length')
1071 return self._DrawLineList(lines, pens, [])
1074 def DrawRectangleList(self, rectangles, pens=None, brushes=None):
1076 Draw a list of rectangles as quickly as possible.
1078 :param rectangles: A sequence of 4-element sequences representing
1079 each rectangle to draw, (x,y, w,h).
1080 :param pens: If None, then the current pen is used. If a
1081 single pen then it will be used for all rectangles.
1082 If a list of pens then there should be one for each
1083 rectangle in rectangles.
1084 :param brushes: A brush or brushes to be used to fill the rectagles,
1085 with similar semantics as the pens parameter.
1089 elif isinstance(pens, wx.Pen):
1091 elif len(pens) != len(rectangles):
1092 raise ValueError('rectangles and pens must have same length')
1095 elif isinstance(brushes, wx.Brush):
1097 elif len(brushes) != len(rectangles):
1098 raise ValueError('rectangles and brushes must have same length')
1099 return self._DrawRectangleList(rectangles, pens, brushes)
1102 def DrawEllipseList(self, ellipses, pens=None, brushes=None):
1104 Draw a list of ellipses as quickly as possible.
1106 :param ellipses: A sequence of 4-element sequences representing
1107 each ellipse to draw, (x,y, w,h).
1108 :param pens: If None, then the current pen is used. If a
1109 single pen then it will be used for all ellipses.
1110 If a list of pens then there should be one for each
1111 ellipse in ellipses.
1112 :param brushes: A brush or brushes to be used to fill the ellipses,
1113 with similar semantics as the pens parameter.
1117 elif isinstance(pens, wx.Pen):
1119 elif len(pens) != len(ellipses):
1120 raise ValueError('ellipses and pens must have same length')
1123 elif isinstance(brushes, wx.Brush):
1125 elif len(brushes) != len(ellipses):
1126 raise ValueError('ellipses and brushes must have same length')
1127 return self._DrawEllipseList(ellipses, pens, brushes)
1130 def DrawPolygonList(self, polygons, pens=None, brushes=None):
1132 Draw a list of polygons, each of which is a list of points.
1134 :param polygons: A sequence of sequences of sequences.
1135 [[(x1,y1),(x2,y2),(x3,y3)...],
1136 [(x1,y1),(x2,y2),(x3,y3)...]]
1138 :param pens: If None, then the current pen is used. If a
1139 single pen then it will be used for all polygons.
1140 If a list of pens then there should be one for each
1142 :param brushes: A brush or brushes to be used to fill the polygons,
1143 with similar semantics as the pens parameter.
1147 elif isinstance(pens, wx.Pen):
1149 elif len(pens) != len(polygons):
1150 raise ValueError('polygons and pens must have same length')
1153 elif isinstance(brushes, wx.Brush):
1155 elif len(brushes) != len(polygons):
1156 raise ValueError('polygons and brushes must have same length')
1157 return self._DrawPolygonList(polygons, pens, brushes)
1160 def DrawTextList(self, textList, coords, foregrounds = None, backgrounds = None):
1162 Draw a list of strings using a list of coordinants for positioning each string.
1164 :param textList: A list of strings
1165 :param coords: A list of (x,y) positions
1166 :param foregrounds: A list of `wx.Colour` objects to use for the
1167 foregrounds of the strings.
1168 :param backgrounds: A list of `wx.Colour` objects to use for the
1169 backgrounds of the strings.
1171 NOTE: Make sure you set Background mode to wx.Solid (DC.SetBackgroundMode)
1172 If you want backgrounds to do anything.
1174 if type(textList) == type(''):
1175 textList = [textList]
1176 elif len(textList) != len(coords):
1177 raise ValueError('textlist and coords must have same length')
1178 if foregrounds is None:
1180 elif isinstance(foregrounds, wx.Colour):
1181 foregrounds = [foregrounds]
1182 elif len(foregrounds) != len(coords):
1183 raise ValueError('foregrounds and coords must have same length')
1184 if backgrounds is None:
1186 elif isinstance(backgrounds, wx.Colour):
1187 backgrounds = [backgrounds]
1188 elif len(backgrounds) != len(coords):
1189 raise ValueError('backgrounds and coords must have same length')
1190 return self._DrawTextList(textList, coords, foregrounds, backgrounds)
1193 %property(Background, GetBackground, SetBackground, doc="See `GetBackground` and `SetBackground`");
1194 %property(BackgroundMode, GetBackgroundMode, SetBackgroundMode, doc="See `GetBackgroundMode` and `SetBackgroundMode`");
1195 %property(BoundingBox, GetBoundingBox, doc="See `GetBoundingBox`");
1196 %property(Brush, GetBrush, SetBrush, doc="See `GetBrush` and `SetBrush`");
1197 %property(CharHeight, GetCharHeight, doc="See `GetCharHeight`");
1198 %property(CharWidth, GetCharWidth, doc="See `GetCharWidth`");
1199 %property(ClippingBox, GetClippingBox, doc="See `GetClippingBox`");
1200 %property(ClippingRect, GetClippingRect, SetClippingRect, doc="See `GetClippingRect` and `SetClippingRect`");
1201 %property(Depth, GetDepth, doc="See `GetDepth`");
1202 %property(DeviceOrigin, GetDeviceOrigin, SetDeviceOrigin, doc="See `GetDeviceOrigin` and `SetDeviceOrigin`");
1203 %property(Font, GetFont, SetFont, doc="See `GetFont` and `SetFont`");
1204 %property(FullTextExtent, GetFullTextExtent, doc="See `GetFullTextExtent`");
1205 %property(LogicalFunction, GetLogicalFunction, SetLogicalFunction, doc="See `GetLogicalFunction` and `SetLogicalFunction`");
1206 %property(LogicalOrigin, GetLogicalOrigin, SetLogicalOrigin, doc="See `GetLogicalOrigin` and `SetLogicalOrigin`");
1207 %property(LogicalScale, GetLogicalScale, SetLogicalScale, doc="See `GetLogicalScale` and `SetLogicalScale`");
1208 %property(MapMode, GetMapMode, SetMapMode, doc="See `GetMapMode` and `SetMapMode`");
1209 %property(MultiLineTextExtent, GetMultiLineTextExtent, doc="See `GetMultiLineTextExtent`");
1210 %property(Optimization, GetOptimization, SetOptimization, doc="See `GetOptimization` and `SetOptimization`");
1211 %property(PPI, GetPPI, doc="See `GetPPI`");
1212 %property(PartialTextExtents, GetPartialTextExtents, doc="See `GetPartialTextExtents`");
1213 %property(Pen, GetPen, SetPen, doc="See `GetPen` and `SetPen`");
1214 %property(Pixel, GetPixel, doc="See `GetPixel`");
1215 %property(PixelPoint, GetPixelPoint, doc="See `GetPixelPoint`");
1216 %property(Size, GetSize, doc="See `GetSize`");
1217 %property(SizeMM, GetSizeMM, doc="See `GetSizeMM`");
1218 %property(TextBackground, GetTextBackground, SetTextBackground, doc="See `GetTextBackground` and `SetTextBackground`");
1219 %property(TextExtent, GetTextExtent, doc="See `GetTextExtent`");
1220 %property(TextForeground, GetTextForeground, SetTextForeground, doc="See `GetTextForeground` and `SetTextForeground`");
1221 %property(UserScale, GetUserScale, SetUserScale, doc="See `GetUserScale` and `SetUserScale`");
1223 %property(LayoutDirection, GetLayoutDirection, SetLayoutDirection);
1229 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
1238 //---------------------------------------------------------------------------
1241 MustHaveApp(wxMemoryDC);
1244 "A memory device context provides a means to draw graphics onto a
1245 bitmap. A bitmap must be selected into the new memory DC before it may
1246 be used for anything. Typical usage is as follows::
1249 dc.SelectObject(bitmap)
1250 # draw on the dc using any of the Draw methods
1251 dc.SelectObject(wx.NullBitmap)
1252 # the bitmap now contains wahtever was drawn upon it
1254 Note that the memory DC *must* be deleted (or the bitmap selected out
1255 of it) before a bitmap can be reselected into another memory DC.
1258 class wxMemoryDC : public wxDC {
1261 wxMemoryDC(const wxBitmap& bitmap = wxNullBitmap),
1262 "Constructs a new memory device context.
1264 Use the Ok member to test whether the constructor was successful in
1265 creating a usable device context. If a bitmap is not given to this
1266 constructor then don't forget to select a bitmap into the DC before
1269 :see: `MemoryDCFromDC`");
1272 wxMemoryDC(wxDC* oldDC),
1273 "Creates a DC that is compatible with the oldDC.", "",
1278 void , SelectObject(const wxBitmap& bitmap),
1279 "Selects the bitmap into the device context, to use as the memory
1280 bitmap. Selecting the bitmap into a memory DC allows you to draw into
1281 the DC, and therefore the bitmap, and also to use Blit to copy the
1284 If the argument is wx.NullBitmap (or some other uninitialised
1285 `wx.Bitmap`) the current bitmap is selected out of the device context,
1286 and the original bitmap restored, allowing the current bitmap to be
1287 destroyed safely.", "");
1291 //---------------------------------------------------------------------------
1294 MustHaveApp(wxScreenDC);
1297 "A wxScreenDC can be used to paint anywhere on the screen. This should
1298 normally be constructed as a temporary stack object; don't store a
1301 class wxScreenDC : public wxDC {
1306 bool , StartDrawingOnTop(wxWindow* window),
1307 "Specify that the area of the screen to be drawn upon coincides with
1310 :see: `EndDrawingOnTop`", "",
1311 StartDrawingOnTopWin);
1315 bool , StartDrawingOnTop(wxRect* rect = NULL),
1316 "Specify that the area is the given rectangle, or the whole screen if
1319 :see: `EndDrawingOnTop`", "");
1323 bool , EndDrawingOnTop(),
1324 "Use this in conjunction with `StartDrawingOnTop` or
1325 `StartDrawingOnTopWin` to ensure that drawing to the screen occurs on
1326 top of existing windows. Without this, some window systems (such as X)
1327 only allow drawing to take place underneath other windows.
1329 You might use this pair of functions when implementing a drag feature,
1330 for example as in the `wx.SplitterWindow` implementation.
1332 These functions are probably obsolete since the X implementations
1333 allow drawing directly on the screen now. However, the fact that this
1334 function allows the screen to be refreshed afterwards may be useful
1335 to some applications.", "");
1339 //---------------------------------------------------------------------------
1342 MustHaveApp(wxWindowDC);
1345 "A wx.WindowDC must be constructed if an application wishes to paint on
1346 the whole area of a window (client and decorations). This should
1347 normally be constructed as a temporary stack object; don't store a
1348 wx.WindowDC object.","");
1349 class wxWindowDC : public wxDC {
1352 wxWindowDC(wxWindow* win),
1353 "Constructor. Pass the window on which you wish to paint.","");
1356 //---------------------------------------------------------------------------
1359 MustHaveApp(wxClientDC);
1362 "A wx.ClientDC must be constructed if an application wishes to paint on
1363 the client area of a window from outside an EVT_PAINT event. This should
1364 normally be constructed as a temporary stack object; don't store a
1365 wx.ClientDC object long term.
1367 To draw on a window from within an EVT_PAINT handler, construct a
1368 `wx.PaintDC` object.
1370 To draw on the whole window including decorations, construct a
1371 `wx.WindowDC` object (Windows only).
1373 class wxClientDC : public wxWindowDC {
1376 wxClientDC(wxWindow* win),
1377 "Constructor. Pass the window on which you wish to paint.", "");
1380 //---------------------------------------------------------------------------
1383 MustHaveApp(wxPaintDC);
1386 "A wx.PaintDC must be constructed if an application wishes to paint on
1387 the client area of a window from within an EVT_PAINT event
1388 handler. This should normally be constructed as a temporary stack
1389 object; don't store a wx.PaintDC object. If you have an EVT_PAINT
1390 handler, you **must** create a wx.PaintDC object within it even if you
1391 don't actually use it.
1393 Using wx.PaintDC within EVT_PAINT handlers is important because it
1394 automatically sets the clipping area to the damaged area of the
1395 window. Attempts to draw outside this area do not appear.
1397 To draw on a window from outside EVT_PAINT handlers, construct a
1398 `wx.ClientDC` object.
1400 class wxPaintDC : public wxClientDC {
1403 wxPaintDC(wxWindow* win),
1404 "Constructor. Pass the window on which you wish to paint.", "");
1409 //---------------------------------------------------------------------------
1414 #include <wx/dcbuffer.h>
1418 wxBUFFER_VIRTUAL_AREA,
1419 wxBUFFER_CLIENT_AREA
1422 MustHaveApp(wxBufferedDC);
1424 DocStr(wxBufferedDC,
1425 "This simple class provides a simple way to avoid flicker: when drawing
1426 on it, everything is in fact first drawn on an in-memory buffer (a
1427 `wx.Bitmap`) and then copied to the screen only once, when this object
1430 It can be used in the same way as any other device context.
1431 wx.BufferedDC itself typically replaces `wx.ClientDC`, if you want to
1432 use it in your EVT_PAINT handler, you should look at
1433 `wx.BufferedPaintDC`.
1435 Please note that GTK+ 2.0 and OS X provide double buffering themselves
1436 natively. wxBufferedDC is aware of this however, and will bypass the buffering
1437 unless an explicit buffer bitmap is given.
1440 class wxBufferedDC : public wxMemoryDC
1443 %pythonAppend wxBufferedDC
1444 "self.__dc = args[0] # save a ref so the other dc will not be deleted before self";
1446 %nokwargs wxBufferedDC;
1450 "Constructs a buffered DC.", "
1452 :param dc: The underlying DC: everything drawn to this object will
1453 be flushed to this DC when this object is destroyed. You may
1454 pass ``None`` in order to just initialize the buffer, and not
1457 :param buffer: If a `wx.Size` object is passed as the 2nd arg then
1458 it is the size of the bitmap that will be created internally
1459 and used for an implicit buffer. If the 2nd arg is a
1460 `wx.Bitmap` then it is the explicit buffer that will be
1461 used. Using an explicit buffer is the most efficient solution
1462 as the bitmap doesn't have to be recreated each time but it
1463 also requires more memory as the bitmap is never freed. The
1464 bitmap should have appropriate size, anything drawn outside of
1465 its bounds is clipped. If wx.NullBitmap is used then a new
1466 buffer will be allocated that is the same size as the dc.
1468 :param style: The style parameter indicates whether the supplied buffer is
1469 intended to cover the entire virtual size of a `wx.ScrolledWindow` or
1470 if it only covers the client area. Acceptable values are
1471 ``wx.BUFFER_VIRTUAL_AREA`` and ``wx.BUFFER_CLIENT_AREA``.
1474 wxBufferedDC( wxDC* dc,
1475 const wxBitmap& buffer=wxNullBitmap,
1476 int style = wxBUFFER_CLIENT_AREA );
1477 wxBufferedDC( wxDC* dc,
1479 int style = wxBUFFER_CLIENT_AREA );
1480 // wxBufferedDC(wxWindow* win,
1482 // const wxSize &area,
1483 // int style = wxBUFFER_CLIENT_AREA);
1488 "Copies everything drawn on the DC so far to the underlying DC
1489 associated with this object, if any.", "");
1494 "Blits the buffer to the dc, and detaches the dc from the buffer (so it
1495 can be effectively used once only). This is usually only called in
1496 the destructor.", "");
1503 MustHaveApp(wxBufferedPaintDC);
1505 DocStr(wxBufferedPaintDC,
1506 "This is a subclass of `wx.BufferedDC` which can be used inside of an
1507 EVT_PAINT event handler. Just create an object of this class instead
1508 of `wx.PaintDC` and that's all you have to do to (mostly) avoid
1509 flicker. The only thing to watch out for is that if you are using this
1510 class together with `wx.ScrolledWindow`, you probably do **not** want
1511 to call `wx.Window.PrepareDC` on it as it already does this internally
1512 for the real underlying `wx.PaintDC`.
1514 If your window is already fully buffered in a `wx.Bitmap` then your
1515 EVT_PAINT handler can be as simple as just creating a
1516 ``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
1517 automatically when it is destroyed. For example::
1519 def OnPaint(self, event):
1520 dc = wx.BufferedPaintDC(self, self.buffer)
1525 class wxBufferedPaintDC : public wxBufferedDC
1530 wxBufferedPaintDC( wxWindow *window,
1531 const wxBitmap &buffer = wxNullBitmap,
1532 int style = wxBUFFER_CLIENT_AREA),
1533 "Create a buffered paint DC. As with `wx.BufferedDC`, you may either
1534 provide the bitmap to be used for buffering or let this object create
1535 one internally (in the latter case, the size of the client part of the
1536 window is automatically used).", "");
1540 //---------------------------------------------------------------------------
1543 // Epydoc doesn't like this for some strange reason...
1545 // if 'wxMac' in wx.PlatformInfo or 'gtk2' in wx.PlatformInfo:
1546 // _AutoBufferedPaintDCBase = PaintDC
1548 // _AutoBufferedPaintDCBase = BufferedPaintDC
1550 // class AutoBufferedPaintDC(_AutoBufferedPaintDCBase):
1552 // If the current platform double buffers by default then this DC is the
1553 // same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
1555 // :see: `wx.AutoBufferedPaintDCFactory`
1557 // def __init__(self, window):
1558 // _AutoBufferedPaintDCBase.__init__(self, window)
1562 DocStr(wxAutoBufferedPaintDC,
1563 "If the current platform double buffers by default then this DC is the
1564 same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
1566 :see: `wx.AutoBufferedPaintDCFactory`
1569 class wxAutoBufferedPaintDC: public wxDC
1572 wxAutoBufferedPaintDC(wxWindow* win);
1576 %newobject wxAutoBufferedPaintDCFactory;
1578 wxDC* , wxAutoBufferedPaintDCFactory(wxWindow* window),
1579 "Checks if the window is natively double buffered and will return a
1580 `wx.PaintDC` if it is, a `wx.BufferedPaintDC` otherwise. The advantage of
1581 this function over `wx.AutoBufferedPaintDC` is that this function will check
1582 if the the specified window has double-buffering enabled rather than just
1583 going by platform defaults.", "");
1587 //---------------------------------------------------------------------------
1590 MustHaveApp(wxMirrorDC);
1593 "wx.MirrorDC is a simple wrapper class which is always associated with a
1594 real `wx.DC` object and either forwards all of its operations to it
1595 without changes (no mirroring takes place) or exchanges x and y
1596 coordinates which makes it possible to reuse the same code to draw a
1597 figure and its mirror -- i.e. reflection related to the diagonal line
1599 class wxMirrorDC : public wxDC
1603 wxMirrorDC(wxDC& dc, bool mirror),
1604 "Creates a mirrored DC associated with the real *dc*. Everything drawn
1605 on the wx.MirrorDC will appear on the *dc*, and will be mirrored if
1606 *mirror* is True.","");
1609 //---------------------------------------------------------------------------
1613 #include <wx/dcps.h>
1616 MustHaveApp(wxPostScriptDC);
1618 DocStr(wxPostScriptDC,
1619 "This is a `wx.DC` that can write to PostScript files on any platform.","");
1621 class wxPostScriptDC : public wxDC {
1624 wxPostScriptDC(const wxPrintData& printData),
1625 "Constructs a PostScript printer device context from a `wx.PrintData`
1628 wxPrintData& GetPrintData();
1629 void SetPrintData(const wxPrintData& data);
1632 static void , SetResolution(int ppi),
1633 "Set resolution (in pixels per inch) that will be used in PostScript
1634 output. Default is 720ppi.", "");
1637 static int , GetResolution(),
1638 "Return resolution used in PostScript output.", "");
1640 %property(PrintData, GetPrintData, SetPrintData, doc="See `GetPrintData` and `SetPrintData`");
1643 //---------------------------------------------------------------------------
1647 MustHaveApp(wxMetaFile);
1648 MustHaveApp(wxMetaFileDC);
1651 #if defined(__WXMSW__) || defined(__WXMAC__)
1654 #include <wx/metafile.h>
1657 class wxMetaFile : public wxObject {
1659 wxMetaFile(const wxString& filename = wxPyEmptyString);
1663 %pythoncode { Ok = IsOk }
1664 bool SetClipboard(int width = 0, int height = 0);
1671 const wxString& GetFileName() const;
1674 %pythoncode { def __nonzero__(self): return self.IsOk() }
1677 // bool wxMakeMetaFilePlaceable(const wxString& filename,
1678 // int minX, int minY, int maxX, int maxY, float scale=1.0);
1681 class wxMetaFileDC : public wxDC {
1683 wxMetaFileDC(const wxString& filename = wxPyEmptyString,
1684 int width = 0, int height = 0,
1685 const wxString& description = wxPyEmptyString);
1686 wxMetaFile* Close();
1691 #else // Make some dummies for the other platforms
1694 class wxMetaFile : public wxObject {
1696 wxMetaFile(const wxString&)
1697 { wxPyRaiseNotImplemented(); }
1700 class wxMetaFileDC : public wxClientDC {
1702 wxMetaFileDC(const wxString&, int, int, const wxString&)
1703 { wxPyRaiseNotImplemented(); }
1708 class wxMetaFile : public wxObject {
1710 wxMetaFile(const wxString& filename = wxPyEmptyString);
1713 class wxMetaFileDC : public wxDC {
1715 wxMetaFileDC(const wxString& filename = wxPyEmptyString,
1716 int width = 0, int height = 0,
1717 const wxString& description = wxPyEmptyString);
1724 //---------------------------------------------------------------------------
1726 MustHaveApp(wxPrinterDC);
1728 #if defined(__WXMSW__) || defined(__WXMAC__)
1730 class wxPrinterDC : public wxDC {
1732 wxPrinterDC(const wxPrintData& printData);
1737 class wxPrinterDC : public wxClientDC {
1739 wxPrinterDC(const wxPrintData&)
1740 { wxPyRaiseNotImplemented(); }
1745 class wxPrinterDC : public wxDC {
1747 wxPrinterDC(const wxPrintData& printData);
1751 //---------------------------------------------------------------------------
1752 //---------------------------------------------------------------------------