]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: | |
3 | // Purpose: Wraper definitions for the wxPseudoDC Class | |
4 | // Author: Paul Lanier | |
5 | // Modified by: | |
6 | // Created: 05/25/06 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) wxWidgets team | |
9 | // Licence: wxWindows licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | ||
13 | %{ | |
14 | #include "wx/wxPython/pseudodc.h" | |
15 | %} | |
16 | ||
17 | %newgroup; | |
18 | ||
19 | DocStr(wxPseudoDC, | |
20 | "A PseudoDC is an object that can be used as if it were a `wx.DC`. All | |
21 | commands issued to the PseudoDC are stored in a list. You can then | |
22 | play these commands back to a real DC object using the DrawToDC | |
23 | method. Commands in the command list are indexed by ID. You can use | |
24 | this to clear the operations associated with a single ID and then | |
25 | re-draw the object associated with that ID.", ""); | |
26 | ||
27 | class wxPseudoDC : public wxObject | |
28 | { | |
29 | public: | |
30 | DocCtorStr( | |
31 | wxPseudoDC(), | |
32 | "Constructs a new Pseudo device context for recording dc operations",""); | |
33 | DocDeclStr( | |
34 | void , BeginDrawing(), | |
35 | "Allows for optimization of drawing code on platforms that need it. On | |
36 | other platforms this is just an empty function and is harmless. To | |
37 | take advantage of this postential optimization simply enclose each | |
38 | group of calls to the drawing primitives within calls to | |
39 | `BeginDrawing` and `EndDrawing`.", ""); | |
40 | ||
41 | DocDeclStr( | |
42 | void , EndDrawing(), | |
43 | "Ends the group of drawing primitives started with `BeginDrawing`, and | |
44 | invokes whatever optimization is available for this DC type on the | |
45 | current platform.", ""); | |
46 | DocCtorStr( | |
47 | ~wxPseudoDC(), | |
48 | "Frees memory used by the operation list of the pseudo dc",""); | |
49 | DocDeclStr( | |
50 | void, RemoveAll(), | |
51 | "Removes all objects and operations from the recorded list.", ""); | |
52 | DocDeclStr( | |
53 | int, GetLen(), | |
54 | "Returns the number of operations in the recorded list.", ""); | |
55 | DocDeclStr( | |
56 | void, SetId(int id), | |
57 | "Sets the id to be associated with subsequent operations.", ""); | |
58 | DocDeclStr( | |
59 | void, ClearId(int id), | |
60 | "Removes all operations associated with id so the object can be redrawn.", ""); | |
61 | DocDeclStr( | |
62 | void, RemoveId(int id), | |
63 | "Remove the object node (and all operations) associated with an id.", ""); | |
64 | DocDeclStr( | |
65 | void, TranslateId(int id, wxCoord dx, wxCoord dy), | |
66 | "Translate the operations of id by dx,dy.", ""); | |
67 | DocDeclStr( | |
68 | void, SetIdGreyedOut(int id, bool greyout=true), | |
69 | "Set whether an object is drawn greyed out or not.", ""); | |
70 | DocDeclStr( | |
71 | bool, GetIdGreyedOut(int id), | |
72 | "Get whether an object is drawn greyed out or not.", ""); | |
73 | KeepGIL(FindObjects); | |
74 | DocDeclStr( | |
75 | PyObject*, FindObjects(wxCoord x, wxCoord y, | |
76 | wxCoord radius=1, const wxColour& bg=*wxWHITE), | |
77 | "Returns a list of all the id's that draw a pixel with color | |
78 | not equal to bg within radius of (x,y). | |
79 | Returns an empty list if nothing is found. The list is in | |
80 | reverse drawing order so list[0] is the top id.",""); | |
81 | KeepGIL(FindObjectsByBBox); | |
82 | DocDeclStr( | |
83 | PyObject*, FindObjectsByBBox(wxCoord x, wxCoord y), | |
84 | "Returns a list of all the id's whose bounding boxes include (x,y). | |
85 | Returns an empty list if nothing is found. The list is in | |
86 | reverse drawing order so list[0] is the top id.",""); | |
87 | DocDeclStr( | |
88 | void, DrawIdToDC(int id, wxDC *dc), | |
89 | "Draw recorded operations of id to dc.", ""); | |
90 | DocDeclStr( | |
91 | void, SetIdBounds(int id, wxRect& rect), | |
92 | "Set the bounding rect of a given object. This will create | |
93 | an object node if one doesn't exist.", ""); | |
94 | %extend { | |
95 | DocStr( | |
96 | GetIdBounds, | |
97 | "Returns the bounding rectangle previouly set with SetIdBounds. If | |
98 | no bounds have been set, it returns wx.Rect(0,0,0,0).", ""); | |
99 | wxRect GetIdBounds(int id) { | |
100 | wxRect rect; | |
101 | self->GetIdBounds(id, rect); | |
102 | return rect; | |
103 | } | |
104 | } | |
105 | DocDeclStr( | |
106 | void, DrawToDCClipped(wxDC *dc, const wxRect& rect), | |
107 | "Draws the recorded operations to dc unless the operation is known to | |
108 | be outside rect.", ""); | |
109 | DocDeclStr( | |
110 | void, DrawToDCClippedRgn(wxDC *dc, const wxRegion& region), | |
111 | "Draws the recorded operations to dc unless the operation is known to | |
112 | be outside rect.", ""); | |
113 | DocDeclStr( | |
114 | void, DrawToDC(wxDC *dc), | |
115 | "Draws the recorded operations to dc.", ""); | |
116 | ||
117 | //------------------------------------------------------------------------- | |
118 | // Methods Mirrored from wxDC | |
119 | //------------------------------------------------------------------------- | |
120 | // | |
121 | // DocDeclStr( | |
122 | // void , SetFont(const wxFont& font), | |
123 | // "Sets the current font for the DC. It must be a valid font, in | |
124 | //particular you should not pass ``wx.NullFont`` to this method."," | |
125 | // | |
126 | //:see: `wx.Font`"); | |
127 | // | |
128 | // DocDeclStr( | |
129 | // void , SetPen(const wxPen& pen), | |
130 | // "Sets the current pen for the DC. | |
131 | // | |
132 | //If the argument is ``wx.NullPen``, the current pen is selected out of the | |
133 | //device context, and the original pen restored.", " | |
134 | // | |
135 | //:see: `wx.Pen`"); | |
136 | // | |
137 | // DocDeclStr( | |
138 | // void , SetBrush(const wxBrush& brush), | |
139 | // "Sets the current brush for the DC. | |
140 | // | |
141 | //If the argument is ``wx.NullBrush``, the current brush is selected out | |
142 | //of the device context, and the original brush restored, allowing the | |
143 | //current brush to be destroyed safely."," | |
144 | // | |
145 | //:see: `wx.Brush`"); | |
146 | // | |
147 | // DocDeclStr( | |
148 | // void , SetBackground(const wxBrush& brush), | |
149 | // "Sets the current background brush for the DC.", ""); | |
150 | // | |
151 | // DocDeclStr( | |
152 | // void , SetBackgroundMode(int mode), | |
153 | // "*mode* may be one of ``wx.SOLID`` and ``wx.TRANSPARENT``. This setting | |
154 | //determines whether text will be drawn with a background colour or | |
155 | //not.", ""); | |
156 | // | |
157 | // DocDeclStr( | |
158 | // void , SetTextForeground(const wxColour& colour), | |
159 | // "Sets the current text foreground colour for the DC.", ""); | |
160 | // | |
161 | // DocDeclStr( | |
162 | // void , SetTextBackground(const wxColour& colour), | |
163 | // "Sets the current text background colour for the DC.", ""); | |
164 | // DocDeclStr( | |
165 | // void , DrawLabel(const wxString& text, const wxRect& rect, | |
166 | // int alignment = wxALIGN_LEFT | wxALIGN_TOP, | |
167 | // int indexAccel = -1), | |
168 | // "Draw *text* within the specified rectangle, abiding by the alignment | |
169 | //flags. Will additionally emphasize the character at *indexAccel* if | |
170 | //it is not -1.", " | |
171 | // | |
172 | //:see: `DrawImageLabel`"); | |
173 | // DocStr( | |
174 | // DrawText, | |
175 | // "Draws a text string at the specified point, using the current text | |
176 | //font, and the current text foreground and background colours. | |
177 | // | |
178 | //The coordinates refer to the top-left corner of the rectangle bounding | |
179 | //the string. See `GetTextExtent` for how to get the dimensions of a | |
180 | //text string, which can be used to position the text more precisely. | |
181 | // | |
182 | //**NOTE**: under wxGTK the current logical function is used by this | |
183 | //function but it is ignored by wxMSW. Thus, you should avoid using | |
184 | //logical functions with this function in portable programs.", " | |
185 | // | |
186 | //:see: `DrawRotatedText`"); | |
187 | // void DrawText(const wxString& text, wxCoord x, wxCoord y); | |
188 | // DocStr( | |
189 | // DrawLine, | |
190 | // "Draws a line from the first point to the second. The current pen is | |
191 | //used for drawing the line. Note that the second point is *not* part of | |
192 | //the line and is not drawn by this function (this is consistent with | |
193 | //the behaviour of many other toolkits).", ""); | |
194 | // void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2); | |
195 | // DocDeclStr( | |
196 | // void, DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height), | |
197 | // "Draws a rectangle with the given top left corner, and with the given | |
198 | //size. The current pen is used for the outline and the current brush | |
199 | //for filling the shape.", ""); | |
200 | // DocDeclStr( | |
201 | // void , Clear(), | |
202 | // "Clears the device context using the current background brush.", ""); | |
203 | ||
204 | DocStr( | |
205 | FloodFill, | |
206 | "Flood fills the device context starting from the given point, using | |
207 | the current brush colour, and using a style: | |
208 | ||
209 | - **wxFLOOD_SURFACE**: the flooding occurs until a colour other than | |
210 | the given colour is encountered. | |
211 | ||
212 | - **wxFLOOD_BORDER**: the area to be flooded is bounded by the given | |
213 | colour. | |
214 | ||
215 | Returns False if the operation failed. | |
216 | ||
217 | Note: The present implementation for non-Windows platforms may fail to | |
218 | find colour borders if the pixels do not match the colour | |
219 | exactly. However the function will still return true.", ""); | |
220 | void FloodFill(wxCoord x, wxCoord y, const wxColour& col, int style = wxFLOOD_SURFACE); | |
221 | %Rename(FloodFillPoint, void, FloodFill(const wxPoint& pt, const wxColour& col, int style = wxFLOOD_SURFACE)); | |
222 | ||
223 | ||
224 | DocStr( | |
225 | DrawLine, | |
226 | "Draws a line from the first point to the second. The current pen is | |
227 | used for drawing the line. Note that the second point is *not* part of | |
228 | the line and is not drawn by this function (this is consistent with | |
229 | the behaviour of many other toolkits).", ""); | |
230 | void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2); | |
231 | %Rename(DrawLinePoint, void, DrawLine(const wxPoint& pt1, const wxPoint& pt2)); | |
232 | ||
233 | ||
234 | DocStr( | |
235 | CrossHair, | |
236 | "Displays a cross hair using the current pen. This is a vertical and | |
237 | horizontal line the height and width of the window, centred on the | |
238 | given point.", ""); | |
239 | void CrossHair(wxCoord x, wxCoord y); | |
240 | %Rename(CrossHairPoint, void, CrossHair(const wxPoint& pt)); | |
241 | ||
242 | ||
243 | DocStr( | |
244 | DrawArc, | |
245 | "Draws an arc of a circle, centred on the *center* point (xc, yc), from | |
246 | the first point to the second. The current pen is used for the outline | |
247 | and the current brush for filling the shape. | |
248 | ||
249 | The arc is drawn in an anticlockwise direction from the start point to | |
250 | the end point.", ""); | |
251 | void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc); | |
252 | %Rename(DrawArcPoint, void, DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& center)); | |
253 | ||
254 | ||
255 | DocStr( | |
256 | DrawCheckMark, | |
257 | "Draws a check mark inside the given rectangle.", ""); | |
258 | void DrawCheckMark(wxCoord x, wxCoord y, wxCoord width, wxCoord height); | |
259 | %Rename(DrawCheckMarkRect, void, DrawCheckMark(const wxRect& rect)); | |
260 | ||
261 | DocStr( | |
262 | DrawEllipticArc, | |
263 | "Draws an arc of an ellipse, with the given rectangle defining the | |
264 | bounds of the ellipse. The current pen is used for drawing the arc and | |
265 | the current brush is used for drawing the pie. | |
266 | ||
267 | The *start* and *end* parameters specify the start and end of the arc | |
268 | relative to the three-o'clock position from the center of the | |
269 | rectangle. Angles are specified in degrees (360 is a complete | |
270 | circle). Positive values mean counter-clockwise motion. If start is | |
271 | equal to end, a complete ellipse will be drawn.", ""); | |
272 | void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h, double start, double end); | |
273 | %Rename(DrawEllipticArcPointSize, void, DrawEllipticArc(const wxPoint& pt, const wxSize& sz, double start, double end)); | |
274 | ||
275 | ||
276 | DocStr( | |
277 | DrawPoint, | |
278 | "Draws a point using the current pen.", ""); | |
279 | void DrawPoint(wxCoord x, wxCoord y); | |
280 | %Rename(DrawPointPoint, void, DrawPoint(const wxPoint& pt)); | |
281 | ||
282 | ||
283 | DocStr( | |
284 | DrawRectangle, | |
285 | "Draws a rectangle with the given top left corner, and with the given | |
286 | size. The current pen is used for the outline and the current brush | |
287 | for filling the shape.", ""); | |
288 | void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height); | |
289 | %Rename(DrawRectangleRect,void, DrawRectangle(const wxRect& rect)); | |
290 | %Rename(DrawRectanglePointSize, void, DrawRectangle(const wxPoint& pt, const wxSize& sz)); | |
291 | ||
292 | ||
293 | DocStr( | |
294 | DrawRoundedRectangle, | |
295 | "Draws a rectangle with the given top left corner, and with the given | |
296 | size. The corners are quarter-circles using the given radius. The | |
297 | current pen is used for the outline and the current brush for filling | |
298 | the shape. | |
299 | ||
300 | If radius is positive, the value is assumed to be the radius of the | |
301 | rounded corner. If radius is negative, the absolute value is assumed | |
302 | to be the proportion of the smallest dimension of the rectangle. This | |
303 | means that the corner can be a sensible size relative to the size of | |
304 | the rectangle, and also avoids the strange effects X produces when the | |
305 | corners are too big for the rectangle.", ""); | |
306 | void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius); | |
307 | %Rename(DrawRoundedRectangleRect, void, DrawRoundedRectangle(const wxRect& r, double radius)); | |
308 | %Rename(DrawRoundedRectanglePointSize, void, DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz, double radius)); | |
309 | ||
310 | ||
311 | DocStr( | |
312 | DrawCircle, | |
313 | "Draws a circle with the given center point and radius. The current | |
314 | pen is used for the outline and the current brush for filling the | |
315 | shape.", " | |
316 | ||
317 | :see: `DrawEllipse`"); | |
318 | void DrawCircle(wxCoord x, wxCoord y, wxCoord radius); | |
319 | %Rename(DrawCirclePoint, void, DrawCircle(const wxPoint& pt, wxCoord radius)); | |
320 | ||
321 | ||
322 | DocStr( | |
323 | DrawEllipse, | |
324 | "Draws an ellipse contained in the specified rectangle. The current pen | |
325 | is used for the outline and the current brush for filling the shape.", " | |
326 | ||
327 | :see: `DrawCircle`"); | |
328 | void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height); | |
329 | %Rename(DrawEllipseRect, void, DrawEllipse(const wxRect& rect)); | |
330 | %Rename(DrawEllipsePointSize, void, DrawEllipse(const wxPoint& pt, const wxSize& sz)); | |
331 | ||
332 | ||
333 | DocStr( | |
334 | DrawIcon, | |
335 | "Draw an icon on the display (does nothing if the device context is | |
336 | PostScript). This can be the simplest way of drawing bitmaps on a | |
337 | window.", ""); | |
338 | void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y); | |
339 | %Rename(DrawIconPoint, void, DrawIcon(const wxIcon& icon, const wxPoint& pt)); | |
340 | ||
341 | ||
342 | DocStr( | |
343 | DrawBitmap, | |
344 | "Draw a bitmap on the device context at the specified point. If | |
345 | *transparent* is true and the bitmap has a transparency mask, (or | |
346 | alpha channel on the platforms that support it) then the bitmap will | |
347 | be drawn transparently.", " | |
348 | ||
349 | When drawing a mono-bitmap, the current text foreground colour will be | |
350 | used to draw the foreground of the bitmap (all bits set to 1), and the | |
351 | current text background colour to draw the background (all bits set to | |
352 | 0). | |
353 | ||
354 | :see: `SetTextForeground`, `SetTextBackground` and `wx.MemoryDC`"); | |
355 | void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask = false); | |
356 | %Rename(DrawBitmapPoint, void, DrawBitmap(const wxBitmap &bmp, const wxPoint& pt, bool useMask = false)); | |
357 | ||
358 | ||
359 | DocStr( | |
360 | DrawText, | |
361 | "Draws a text string at the specified point, using the current text | |
362 | font, and the current text foreground and background colours. | |
363 | ||
364 | The coordinates refer to the top-left corner of the rectangle bounding | |
365 | the string. See `wx.DC.GetTextExtent` for how to get the dimensions of | |
366 | a text string, which can be used to position the text more precisely, | |
367 | (you will need to use a real DC with GetTextExtent as wx.PseudoDC does | |
368 | not implement it.) | |
369 | ||
370 | **NOTE**: under wxGTK the current logical function is used by this | |
371 | function but it is ignored by wxMSW. Thus, you should avoid using | |
372 | logical functions with this function in portable programs.", " | |
373 | ||
374 | :see: `DrawRotatedText`"); | |
375 | void DrawText(const wxString& text, wxCoord x, wxCoord y); | |
376 | %Rename(DrawTextPoint, void, DrawText(const wxString& text, const wxPoint& pt)); | |
377 | ||
378 | ||
379 | DocStr( | |
380 | DrawRotatedText, | |
381 | "Draws the text rotated by *angle* degrees, if supported by the platform. | |
382 | ||
383 | **NOTE**: Under Win9x only TrueType fonts can be drawn by this | |
384 | function. In particular, a font different from ``wx.NORMAL_FONT`` | |
385 | should be used as the it is not normally a TrueType | |
386 | font. ``wx.SWISS_FONT`` is an example of a font which is."," | |
387 | ||
388 | :see: `DrawText`"); | |
389 | void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle); | |
390 | %Rename(DrawRotatedTextPoint, void, DrawRotatedText(const wxString& text, const wxPoint& pt, double angle)); | |
391 | ||
392 | ||
393 | // DocDeclStr( | |
394 | // bool , Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, | |
395 | // wxDC *source, wxCoord xsrc, wxCoord ysrc, | |
396 | // int rop = wxCOPY, bool useMask = false, | |
397 | // wxCoord xsrcMask = -1, wxCoord ysrcMask = -1), | |
398 | // "Copy from a source DC to this DC. Parameters specify the destination | |
399 | //coordinates, size of area to copy, source DC, source coordinates, | |
400 | //logical function, whether to use a bitmap mask, and mask source | |
401 | //position.", " | |
402 | // | |
403 | // :param xdest: Destination device context x position. | |
404 | // :param ydest: Destination device context y position. | |
405 | // :param width: Width of source area to be copied. | |
406 | // :param height: Height of source area to be copied. | |
407 | // :param source: Source device context. | |
408 | // :param xsrc: Source device context x position. | |
409 | // :param ysrc: Source device context y position. | |
410 | // :param rop: Logical function to use: see `SetLogicalFunction`. | |
411 | // :param useMask: If true, Blit does a transparent blit using the mask | |
412 | // that is associated with the bitmap selected into the | |
413 | // source device context. | |
414 | // :param xsrcMask: Source x position on the mask. If both xsrcMask and | |
415 | // ysrcMask are -1, xsrc and ysrc will be assumed for | |
416 | // the mask source position. | |
417 | // :param ysrcMask: Source y position on the mask. | |
418 | //"); | |
419 | ||
420 | // DocDeclStrName( | |
421 | // bool , Blit(const wxPoint& destPt, const wxSize& sz, | |
422 | // wxDC *source, const wxPoint& srcPt, | |
423 | // int rop = wxCOPY, bool useMask = false, | |
424 | // const wxPoint& srcPtMask = wxDefaultPosition), | |
425 | // "Copy from a source DC to this DC. Parameters specify the destination | |
426 | //coordinates, size of area to copy, source DC, source coordinates, | |
427 | //logical function, whether to use a bitmap mask, and mask source | |
428 | //position.", " | |
429 | // | |
430 | // :param destPt: Destination device context position. | |
431 | // :param sz: Size of source area to be copied. | |
432 | // :param source: Source device context. | |
433 | // :param srcPt: Source device context position. | |
434 | // :param rop: Logical function to use: see `SetLogicalFunction`. | |
435 | // :param useMask: If true, Blit does a transparent blit using the mask | |
436 | // that is associated with the bitmap selected into the | |
437 | // source device context. | |
438 | // :param srcPtMask: Source position on the mask. | |
439 | //", | |
440 | // BlitPointSize); | |
441 | ||
442 | ||
443 | DocDeclAStr( | |
444 | void , DrawLines(int points, wxPoint* points_array, | |
445 | wxCoord xoffset = 0, wxCoord yoffset = 0), | |
446 | "DrawLines(self, List points, int xoffset=0, int yoffset=0)", | |
447 | "Draws lines using a sequence of `wx.Point` objects, adding the | |
448 | optional offset coordinate. The current pen is used for drawing the | |
449 | lines.", ""); | |
450 | ||
451 | ||
452 | DocDeclAStr( | |
453 | void , DrawPolygon(int points, wxPoint* points_array, | |
454 | wxCoord xoffset = 0, wxCoord yoffset = 0, | |
455 | int fillStyle = wxODDEVEN_RULE), | |
456 | "DrawPolygon(self, List points, int xoffset=0, int yoffset=0, | |
457 | int fillStyle=ODDEVEN_RULE)", | |
458 | "Draws a filled polygon using a sequence of `wx.Point` objects, adding | |
459 | the optional offset coordinate. The last argument specifies the fill | |
460 | rule: ``wx.ODDEVEN_RULE`` (the default) or ``wx.WINDING_RULE``. | |
461 | ||
462 | The current pen is used for drawing the outline, and the current brush | |
463 | for filling the shape. Using a transparent brush suppresses | |
464 | filling. Note that wxWidgets automatically closes the first and last | |
465 | points.", ""); | |
466 | ||
467 | ||
468 | // TODO: Figure out a good typemap for this... | |
469 | // Convert the first 3 args from a sequence of sequences? | |
470 | // void DrawPolyPolygon(int n, int count[], wxPoint points[], | |
471 | // wxCoord xoffset = 0, wxCoord yoffset = 0, | |
472 | // int fillStyle = wxODDEVEN_RULE); | |
473 | ||
474 | ||
475 | DocDeclStr( | |
476 | void , DrawLabel(const wxString& text, const wxRect& rect, | |
477 | int alignment = wxALIGN_LEFT | wxALIGN_TOP, | |
478 | int indexAccel = -1), | |
479 | "Draw *text* within the specified rectangle, abiding by the alignment | |
480 | flags. Will additionally emphasize the character at *indexAccel* if | |
481 | it is not -1.", " | |
482 | ||
483 | :see: `DrawImageLabel`"); | |
484 | ||
485 | DocDeclStrName( | |
486 | void, DrawLabel(const wxString& text, | |
487 | const wxBitmap& image, | |
488 | const wxRect& rect, | |
489 | int alignment = wxALIGN_LEFT | wxALIGN_TOP, | |
490 | int indexAccel = -1), | |
491 | "Draw *text* and an image (which may be ``wx.NullBitmap`` to skip | |
492 | drawing it) within the specified rectangle, abiding by the alignment | |
493 | flags. Will additionally emphasize the character at *indexAccel* if | |
494 | it is not -1.", "", DrawImageLabel); | |
495 | ||
496 | ||
497 | DocDeclAStr( | |
498 | void , DrawSpline(int points, wxPoint* points_array), | |
499 | "DrawSpline(self, List points)", | |
500 | "Draws a spline between all given control points, (a list of `wx.Point` | |
501 | objects) using the current pen. The spline is drawn using a series of | |
502 | lines, using an algorithm taken from the X drawing program 'XFIG'.", ""); | |
503 | ||
504 | ||
505 | DocDeclStr( | |
506 | virtual void , Clear(), | |
507 | "Clears the device context using the current background brush.", ""); | |
508 | ||
509 | ||
510 | // set objects to use for drawing | |
511 | // ------------------------------ | |
512 | ||
513 | DocDeclStr( | |
514 | virtual void , SetFont(const wxFont& font), | |
515 | "Sets the current font for the DC. It must be a valid font, in | |
516 | particular you should not pass ``wx.NullFont`` to this method."," | |
517 | ||
518 | :see: `wx.Font`"); | |
519 | ||
520 | DocDeclStr( | |
521 | virtual void , SetPen(const wxPen& pen), | |
522 | "Sets the current pen for the DC. | |
523 | ||
524 | If the argument is ``wx.NullPen``, the current pen is selected out of the | |
525 | device context, and the original pen restored.", " | |
526 | ||
527 | :see: `wx.Pen`"); | |
528 | ||
529 | DocDeclStr( | |
530 | virtual void , SetBrush(const wxBrush& brush), | |
531 | "Sets the current brush for the DC. | |
532 | ||
533 | If the argument is ``wx.NullBrush``, the current brush is selected out | |
534 | of the device context, and the original brush restored, allowing the | |
535 | current brush to be destroyed safely."," | |
536 | ||
537 | :see: `wx.Brush`"); | |
538 | ||
539 | DocDeclStr( | |
540 | virtual void , SetBackground(const wxBrush& brush), | |
541 | "Sets the current background brush for the DC.", ""); | |
542 | ||
543 | DocDeclStr( | |
544 | virtual void , SetBackgroundMode(int mode), | |
545 | "*mode* may be one of ``wx.SOLID`` and ``wx.TRANSPARENT``. This setting | |
546 | determines whether text will be drawn with a background colour or | |
547 | not.", ""); | |
548 | ||
549 | DocDeclStr( | |
550 | virtual void , SetPalette(const wxPalette& palette), | |
551 | "If this is a window DC or memory DC, assigns the given palette to the | |
552 | window or bitmap associated with the DC. If the argument is | |
553 | ``wx.NullPalette``, the current palette is selected out of the device | |
554 | context, and the original palette restored.", " | |
555 | ||
556 | :see: `wx.Palette`"); | |
557 | ||
558 | ||
559 | DocDeclStr( | |
560 | virtual void , SetTextForeground(const wxColour& colour), | |
561 | "Sets the current text foreground colour for the DC.", ""); | |
562 | ||
563 | DocDeclStr( | |
564 | virtual void , SetTextBackground(const wxColour& colour), | |
565 | "Sets the current text background colour for the DC.", ""); | |
566 | ||
567 | DocDeclStr( | |
568 | virtual void , SetLogicalFunction(int function), | |
569 | "Sets the current logical function for the device context. This | |
570 | determines how a source pixel (from a pen or brush colour, combines | |
571 | with a destination pixel in the current device context. | |
572 | ||
573 | The possible values and their meaning in terms of source and | |
574 | destination pixel values are as follows: | |
575 | ||
576 | ================ ========================== | |
577 | wx.AND src AND dst | |
578 | wx.AND_INVERT (NOT src) AND dst | |
579 | wx.AND_REVERSE src AND (NOT dst) | |
580 | wx.CLEAR 0 | |
581 | wx.COPY src | |
582 | wx.EQUIV (NOT src) XOR dst | |
583 | wx.INVERT NOT dst | |
584 | wx.NAND (NOT src) OR (NOT dst) | |
585 | wx.NOR (NOT src) AND (NOT dst) | |
586 | wx.NO_OP dst | |
587 | wx.OR src OR dst | |
588 | wx.OR_INVERT (NOT src) OR dst | |
589 | wx.OR_REVERSE src OR (NOT dst) | |
590 | wx.SET 1 | |
591 | wx.SRC_INVERT NOT src | |
592 | wx.XOR src XOR dst | |
593 | ================ ========================== | |
594 | ||
595 | The default is wx.COPY, which simply draws with the current | |
596 | colour. The others combine the current colour and the background using | |
597 | a logical operation. wx.INVERT is commonly used for drawing rubber | |
598 | bands or moving outlines, since drawing twice reverts to the original | |
599 | colour. | |
600 | ", ""); | |
601 | ||
602 | ||
603 | %property(IdBounds, GetIdBounds, SetIdBounds, doc="See `GetIdBounds` and `SetIdBounds`"); | |
604 | %property(Len, GetLen, doc="See `GetLen`"); | |
605 | }; |