]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: _window.i | |
3 | // Purpose: SWIG interface for wxWindow | |
4 | // | |
5 | // Author: Robin Dunn | |
6 | // | |
7 | // Created: 24-June-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 | ||
21 | MAKE_CONST_WXSTRING(PanelNameStr); | |
22 | ||
23 | //--------------------------------------------------------------------------- | |
24 | %newgroup | |
25 | ||
26 | ||
27 | DocStr(wxVisualAttributes, | |
28 | "struct containing all the visual attributes of a control", ""); | |
29 | ||
30 | struct wxVisualAttributes | |
31 | { | |
32 | %extend { | |
33 | wxVisualAttributes() { return new wxVisualAttributes; } | |
34 | ~wxVisualAttributes() { delete self; } | |
35 | } | |
36 | ||
37 | // the font used for control label/text inside it | |
38 | wxFont font; | |
39 | ||
40 | // the foreground colour | |
41 | wxColour colFg; | |
42 | ||
43 | // the background colour, may be wxNullColour if the controls background | |
44 | // colour is not solid | |
45 | wxColour colBg; | |
46 | }; | |
47 | ||
48 | ||
49 | ||
50 | ||
51 | enum wxWindowVariant | |
52 | { | |
53 | wxWINDOW_VARIANT_NORMAL, // Normal size | |
54 | wxWINDOW_VARIANT_SMALL, // Smaller size (about 25 % smaller than normal ) | |
55 | wxWINDOW_VARIANT_MINI, // Mini size (about 33 % smaller than normal ) | |
56 | wxWINDOW_VARIANT_LARGE, // Large size (about 25 % larger than normal ) | |
57 | wxWINDOW_VARIANT_MAX | |
58 | }; | |
59 | ||
60 | ||
61 | DocStr(wxWindow, | |
62 | "wx.Window is the base class for all windows and represents any visible | |
63 | object on the screen. All controls, top level windows and so on are | |
64 | wx.Windows. Sizers and device contexts are not however, as they don't | |
65 | appear on screen themselves. | |
66 | ", | |
67 | " | |
68 | Styles | |
69 | ------- | |
70 | ============================= ===================================== | |
71 | wx.SIMPLE_BORDER Displays a thin border around the window. | |
72 | ||
73 | wx.DOUBLE_BORDER Displays a double border. Windows and Mac only. | |
74 | ||
75 | wx.SUNKEN_BORDER Displays a sunken border. | |
76 | ||
77 | wx.RAISED_BORDER Displays a raised border. | |
78 | ||
79 | wx.STATIC_BORDER Displays a border suitable for a static | |
80 | control. Windows only. | |
81 | ||
82 | wx.NO_BORDER Displays no border, overriding the default | |
83 | border style for the window. | |
84 | ||
85 | wx.TRANSPARENT_WINDOW The window is transparent, that is, it | |
86 | will not receive paint events. Windows only. | |
87 | ||
88 | wx.TAB_TRAVERSAL Use this to enable tab traversal for | |
89 | non-dialog windows. | |
90 | ||
91 | wx.WANTS_CHARS Use this to indicate that the window | |
92 | wants to get all char/key events for | |
93 | all keys - even for keys like TAB or | |
94 | ENTER which are usually used for | |
95 | dialog navigation and which wouldn't | |
96 | be generated without this style. If | |
97 | you need to use this style in order to | |
98 | get the arrows or etc., but would | |
99 | still like to have normal keyboard | |
100 | navigation take place, you should | |
101 | create and send a wxNavigationKeyEvent | |
102 | in response to the key events for Tab | |
103 | and Shift-Tab. | |
104 | ||
105 | wx.NO_FULL_REPAINT_ON_RESIZE Disables repainting the window | |
106 | completely when its size is changed. | |
107 | You will have to repaint the new | |
108 | window area manually if you use this | |
109 | style. As of version 2.5.1 this | |
110 | style is on by default. Use | |
111 | wx.FULL_REPAINT_ON_RESIZE to | |
112 | deactivate it. | |
113 | ||
114 | wx.VSCROLL Use this style to enable a vertical scrollbar. | |
115 | ||
116 | wx.HSCROLL Use this style to enable a horizontal scrollbar. | |
117 | ||
118 | wx.ALWAYS_SHOW_SB If a window has scrollbars, disable them | |
119 | instead of hiding them when they are | |
120 | not needed (i.e. when the size of the | |
121 | window is big enough to not require | |
122 | the scrollbars to navigate it). This | |
123 | style is currently only implemented | |
124 | for wxMSW and wxUniversal and does | |
125 | nothing on the other platforms. | |
126 | ||
127 | wx.CLIP_CHILDREN Use this style to eliminate flicker caused by | |
128 | the background being repainted, then | |
129 | children being painted over | |
130 | them. Windows only. | |
131 | ||
132 | wx.FULL_REPAINT_ON_RESIZE Use this style to force a complete | |
133 | redraw of the window whenever it is | |
134 | resized instead of redrawing just the | |
135 | part of the window affected by | |
136 | resizing. Note that this was the | |
137 | behaviour by default before 2.5.1 | |
138 | release and that if you experience | |
139 | redraw problems with the code which | |
140 | previously used to work you may want | |
141 | to try this. | |
142 | ============================= ===================================== | |
143 | ||
144 | ||
145 | Extra Styles | |
146 | ------------ | |
147 | ============================= ===================================== | |
148 | wx.WS_EX_VALIDATE_RECURSIVELY By default, | |
149 | Validate/TransferDataTo/FromWindow() | |
150 | only work on direct children of | |
151 | the window (compatible | |
152 | behaviour). Set this flag to make | |
153 | them recursively descend into all | |
154 | subwindows. | |
155 | ||
156 | wx.WS_EX_BLOCK_EVENTS wx.CommandEvents and the objects of the | |
157 | derived classes are forwarded to | |
158 | the parent window and so on | |
159 | recursively by default. Using this | |
160 | flag for the given window allows | |
161 | to block this propagation at this | |
162 | window, i.e. prevent the events | |
163 | from being propagated further | |
164 | upwards. Dialogs have this flag on | |
165 | by default. | |
166 | ||
167 | wx.WS_EX_TRANSIENT Don't use this window as an implicit parent for | |
168 | the other windows: this must be | |
169 | used with transient windows as | |
170 | otherwise there is the risk of | |
171 | creating a dialog/frame with this | |
172 | window as a parent which would | |
173 | lead to a crash if the parent is | |
174 | destroyed before the child. | |
175 | ||
176 | wx.WS_EX_PROCESS_IDLE This window should always process idle | |
177 | events, even if the mode set by | |
178 | `wx.IdleEvent.SetMode` is | |
179 | wx.IDLE_PROCESS_SPECIFIED. | |
180 | ||
181 | wx.WS_EX_PROCESS_UI_UPDATES This window should always process UI | |
182 | update events, even if the mode | |
183 | set by `wx.UpdateUIEvent.SetMode` is | |
184 | wxUPDATE_UI_PROCESS_SPECIFIED. | |
185 | ============================= ===================================== | |
186 | ||
187 | "); | |
188 | ||
189 | ||
190 | MustHaveApp(wxWindow); | |
191 | MustHaveApp(wxWindow::FindFocus); | |
192 | MustHaveApp(wxWindow::GetCapture); | |
193 | ||
194 | // This one is not restricted to wxWindow | |
195 | MustHaveApp(GetClassDefaultAttributes); | |
196 | ||
197 | class wxWindow : public wxEvtHandler | |
198 | { | |
199 | public: | |
200 | %pythonAppend wxWindow "self._setOORInfo(self)" | |
201 | %pythonAppend wxWindow() "" | |
202 | %typemap(out) wxWindow*; // turn off this typemap | |
203 | ||
204 | DocCtorStr( | |
205 | wxWindow(wxWindow* parent, const wxWindowID id=-1, | |
206 | const wxPoint& pos = wxDefaultPosition, | |
207 | const wxSize& size = wxDefaultSize, | |
208 | long style = 0, | |
209 | const wxString& name = wxPyPanelNameStr), | |
210 | "Construct and show a generic Window.", ""); | |
211 | ||
212 | DocCtorStrName( | |
213 | wxWindow(), | |
214 | "Precreate a Window for 2-phase creation.", "", | |
215 | PreWindow); | |
216 | ||
217 | // Turn it back on again | |
218 | %typemap(out) wxWindow* { $result = wxPyMake_wxObject($1, $owner); } | |
219 | ||
220 | ||
221 | DocDeclStr( | |
222 | bool , Create(wxWindow* parent, const wxWindowID id=-1, | |
223 | const wxPoint& pos = wxDefaultPosition, | |
224 | const wxSize& size = wxDefaultSize, | |
225 | long style = 0, | |
226 | const wxString& name = wxPyPanelNameStr), | |
227 | "Create the GUI part of the Window for 2-phase creation mode.", ""); | |
228 | ||
229 | ||
230 | // deleting the window | |
231 | // ------------------- | |
232 | ||
233 | ||
234 | DocDeclStr( | |
235 | bool , Close( bool force = false ), | |
236 | "This function simply generates a EVT_CLOSE event whose handler usually | |
237 | tries to close the window. It doesn't close the window itself, | |
238 | however. If force is False (the default) then the window's close | |
239 | handler will be allowed to veto the destruction of the window.", | |
240 | " | |
241 | Usually Close is only used with the top level windows (wx.Frame and | |
242 | wx.Dialog classes) as the others are not supposed to have any special | |
243 | EVT_CLOSE logic. | |
244 | ||
245 | The close handler should check whether the window is being deleted | |
246 | forcibly, using wx.CloseEvent.GetForce, in which case it should | |
247 | destroy the window using wx.Window.Destroy. | |
248 | ||
249 | Note that calling Close does not guarantee that the window will be | |
250 | destroyed; but it provides a way to simulate a manual close of a | |
251 | window, which may or may not be implemented by destroying the | |
252 | window. The default EVT_CLOSE handler for wx.Dialog does not | |
253 | necessarily delete the dialog, since it will simply simulate an | |
254 | wxID_CANCEL event which is handled by the appropriate button event | |
255 | handler and may do anything at all. | |
256 | ||
257 | To guarantee that the window will be destroyed, call wx.Window.Destroy | |
258 | instead."); | |
259 | ||
260 | ||
261 | ||
262 | DocDeclStr( | |
263 | virtual bool , Destroy(), | |
264 | "Destroys the window safely. Frames and dialogs are not destroyed | |
265 | immediately when this function is called -- they are added to a list | |
266 | of windows to be deleted on idle time, when all the window's events | |
267 | have been processed. This prevents problems with events being sent to | |
268 | non-existent windows. | |
269 | ||
270 | Returns True if the window has either been successfully deleted, or it | |
271 | has been added to the list of windows pending real deletion.", ""); | |
272 | ||
273 | ||
274 | DocDeclStr( | |
275 | bool , DestroyChildren(), | |
276 | "Destroys all children of a window. Called automatically by the | |
277 | destructor.", ""); | |
278 | ||
279 | ||
280 | DocDeclStr( | |
281 | bool , IsBeingDeleted() const, | |
282 | "Is the window in the process of being deleted?", ""); | |
283 | ||
284 | ||
285 | ||
286 | // window attributes | |
287 | // ----------------- | |
288 | ||
289 | DocDeclStr( | |
290 | virtual void , SetTitle( const wxString& title), | |
291 | "Sets the window's title. Applicable only to frames and dialogs.", ""); | |
292 | ||
293 | DocDeclStr( | |
294 | virtual wxString , GetTitle() const, | |
295 | "Gets the window's title. Applicable only to frames and dialogs.", ""); | |
296 | ||
297 | ||
298 | DocDeclStr( | |
299 | virtual void , SetLabel(const wxString& label), | |
300 | "Set the text which the window shows in its label if applicable.", ""); | |
301 | ||
302 | DocDeclStr( | |
303 | virtual wxString , GetLabel() const, | |
304 | "Generic way of getting a label from any window, for identification | |
305 | purposes. The interpretation of this function differs from class to | |
306 | class. For frames and dialogs, the value returned is the title. For | |
307 | buttons or static text controls, it is the button text. This function | |
308 | can be useful for meta-programs such as testing tools or special-needs | |
309 | access programs)which need to identify windows by name.", ""); | |
310 | ||
311 | ||
312 | DocDeclStr( | |
313 | virtual void , SetName( const wxString &name ), | |
314 | "Sets the window's name. The window name is used for ressource setting | |
315 | in X, it is not the same as the window title/label", ""); | |
316 | ||
317 | DocDeclStr( | |
318 | virtual wxString , GetName() const, | |
319 | "Returns the windows name. This name is not guaranteed to be unique; | |
320 | it is up to the programmer to supply an appropriate name in the window | |
321 | constructor or via wx.Window.SetName.", ""); | |
322 | ||
323 | ||
324 | DocDeclStr( | |
325 | void , SetWindowVariant( wxWindowVariant variant ), | |
326 | "Sets the variant of the window/font size to use for this window, if | |
327 | the platform supports variants, for example, wxMac.", | |
328 | " | |
329 | Variant values are: | |
330 | ||
331 | ======================== ======================================= | |
332 | wx.WINDOW_VARIANT_NORMAL Normal size | |
333 | wx.WINDOW_VARIANT_SMALL Smaller size (about 25 % smaller than normal) | |
334 | wx.WINDOW_VARIANT_MINI Mini size (about 33 % smaller than normal) | |
335 | wx.WINDOW_VARIANT_LARGE Large size (about 25 % larger than normal) | |
336 | ======================== ======================================= | |
337 | "); | |
338 | ||
339 | DocDeclStr( | |
340 | wxWindowVariant , GetWindowVariant() const, | |
341 | "", ""); | |
342 | ||
343 | ||
344 | DocDeclStr( | |
345 | void , SetId( wxWindowID winid ), | |
346 | "Sets the identifier of the window. Each window has an integer | |
347 | identifier. If the application has not provided one, an identifier | |
348 | will be generated. Normally, the identifier should be provided on | |
349 | creation and should not be modified subsequently.", ""); | |
350 | ||
351 | DocDeclStr( | |
352 | wxWindowID , GetId() const, | |
353 | "Returns the identifier of the window. Each window has an integer | |
354 | identifier. If the application has not provided one (or the default Id | |
355 | -1 is used) then an unique identifier with a negative value will be | |
356 | generated.", ""); | |
357 | ||
358 | ||
359 | DocDeclStr( | |
360 | static int , NewControlId(), | |
361 | "Generate a control id for the controls which were not given one.", ""); | |
362 | ||
363 | ||
364 | DocDeclStr( | |
365 | static int , NextControlId(int winid), | |
366 | "Get the id of the control following the one with the given | |
367 | autogenerated) id", ""); | |
368 | ||
369 | ||
370 | DocDeclStr( | |
371 | static int , PrevControlId(int winid), | |
372 | "Get the id of the control preceding the one with the given | |
373 | autogenerated) id", ""); | |
374 | ||
375 | ||
376 | ||
377 | ||
378 | // moving/resizing | |
379 | // --------------- | |
380 | ||
381 | ||
382 | DocDeclStr( | |
383 | void , SetSize( const wxSize& size ), | |
384 | "Sets the size of the window in pixels.", ""); | |
385 | ||
386 | ||
387 | DocDeclStrName( | |
388 | void , SetSize( int x, int y, int width, int height, | |
389 | int sizeFlags = wxSIZE_AUTO ), | |
390 | "Sets the position and size of the window in pixels. The sizeFlags | |
391 | parameter indicates the interpretation of the other params if they are | |
392 | equal to -1. | |
393 | ||
394 | ======================== ====================================== | |
395 | wx.SIZE_AUTO A -1 indicates that a class-specific | |
396 | default should be used. | |
397 | wx.SIZE_USE_EXISTING Axisting dimensions should be used if | |
398 | -1 values are supplied. | |
399 | wxSIZE_ALLOW_MINUS_ONE Allow dimensions of -1 and less to be | |
400 | interpreted as real dimensions, not | |
401 | default values. | |
402 | ======================== ====================================== | |
403 | ", "", | |
404 | SetDimensions); | |
405 | ||
406 | ||
407 | DocDeclStrName( | |
408 | void , SetSize(const wxRect& rect, int sizeFlags = wxSIZE_AUTO), | |
409 | "Sets the position and size of the window in pixels using a wx.Rect.", "", | |
410 | SetRect); | |
411 | ||
412 | ||
413 | DocDeclStrName( | |
414 | void , SetSize( int width, int height ), | |
415 | "Sets the size of the window in pixels.", "", | |
416 | SetSizeWH); | |
417 | ||
418 | ||
419 | DocDeclStr( | |
420 | void , Move(const wxPoint& pt, int flags = wxSIZE_USE_EXISTING), | |
421 | "Moves the window to the given position.", ""); | |
422 | ||
423 | %pythoncode { SetPosition = Move } | |
424 | ||
425 | ||
426 | DocDeclStrName( | |
427 | void , Move(int x, int y, int flags = wxSIZE_USE_EXISTING), | |
428 | "Moves the window to the given position.", "", | |
429 | MoveXY); | |
430 | ||
431 | DocDeclStr( | |
432 | void , SetBestFittingSize(const wxSize& size=wxDefaultSize), | |
433 | "A 'Smart' SetSize that will fill in default size components with the | |
434 | window's *best size* values. Also set's the minsize for use with sizers.", ""); | |
435 | ||
436 | ||
437 | ||
438 | DocDeclStr( | |
439 | virtual void , Raise(), | |
440 | "Raises the window to the top of the window hierarchy if it is a | |
441 | managed window (dialog or frame).", ""); | |
442 | ||
443 | DocDeclStr( | |
444 | virtual void , Lower(), | |
445 | "Lowers the window to the bottom of the window hierarchy if it is a | |
446 | managed window (dialog or frame).", ""); | |
447 | ||
448 | ||
449 | ||
450 | // client size is the size of the area available for subwindows | |
451 | DocStr(SetClientSize, | |
452 | "This sets the size of the window client area in pixels. Using this | |
453 | function to size a window tends to be more device-independent than | |
454 | wx.Window.SetSize, since the application need not worry about what | |
455 | dimensions the border or title bar have when trying to fit the window | |
456 | around panel items, for example.", ""); | |
457 | void SetClientSize( const wxSize& size ); | |
458 | %Rename(SetClientSizeWH, void, SetClientSize( int width, int height )); | |
459 | %Rename(SetClientRect, void, SetClientSize(const wxRect& rect)); | |
460 | ||
461 | ||
462 | DocStr(GetPosition, // sets the docstring for both | |
463 | "Get the window's position.", ""); | |
464 | wxPoint GetPosition(); | |
465 | ||
466 | DocDeclAName( | |
467 | void, GetPosition(int *OUTPUT, int *OUTPUT), | |
468 | "GetPositionTuple() -> (x,y)", | |
469 | GetPositionTuple); | |
470 | ||
471 | ||
472 | DocStr(GetSize, "Get the window size.", ""); | |
473 | wxSize GetSize() const; | |
474 | DocDeclAName( | |
475 | void, GetSize( int *OUTPUT, int *OUTPUT ) const, | |
476 | "GetSizeTuple() -> (width, height)", | |
477 | GetSizeTuple); | |
478 | ||
479 | ||
480 | ||
481 | DocDeclStr( | |
482 | wxRect , GetRect() const, | |
483 | "Returns the size and position of the window as a wx.Rect object.", ""); | |
484 | ||
485 | ||
486 | DocStr(GetClientSize, | |
487 | "This gets the size of the window's 'client area' in pixels. The client | |
488 | area is the area which may be drawn on by the programmer, excluding | |
489 | title bar, border, scrollbars, etc.", ""); | |
490 | wxSize GetClientSize() const; | |
491 | DocDeclAName( | |
492 | void, GetClientSize( int *OUTPUT, int *OUTPUT ) const, | |
493 | "GetClientSizeTuple() -> (width, height)", | |
494 | GetClientSizeTuple); | |
495 | ||
496 | ||
497 | ||
498 | DocDeclStr( | |
499 | virtual wxPoint , GetClientAreaOrigin() const, | |
500 | "Get the origin of the client area of the window relative to the | |
501 | window's top left corner (the client area may be shifted because of | |
502 | the borders, scrollbars, other decorations...)", ""); | |
503 | ||
504 | ||
505 | DocDeclStr( | |
506 | wxRect , GetClientRect() const, | |
507 | "Get the client area position and size as a `wx.Rect` object.", ""); | |
508 | ||
509 | ||
510 | ||
511 | DocStr(GetBestSize, | |
512 | "This function returns the best acceptable minimal size for the | |
513 | window, if applicable. For example, for a static text control, it will | |
514 | be the minimal size such that the control label is not truncated. For | |
515 | windows containing subwindows (suzh aswx.Panel), the size returned by | |
516 | this function will be the same as the size the window would have had | |
517 | after calling Fit.", ""); | |
518 | wxSize GetBestSize() const; | |
519 | DocDeclAName( | |
520 | void, GetBestSize(int *OUTPUT, int *OUTPUT) const, | |
521 | "GetBestSizeTuple() -> (width, height)", | |
522 | GetBestSizeTuple); | |
523 | ||
524 | ||
525 | DocDeclStr( | |
526 | void , InvalidateBestSize(), | |
527 | "Reset the cached best size value so it will be recalculated the next | |
528 | time it is needed.", ""); | |
529 | ||
530 | DocDeclStr( | |
531 | void , CacheBestSize(const wxSize& size) const, | |
532 | "Cache the best size so it doesn't need to be calculated again, (at least until | |
533 | some properties of the window change.)", ""); | |
534 | ||
535 | ||
536 | DocDeclStr( | |
537 | wxSize , GetBestFittingSize() const, | |
538 | "This function will merge the window's best size into the window's | |
539 | minimum size, giving priority to the min size components, and returns | |
540 | the results. | |
541 | ", ""); | |
542 | ||
543 | ||
544 | DocDeclStr( | |
545 | wxSize , GetAdjustedBestSize() const, | |
546 | "This method is similar to GetBestSize, except in one | |
547 | thing. GetBestSize should return the minimum untruncated size of the | |
548 | window, while this method will return the largest of BestSize and any | |
549 | user specified minimum size. ie. it is the minimum size the window | |
550 | should currently be drawn at, not the minimal size it can possibly | |
551 | tolerate.", ""); | |
552 | ||
553 | ||
554 | ||
555 | ||
556 | DocDeclStr( | |
557 | void , Center( int direction = wxBOTH ), | |
558 | "Centers the window. The parameter specifies the direction for | |
559 | cetering, and may be wx.HORIZONTAL, wx.VERTICAL or wx.BOTH. It may | |
560 | also include wx.CENTER_ON_SCREEN flag if you want to center the window | |
561 | on the entire screen and not on its parent window. If it is a | |
562 | top-level window and has no parent then it will always be centered | |
563 | relative to the screen.", ""); | |
564 | ||
565 | %pythoncode { Centre = Center } | |
566 | ||
567 | ||
568 | DocDeclStr( | |
569 | void , CenterOnScreen(int dir = wxBOTH), | |
570 | "Center on screen (only works for top level windows)", ""); | |
571 | %pythoncode { CentreOnScreen = CenterOnScreen } | |
572 | ||
573 | ||
574 | DocDeclStr( | |
575 | void , CenterOnParent(int dir = wxBOTH), | |
576 | "Center with respect to the the parent window", ""); | |
577 | %pythoncode { CentreOnParent = CenterOnParent } | |
578 | ||
579 | ||
580 | ||
581 | DocDeclStr( | |
582 | virtual void , Fit(), | |
583 | "Sizes the window so that it fits around its subwindows. This function | |
584 | won't do anything if there are no subwindows and will only really work | |
585 | correctly if sizers are used for the subwindows layout. Also, if the | |
586 | window has exactly one subwindow it is better (faster and the result | |
587 | is more precise as Fit adds some margin to account for fuzziness of | |
588 | its calculations) to call window.SetClientSize(child.GetSize()) | |
589 | instead of calling Fit.", ""); | |
590 | ||
591 | ||
592 | DocDeclStr( | |
593 | virtual void , FitInside(), | |
594 | "Similar to Fit, but sizes the interior (virtual) size of a | |
595 | window. Mainly useful with scrolled windows to reset scrollbars after | |
596 | sizing changes that do not trigger a size event, and/or scrolled | |
597 | windows without an interior sizer. This function similarly won't do | |
598 | anything if there are no subwindows.", ""); | |
599 | ||
600 | ||
601 | ||
602 | DocStr(SetSizeHints, | |
603 | "Allows specification of minimum and maximum window sizes, and window | |
604 | size increments. If a pair of values is not set (or set to -1), the | |
605 | default values will be used. If this function is called, the user | |
606 | will not be able to size the window outside the given bounds (if it is | |
607 | a top-level window.) Sizers will also inspect the minimum window size | |
608 | and will use that value if set when calculating layout. | |
609 | ||
610 | The resizing increments are only significant under Motif or Xt.", " | |
611 | ||
612 | :see: `GetMinSize`, `GetMaxSize`, `SetMinSize`, `SetMaxSize` | |
613 | "); | |
614 | virtual void SetSizeHints( int minW, int minH, | |
615 | int maxW = -1, int maxH = -1, | |
616 | int incW = -1, int incH = -1 ); | |
617 | %Rename(SetSizeHintsSz, void, SetSizeHints( const wxSize& minSize, | |
618 | const wxSize& maxSize=wxDefaultSize, | |
619 | const wxSize& incSize=wxDefaultSize)); | |
620 | ||
621 | ||
622 | DocStr(SetVirtualSizeHints, | |
623 | "Allows specification of minimum and maximum virtual window sizes. If a | |
624 | pair of values is not set (or set to -1), the default values will be | |
625 | used. If this function is called, the user will not be able to size | |
626 | the virtual area of the window outside the given bounds.", ""); | |
627 | virtual void SetVirtualSizeHints( int minW, int minH, | |
628 | int maxW = -1, int maxH = -1 ); | |
629 | %Rename(SetVirtualSizeHintsSz, void, SetVirtualSizeHints( | |
630 | const wxSize& minSize, const wxSize& maxSize=wxDefaultSize)); | |
631 | ||
632 | ||
633 | ||
634 | DocDeclStr( | |
635 | virtual wxSize , GetMaxSize() const, | |
636 | "", ""); | |
637 | ||
638 | DocDeclStr( | |
639 | virtual wxSize , GetMinSize() const, | |
640 | "", ""); | |
641 | ||
642 | DocDeclStr( | |
643 | void , SetMinSize(const wxSize& minSize), | |
644 | "A more convenient method than `SetSizeHints` for setting just the | |
645 | min size.", ""); | |
646 | ||
647 | DocDeclStr( | |
648 | void , SetMaxSize(const wxSize& maxSize), | |
649 | "A more convenient method than `SetSizeHints` for setting just the | |
650 | max size.", ""); | |
651 | ||
652 | ||
653 | ||
654 | DocDeclStr( | |
655 | virtual int , GetMinWidth() const, | |
656 | "", ""); | |
657 | ||
658 | DocDeclStr( | |
659 | virtual int , GetMinHeight() const, | |
660 | "", ""); | |
661 | ||
662 | DocDeclStr( | |
663 | int , GetMaxWidth() const, | |
664 | "", ""); | |
665 | ||
666 | DocDeclStr( | |
667 | int , GetMaxHeight() const, | |
668 | "", ""); | |
669 | ||
670 | ||
671 | ||
672 | DocStr(SetVirtualSize, | |
673 | "Set the the virtual size of a window in pixels. For most windows this | |
674 | is just the client area of the window, but for some like scrolled | |
675 | windows it is more or less independent of the screen window size.", ""); | |
676 | void SetVirtualSize(const wxSize& size ); | |
677 | %Rename(SetVirtualSizeWH, void, SetVirtualSize( int w, int h )); | |
678 | ||
679 | ||
680 | DocStr(GetVirtualSize, | |
681 | "Get the the virtual size of the window in pixels. For most windows | |
682 | this is just the client area of the window, but for some like scrolled | |
683 | windows it is more or less independent of the screen window size.", ""); | |
684 | wxSize GetVirtualSize() const; | |
685 | DocDeclAName( | |
686 | void, GetVirtualSize( int *OUTPUT, int *OUTPUT ) const, | |
687 | "GetVirtualSizeTuple() -> (width, height)", | |
688 | GetVirtualSizeTuple); | |
689 | ||
690 | ||
691 | // TODO: using directors? | |
692 | // // Override these methods for windows that have a virtual size | |
693 | // // independent of their client size. eg. the virtual area of a | |
694 | // // wxScrolledWindow. Default is to alias VirtualSize to ClientSize. | |
695 | // virtual void DoSetVirtualSize( int x, int y ); | |
696 | // virtual wxSize DoGetVirtualSize() const; // { return m_virtualSize; } | |
697 | ||
698 | ||
699 | DocDeclStr( | |
700 | virtual wxSize , GetBestVirtualSize() const, | |
701 | "Return the largest of ClientSize and BestSize (as determined by a | |
702 | sizer, interior children, or other means)", ""); | |
703 | ||
704 | ||
705 | ||
706 | // window state | |
707 | // ------------ | |
708 | ||
709 | DocDeclStr( | |
710 | virtual bool , Show( bool show = true ), | |
711 | "Shows or hides the window. You may need to call Raise for a top level | |
712 | window if you want to bring it to top, although this is not needed if | |
713 | Show is called immediately after the frame creation. Returns True if | |
714 | the window has been shown or hidden or False if nothing was done | |
715 | because it already was in the requested state.", ""); | |
716 | ||
717 | DocDeclStr( | |
718 | bool , Hide(), | |
719 | "Equivalent to calling Show(False).", ""); | |
720 | ||
721 | ||
722 | DocDeclStr( | |
723 | virtual bool , Enable( bool enable = true ), | |
724 | "Enable or disable the window for user input. Note that when a parent | |
725 | window is disabled, all of its children are disabled as well and they | |
726 | are reenabled again when the parent is. Returns true if the window | |
727 | has been enabled or disabled, false if nothing was done, i.e. if the | |
728 | window had already been in the specified state.", ""); | |
729 | ||
730 | DocDeclStr( | |
731 | bool , Disable(), | |
732 | "Disables the window, same as Enable(false).", ""); | |
733 | ||
734 | ||
735 | DocDeclStr( | |
736 | bool , IsShown() const, | |
737 | "Returns true if the window is shown, false if it has been hidden.", ""); | |
738 | ||
739 | DocDeclStr( | |
740 | bool , IsEnabled() const, | |
741 | "Returns true if the window is enabled for input, false otherwise.", ""); | |
742 | ||
743 | ||
744 | ||
745 | ||
746 | DocDeclStr( | |
747 | virtual void , SetWindowStyleFlag( long style ), | |
748 | "Sets the style of the window. Please note that some styles cannot be | |
749 | changed after the window creation and that Refresh() might need to be | |
750 | called after changing the others for the change to take place | |
751 | immediately.", ""); | |
752 | ||
753 | DocDeclStr( | |
754 | virtual long , GetWindowStyleFlag() const, | |
755 | "Gets the window style that was passed to the constructor or Create | |
756 | method.", ""); | |
757 | ||
758 | %pythoncode { SetWindowStyle = SetWindowStyleFlag; GetWindowStyle = GetWindowStyleFlag } | |
759 | ||
760 | ||
761 | DocDeclStr( | |
762 | bool , HasFlag(int flag) const, | |
763 | "Test if the given style is set for this window.", ""); | |
764 | ||
765 | ||
766 | DocDeclStr( | |
767 | virtual bool , IsRetained() const, | |
768 | "Returns true if the window is retained, false otherwise. Retained | |
769 | windows are only available on X platforms.", ""); | |
770 | ||
771 | ||
772 | ||
773 | DocDeclStr( | |
774 | virtual void , SetExtraStyle(long exStyle), | |
775 | "Sets the extra style bits for the window. Extra styles are the less | |
776 | often used style bits which can't be set with the constructor or with | |
777 | SetWindowStyleFlag()", ""); | |
778 | ||
779 | DocDeclStr( | |
780 | long , GetExtraStyle() const, | |
781 | "Returns the extra style bits for the window.", ""); | |
782 | ||
783 | ||
784 | ||
785 | DocDeclStr( | |
786 | virtual void , MakeModal(bool modal = true), | |
787 | "Disables all other windows in the application so that the user can | |
788 | only interact with this window. Passing False will reverse this | |
789 | effect.", ""); | |
790 | ||
791 | ||
792 | ||
793 | DocDeclStr( | |
794 | virtual void , SetThemeEnabled(bool enableTheme), | |
795 | "This function tells a window if it should use the system's \"theme\" | |
796 | code to draw the windows' background instead if its own background | |
797 | drawing code. This will only have an effect on platforms that support | |
798 | the notion of themes in user defined windows. One such platform is | |
799 | GTK+ where windows can have (very colourful) backgrounds defined by a | |
800 | user's selected theme. | |
801 | ||
802 | Dialogs, notebook pages and the status bar have this flag set to true | |
803 | by default so that the default look and feel is simulated best.", ""); | |
804 | ||
805 | DocDeclStr( | |
806 | virtual bool , GetThemeEnabled() const, | |
807 | "Return the themeEnabled flag.", ""); | |
808 | ||
809 | ||
810 | // TODO with directors | |
811 | // // controls by default inherit the colours of their parents, if a | |
812 | // // particular control class doesn't want to do it, it can override | |
813 | // // ShouldInheritColours() to return False | |
814 | // virtual bool ShouldInheritColours() const; | |
815 | ||
816 | ||
817 | ||
818 | ||
819 | ||
820 | // focus and keyboard handling | |
821 | // --------------------------- | |
822 | ||
823 | ||
824 | DocDeclStr( | |
825 | virtual void , SetFocus(), | |
826 | "Set's the focus to this window, allowing it to receive keyboard input.", ""); | |
827 | ||
828 | DocDeclStr( | |
829 | virtual void , SetFocusFromKbd(), | |
830 | "Set focus to this window as the result of a keyboard action. Normally | |
831 | only called internally.", ""); | |
832 | ||
833 | ||
834 | ||
835 | DocDeclStr( | |
836 | static wxWindow *, FindFocus(), | |
837 | "Returns the window or control that currently has the keyboard focus, | |
838 | or None.", ""); | |
839 | ||
840 | ||
841 | DocDeclStr( | |
842 | virtual bool , AcceptsFocus() const, | |
843 | "Can this window have focus?", ""); | |
844 | ||
845 | ||
846 | DocDeclStr( | |
847 | virtual bool , AcceptsFocusFromKeyboard() const, | |
848 | "Can this window be given focus by keyboard navigation? if not, the | |
849 | only way to give it focus (provided it accepts it at all) is to click | |
850 | it.", ""); | |
851 | ||
852 | ||
853 | ||
854 | ||
855 | DocDeclStr( | |
856 | virtual wxWindow *, GetDefaultItem() const, | |
857 | "Get the default child of this parent, i.e. the one which is activated | |
858 | by pressing <Enter> such as the OK button on a wx.Dialog.", ""); | |
859 | ||
860 | DocDeclStr( | |
861 | virtual wxWindow *, SetDefaultItem(wxWindow * child), | |
862 | "Set this child as default, return the old default.", ""); | |
863 | ||
864 | DocDeclStr( | |
865 | virtual void , SetTmpDefaultItem(wxWindow * win), | |
866 | "Set this child as temporary default", ""); | |
867 | ||
868 | ||
869 | DocDeclAStr( | |
870 | virtual bool , Navigate(int flags = wxNavigationKeyEvent::IsForward), | |
871 | "Navigate(self, int flags=NavigationKeyEvent.IsForward) -> bool", | |
872 | "Does keyboard navigation from this window to another, by sending a | |
873 | `wx.NavigationKeyEvent`.", " | |
874 | ||
875 | :param flags: A combination of the ``IsForward`` or ``IsBackward`` | |
876 | and the ``WinChange`` values in the `wx.NavigationKeyEvent` | |
877 | class, which determine if the navigation should be in forward | |
878 | or reverse order, and if it should be able to cross parent | |
879 | window boundaries, such as between notebook pages or MDI child | |
880 | frames. Typically the status of the Shift key (for forward or | |
881 | backward) or the Control key (for WinChange) would be used to | |
882 | determine how to set the flags. | |
883 | ||
884 | One situation in which you may wish to call this method is from a text | |
885 | control custom keypress handler to do the default navigation behaviour | |
886 | for the tab key, since the standard default behaviour for a multiline | |
887 | text control with the wx.TE_PROCESS_TAB style is to insert a tab and | |
888 | not navigate to the next control."); | |
889 | ||
890 | ||
891 | ||
892 | DocDeclStr( | |
893 | void , MoveAfterInTabOrder(wxWindow *win), | |
894 | "Moves this window in the tab navigation order after the specified | |
895 | sibling window. This means that when the user presses the TAB key on | |
896 | that other window, the focus switches to this window. | |
897 | ||
898 | The default tab order is the same as creation order. This function | |
899 | and `MoveBeforeInTabOrder` allow to change it after creating all the | |
900 | windows. | |
901 | ", ""); | |
902 | ||
903 | ||
904 | DocDeclStr( | |
905 | void , MoveBeforeInTabOrder(wxWindow *win), | |
906 | "Same as `MoveAfterInTabOrder` except that it inserts this window just | |
907 | before win instead of putting it right after it.", ""); | |
908 | ||
909 | ||
910 | ||
911 | ||
912 | ||
913 | ||
914 | ||
915 | ||
916 | // parent/children relations | |
917 | // ------------------------- | |
918 | ||
919 | ||
920 | //wxWindowList& GetChildren(); // TODO: Do a typemap or a wrapper for wxWindowList | |
921 | %extend { | |
922 | DocStr(GetChildren, | |
923 | "Returns a list of the window's children. NOTE: Currently this is a | |
924 | copy of the child window list maintained by the window, so the return | |
925 | value of this function is only valid as long as the window's children | |
926 | do not change.", ""); | |
927 | PyObject* GetChildren() { | |
928 | wxWindowList& list = self->GetChildren(); | |
929 | return wxPy_ConvertList(&list); | |
930 | } | |
931 | } | |
932 | ||
933 | DocDeclStr( | |
934 | wxWindow *, GetParent() const, | |
935 | "Returns the parent window of this window, or None if there isn't one.", ""); | |
936 | ||
937 | DocDeclStr( | |
938 | wxWindow *, GetGrandParent() const, | |
939 | "Returns the parent of the parent of this window, or None if there | |
940 | isn't one.", ""); | |
941 | ||
942 | ||
943 | ||
944 | DocDeclStr( | |
945 | virtual bool , IsTopLevel() const, | |
946 | "Returns true if the given window is a top-level one. Currently all | |
947 | frames and dialogs are always considered to be top-level windows (even | |
948 | if they have a parent window).", ""); | |
949 | ||
950 | ||
951 | // change the real parent of this window, return True if the parent | |
952 | // was changed, False otherwise (error or newParent == oldParent) | |
953 | DocDeclStr( | |
954 | virtual bool , Reparent( wxWindow *newParent ), | |
955 | "Reparents the window, i.e the window will be removed from its current | |
956 | parent window (e.g. a non-standard toolbar in a wxFrame) and then | |
957 | re-inserted into another. Available on Windows and GTK. Returns True | |
958 | if the parent was changed, False otherwise (error or newParent == | |
959 | oldParent)", ""); | |
960 | ||
961 | ||
962 | DocDeclStr( | |
963 | virtual void , AddChild( wxWindow *child ), | |
964 | "Adds a child window. This is called automatically by window creation | |
965 | functions so should not be required by the application programmer.", ""); | |
966 | ||
967 | DocDeclStr( | |
968 | virtual void , RemoveChild( wxWindow *child ), | |
969 | "Removes a child window. This is called automatically by window | |
970 | deletion functions so should not be required by the application | |
971 | programmer.", ""); | |
972 | ||
973 | ||
974 | ||
975 | ||
976 | // looking for windows | |
977 | // ------------------- | |
978 | ||
979 | DocDeclStrName( | |
980 | wxWindow *, FindWindow( long winid ), | |
981 | "Find a chld of this window by window ID", "", | |
982 | FindWindowById); | |
983 | ||
984 | DocDeclStrName( | |
985 | wxWindow *, FindWindow( const wxString& name ), | |
986 | "Find a child of this window by name", "", | |
987 | FindWindowByName); | |
988 | ||
989 | ||
990 | ||
991 | // event handler stuff | |
992 | // ------------------- | |
993 | ||
994 | DocDeclStr( | |
995 | wxEvtHandler *, GetEventHandler() const, | |
996 | "Returns the event handler for this window. By default, the window is | |
997 | its own event handler.", ""); | |
998 | ||
999 | ||
1000 | DocDeclStr( | |
1001 | void , SetEventHandler( wxEvtHandler *handler ), | |
1002 | "Sets the event handler for this window. An event handler is an object | |
1003 | that is capable of processing the events sent to a window. By default, | |
1004 | the window is its own event handler, but an application may wish to | |
1005 | substitute another, for example to allow central implementation of | |
1006 | event-handling for a variety of different window classes. | |
1007 | ||
1008 | It is usually better to use `wx.Window.PushEventHandler` since this sets | |
1009 | up a chain of event handlers, where an event not handled by one event | |
1010 | handler is handed to the next one in the chain.", ""); | |
1011 | ||
1012 | ||
1013 | DocDeclStr( | |
1014 | void , PushEventHandler( wxEvtHandler *handler ), | |
1015 | "Pushes this event handler onto the event handler stack for the window. | |
1016 | An event handler is an object that is capable of processing the events | |
1017 | sent to a window. By default, the window is its own event handler, but | |
1018 | an application may wish to substitute another, for example to allow | |
1019 | central implementation of event-handling for a variety of different | |
1020 | window classes. | |
1021 | ||
1022 | wx.Window.PushEventHandler allows an application to set up a chain of | |
1023 | event handlers, where an event not handled by one event handler is | |
1024 | handed to the next one in the chain. Use `wx.Window.PopEventHandler` to | |
1025 | remove the event handler.", ""); | |
1026 | ||
1027 | ||
1028 | DocDeclStr( | |
1029 | wxEvtHandler *, PopEventHandler( bool deleteHandler = false ), | |
1030 | "Removes and returns the top-most event handler on the event handler | |
1031 | stack. If deleteHandler is True then the wx.EvtHandler object will be | |
1032 | destroyed after it is popped.", ""); | |
1033 | ||
1034 | ||
1035 | DocDeclStr( | |
1036 | bool , RemoveEventHandler(wxEvtHandler *handler), | |
1037 | "Find the given handler in the event handler chain and remove (but not | |
1038 | delete) it from the event handler chain, return True if it was found | |
1039 | and False otherwise (this also results in an assert failure so this | |
1040 | function should only be called when the handler is supposed to be | |
1041 | there.)", ""); | |
1042 | ||
1043 | ||
1044 | ||
1045 | ||
1046 | // validators | |
1047 | // ---------- | |
1048 | ||
1049 | // a window may have an associated validator which is used to control | |
1050 | // user input | |
1051 | DocDeclStr( | |
1052 | virtual void , SetValidator( const wxValidator &validator ), | |
1053 | "Deletes the current validator (if any) and sets the window validator, | |
1054 | having called wx.Validator.Clone to create a new validator of this | |
1055 | type.", ""); | |
1056 | ||
1057 | DocDeclStr( | |
1058 | virtual wxValidator *, GetValidator(), | |
1059 | "Returns a pointer to the current validator for the window, or None if | |
1060 | there is none.", ""); | |
1061 | ||
1062 | ||
1063 | DocDeclStr( | |
1064 | virtual bool , Validate(), | |
1065 | "Validates the current values of the child controls using their | |
1066 | validators. If the window has wx.WS_EX_VALIDATE_RECURSIVELY extra | |
1067 | style flag set, the method will also call Validate() of all child | |
1068 | windows. Returns false if any of the validations failed.", ""); | |
1069 | ||
1070 | ||
1071 | DocDeclStr( | |
1072 | virtual bool , TransferDataToWindow(), | |
1073 | "Transfers values to child controls from data areas specified by their | |
1074 | validators. If the window has wx.WS_EX_VALIDATE_RECURSIVELY extra | |
1075 | style flag set, the method will also call TransferDataToWindow() of | |
1076 | all child windows.", ""); | |
1077 | ||
1078 | DocDeclStr( | |
1079 | virtual bool , TransferDataFromWindow(), | |
1080 | "Transfers values from child controls to data areas specified by their | |
1081 | validators. Returns false if a transfer failed. If the window has | |
1082 | wx.WS_EX_VALIDATE_RECURSIVELY extra style flag set, the method will | |
1083 | also call TransferDataFromWindow() of all child windows.", ""); | |
1084 | ||
1085 | ||
1086 | DocDeclStr( | |
1087 | virtual void , InitDialog(), | |
1088 | "Sends an EVT_INIT_DIALOG event, whose handler usually transfers data | |
1089 | to the dialog via validators.", ""); | |
1090 | ||
1091 | ||
1092 | ||
1093 | ||
1094 | // accelerators | |
1095 | // ------------ | |
1096 | ||
1097 | DocDeclStr( | |
1098 | virtual void , SetAcceleratorTable( const wxAcceleratorTable& accel ), | |
1099 | "Sets the accelerator table for this window.", ""); | |
1100 | ||
1101 | DocDeclStr( | |
1102 | wxAcceleratorTable *, GetAcceleratorTable(), | |
1103 | "Gets the accelerator table for this window.", ""); | |
1104 | ||
1105 | ||
1106 | ||
1107 | ||
1108 | ||
1109 | // hot keys (system wide accelerators) | |
1110 | // ----------------------------------- | |
1111 | %extend { | |
1112 | DocStr(RegisterHotKey, | |
1113 | "Registers a system wide hotkey. Every time the user presses the hotkey | |
1114 | registered here, this window will receive a hotkey event. It will | |
1115 | receive the event even if the application is in the background and | |
1116 | does not have the input focus because the user is working with some | |
1117 | other application. To bind an event handler function to this hotkey | |
1118 | use EVT_HOTKEY with an id equal to hotkeyId. Returns True if the | |
1119 | hotkey was registered successfully.", ""); | |
1120 | bool RegisterHotKey(int hotkeyId, int modifiers, int keycode) { | |
1121 | %#if wxUSE_HOTKEY | |
1122 | return self->RegisterHotKey(hotkeyId, modifiers, keycode); | |
1123 | %#else | |
1124 | return false; | |
1125 | %#endif | |
1126 | } | |
1127 | ||
1128 | ||
1129 | DocStr(UnregisterHotKey, | |
1130 | "Unregisters a system wide hotkey.", ""); | |
1131 | bool UnregisterHotKey(int hotkeyId) { | |
1132 | #if wxUSE_HOTKEY | |
1133 | return self->UnregisterHotKey(hotkeyId); | |
1134 | #else | |
1135 | return false; | |
1136 | #endif | |
1137 | } | |
1138 | } | |
1139 | ||
1140 | ||
1141 | ||
1142 | // "dialog units" translations | |
1143 | // --------------------------- | |
1144 | ||
1145 | DocStr(ConvertDialogToPixels, | |
1146 | "Converts a point or size from dialog units to pixels. Dialog units | |
1147 | are used for maintaining a dialog's proportions even if the font | |
1148 | changes. For the x dimension, the dialog units are multiplied by the | |
1149 | average character width and then divided by 4. For the y dimension, | |
1150 | the dialog units are multiplied by the average character height and | |
1151 | then divided by 8.", ""); | |
1152 | %Rename(ConvertDialogPointToPixels, wxPoint, ConvertDialogToPixels(const wxPoint& pt)); | |
1153 | %Rename(ConvertDialogSizeToPixels, wxSize, ConvertDialogToPixels(const wxSize& sz)); | |
1154 | %Rename(DLG_PNT, wxPoint, ConvertDialogToPixels(const wxPoint& pt)); | |
1155 | %Rename(DLG_SZE, wxSize, ConvertDialogToPixels(const wxSize& sz)); | |
1156 | ||
1157 | ||
1158 | DocStr(ConvertPixelPointToDialog, | |
1159 | "Converts a point or size from pixels to dialog units. Dialog units | |
1160 | are used for maintaining a dialog's proportions even if the font | |
1161 | changes. For the x dimension, the dialog units are multiplied by the | |
1162 | average character width and then divided by 4. For the y dimension, | |
1163 | the dialog units are multiplied by the average character height and | |
1164 | then divided by 8.", ""); | |
1165 | %Rename(ConvertPixelPointToDialog, wxPoint, ConvertPixelsToDialog(const wxPoint& pt)); | |
1166 | %Rename(ConvertPixelSizeToDialog, wxSize, ConvertPixelsToDialog(const wxSize& sz)); | |
1167 | ||
1168 | ||
1169 | ||
1170 | // mouse functions | |
1171 | // --------------- | |
1172 | ||
1173 | DocDeclStr( | |
1174 | virtual void , WarpPointer(int x, int y), | |
1175 | "Moves the pointer to the given position on the window. | |
1176 | ||
1177 | NOTE: This function is not supported under Mac because Apple Human | |
1178 | Interface Guidelines forbid moving the mouse cursor programmatically.", ""); | |
1179 | ||
1180 | ||
1181 | DocDeclStr( | |
1182 | void , CaptureMouse(), | |
1183 | "Directs all mouse input to this window. Call wx.Window.ReleaseMouse to | |
1184 | release the capture. | |
1185 | ||
1186 | Note that wxWindows maintains the stack of windows having captured the | |
1187 | mouse and when the mouse is released the capture returns to the window | |
1188 | which had had captured it previously and it is only really released if | |
1189 | there were no previous window. In particular, this means that you must | |
1190 | release the mouse as many times as you capture it.", ""); | |
1191 | ||
1192 | DocDeclStr( | |
1193 | void , ReleaseMouse(), | |
1194 | "Releases mouse input captured with wx.Window.CaptureMouse.", ""); | |
1195 | ||
1196 | ||
1197 | DocDeclStr( | |
1198 | static wxWindow *, GetCapture(), | |
1199 | "Returns the window which currently captures the mouse or None", ""); | |
1200 | ||
1201 | ||
1202 | DocDeclStr( | |
1203 | virtual bool , HasCapture() const, | |
1204 | "Returns true if this window has the current mouse capture.", ""); | |
1205 | ||
1206 | ||
1207 | ||
1208 | ||
1209 | ||
1210 | // painting the window | |
1211 | // ------------------- | |
1212 | ||
1213 | DocDeclStr( | |
1214 | virtual void , Refresh( bool eraseBackground = true, | |
1215 | const wxRect *rect = NULL ), | |
1216 | "Mark the specified rectangle (or the whole window) as \"dirty\" so it | |
1217 | will be repainted. Causes an EVT_PAINT event to be generated and sent | |
1218 | to the window.", ""); | |
1219 | ||
1220 | ||
1221 | DocDeclStr( | |
1222 | void , RefreshRect(const wxRect& rect, bool eraseBackground = true), | |
1223 | "Redraws the contents of the given rectangle: the area inside it will | |
1224 | be repainted. This is the same as Refresh but has a nicer syntax.", ""); | |
1225 | ||
1226 | ||
1227 | DocDeclStr( | |
1228 | virtual void , Update(), | |
1229 | "Calling this method immediately repaints the invalidated area of the | |
1230 | window instead of waiting for the EVT_PAINT event to happen, (normally | |
1231 | this would usually only happen when the flow of control returns to the | |
1232 | event loop.) Notice that this function doesn't refresh the window and | |
1233 | does nothing if the window has been already repainted. Use Refresh | |
1234 | first if you want to immediately redraw the window (or some portion of | |
1235 | it) unconditionally.", ""); | |
1236 | ||
1237 | ||
1238 | DocDeclStr( | |
1239 | virtual void , ClearBackground(), | |
1240 | "Clears the window by filling it with the current background | |
1241 | colour. Does not cause an erase background event to be generated.", ""); | |
1242 | ||
1243 | ||
1244 | ||
1245 | DocDeclStr( | |
1246 | virtual void , Freeze(), | |
1247 | "Freezes the window or, in other words, prevents any updates from | |
1248 | taking place on screen, the window is not redrawn at all. Thaw must be | |
1249 | called to reenable window redrawing. Calls to Freeze/Thaw may be | |
1250 | nested, with the actual Thaw being delayed until all the nesting has | |
1251 | been undone. | |
1252 | ||
1253 | This method is useful for visual appearance optimization (for example, | |
1254 | it is a good idea to use it before inserting large amount of text into | |
1255 | a wxTextCtrl under wxGTK) but is not implemented on all platforms nor | |
1256 | for all controls so it is mostly just a hint to wxWindows and not a | |
1257 | mandatory directive.", ""); | |
1258 | ||
1259 | ||
1260 | DocDeclStr( | |
1261 | virtual void , Thaw(), | |
1262 | "Reenables window updating after a previous call to Freeze. Calls to | |
1263 | Freeze/Thaw may be nested, so Thaw must be called the same number of | |
1264 | times that Freeze was before the window will be updated.", ""); | |
1265 | ||
1266 | ||
1267 | DocDeclStr( | |
1268 | virtual void , PrepareDC( wxDC & dc ), | |
1269 | "Call this function to prepare the device context for drawing a | |
1270 | scrolled image. It sets the device origin according to the current | |
1271 | scroll position.", ""); | |
1272 | ||
1273 | ||
1274 | DocDeclStr( | |
1275 | wxRegion& , GetUpdateRegion(), | |
1276 | "Returns the region specifying which parts of the window have been | |
1277 | damaged. Should only be called within an EVT_PAINT handler.", ""); | |
1278 | ||
1279 | ||
1280 | DocDeclStr( | |
1281 | wxRect , GetUpdateClientRect() const, | |
1282 | "Get the update rectangle region bounding box in client coords.", ""); | |
1283 | ||
1284 | ||
1285 | DocStr(IsExposed, | |
1286 | "Returns true if the given point or rectangle area has been exposed | |
1287 | since the last repaint. Call this in an paint event handler to | |
1288 | optimize redrawing by only redrawing those areas, which have been | |
1289 | exposed.", ""); | |
1290 | bool IsExposed( int x, int y, int w=1, int h=1 ) const; | |
1291 | %Rename(IsExposedPoint, bool, IsExposed( const wxPoint& pt ) const); | |
1292 | %Rename(IsExposedRect, bool, IsExposed( const wxRect& rect ) const); | |
1293 | ||
1294 | ||
1295 | ||
1296 | // colours, fonts and cursors | |
1297 | // -------------------------- | |
1298 | ||
1299 | ||
1300 | DocDeclStr( | |
1301 | virtual wxVisualAttributes , GetDefaultAttributes() const, | |
1302 | "Get the default attributes for an instance of this class. This is | |
1303 | useful if you want to use the same font or colour in your own control | |
1304 | as in a standard control -- which is a much better idea than hard | |
1305 | coding specific colours or fonts which might look completely out of | |
1306 | place on the user's system, especially if it uses themes.", ""); | |
1307 | ||
1308 | ||
1309 | DocDeclStr( | |
1310 | static wxVisualAttributes , | |
1311 | GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL), | |
1312 | "Get the default attributes for this class. This is useful if you want | |
1313 | to use the same font or colour in your own control as in a standard | |
1314 | control -- which is a much better idea than hard coding specific | |
1315 | colours or fonts which might look completely out of place on the | |
1316 | user's system, especially if it uses themes. | |
1317 | ||
1318 | The variant parameter is only relevant under Mac currently and is | |
1319 | ignore under other platforms. Under Mac, it will change the size of | |
1320 | the returned font. See `wx.Window.SetWindowVariant` for more about | |
1321 | this.", ""); | |
1322 | ||
1323 | ||
1324 | DocDeclStr( | |
1325 | virtual bool , SetBackgroundColour( const wxColour &colour ), | |
1326 | "Sets the background colour of the window. Returns True if the colour | |
1327 | was changed. The background colour is usually painted by the default | |
1328 | EVT_ERASE_BACKGROUND event handler function under Windows and | |
1329 | automatically under GTK. Using `wx.NullColour` will reset the window | |
1330 | to the default background colour. | |
1331 | ||
1332 | Note that setting the background colour may not cause an immediate | |
1333 | refresh, so you may wish to call `ClearBackground` or `Refresh` after | |
1334 | calling this function. | |
1335 | ||
1336 | Using this function will disable attempts to use themes for this | |
1337 | window, if the system supports them. Use with care since usually the | |
1338 | themes represent the appearance chosen by the user to be used for all | |
1339 | applications on the system.", ""); | |
1340 | ||
1341 | DocDeclStr( | |
1342 | void , SetOwnBackgroundColour(const wxColour& colour), | |
1343 | "", ""); | |
1344 | ||
1345 | ||
1346 | ||
1347 | DocDeclStr( | |
1348 | virtual bool , SetForegroundColour( const wxColour &colour ), | |
1349 | "Sets the foreground colour of the window. Returns True is the colour | |
1350 | was changed. The interpretation of foreground colour is dependent on | |
1351 | the window class; it may be the text colour or other colour, or it may | |
1352 | not be used at all.", ""); | |
1353 | ||
1354 | DocDeclStr( | |
1355 | void , SetOwnForegroundColour(const wxColour& colour), | |
1356 | "", ""); | |
1357 | ||
1358 | ||
1359 | ||
1360 | DocDeclStr( | |
1361 | wxColour , GetBackgroundColour() const, | |
1362 | "Returns the background colour of the window.", ""); | |
1363 | ||
1364 | DocDeclStr( | |
1365 | wxColour , GetForegroundColour() const, | |
1366 | "Returns the foreground colour of the window. The interpretation of | |
1367 | foreground colour is dependent on the window class; it may be the text | |
1368 | colour or other colour, or it may not be used at all.", ""); | |
1369 | ||
1370 | DocDeclStr( | |
1371 | bool , InheritsBackgroundColour() const, | |
1372 | "", ""); | |
1373 | ||
1374 | DocDeclStr( | |
1375 | bool , UseBgCol() const, | |
1376 | "", ""); | |
1377 | ||
1378 | ||
1379 | // TODO: | |
1380 | // // if the window shouldn't inherit its colour from the parent, override | |
1381 | // // this function to return true | |
1382 | // // | |
1383 | // // this is currently only used by wxMSW and wxUniv but should be useful for | |
1384 | // // the other ports too | |
1385 | // virtual bool ProvidesBackground() const; | |
1386 | ||
1387 | ||
1388 | // Set/get the background style. | |
1389 | // Pass one of wxBG_STYLE_SYSTEM, wxBG_STYLE_COLOUR, wxBG_STYLE_CUSTOM | |
1390 | DocDeclStr( | |
1391 | virtual bool , SetBackgroundStyle(wxBackgroundStyle style), | |
1392 | "Returns the background style of the window. The background style | |
1393 | indicates how the background of the window is drawn. | |
1394 | ||
1395 | ====================== ======================================== | |
1396 | wx.BG_STYLE_SYSTEM The background colour or pattern should | |
1397 | be determined by the system | |
1398 | wx.BG_STYLE_COLOUR The background should be a solid colour | |
1399 | wx.BG_STYLE_CUSTOM The background will be implemented by the | |
1400 | application. | |
1401 | ====================== ======================================== | |
1402 | ||
1403 | On GTK+, use of wx.BG_STYLE_CUSTOM allows the flicker-free drawing of | |
1404 | a custom background, such as a tiled bitmap. Currently the style has | |
1405 | no effect on other platforms. | |
1406 | ||
1407 | :see: `GetBackgroundStyle`, `SetBackgroundColour`", ""); | |
1408 | ||
1409 | DocDeclStr( | |
1410 | virtual wxBackgroundStyle , GetBackgroundStyle() const, | |
1411 | "Returns the background style of the window. | |
1412 | ||
1413 | :see: `SetBackgroundStyle`", ""); | |
1414 | ||
1415 | ||
1416 | DocDeclStr( | |
1417 | bool , HasTransparentBackground(), | |
1418 | "Returns True if this window's background is transparent (as, for | |
1419 | example, for `wx.StaticText`) and should show the parent window's | |
1420 | background. | |
1421 | ||
1422 | This method is mostly used internally by the library itself and you | |
1423 | normally shouldn't have to call it. You may, however, have to override | |
1424 | it in your custom control classes to ensure that background is painted | |
1425 | correctly.", ""); | |
1426 | ||
1427 | ||
1428 | DocDeclStr( | |
1429 | virtual bool , SetCursor( const wxCursor &cursor ), | |
1430 | "Sets the window's cursor. Notice that the window cursor also sets it | |
1431 | for the children of the window implicitly. | |
1432 | ||
1433 | The cursor may be wx.NullCursor in which case the window cursor will | |
1434 | be reset back to default.", ""); | |
1435 | ||
1436 | DocDeclStr( | |
1437 | wxCursor , GetCursor(), | |
1438 | "Return the cursor associated with this window.", ""); | |
1439 | ||
1440 | ||
1441 | ||
1442 | DocDeclStr( | |
1443 | virtual bool , SetFont( const wxFont &font ), | |
1444 | "Sets the font for this window.", ""); | |
1445 | ||
1446 | DocDeclStr( | |
1447 | void , SetOwnFont(const wxFont& font), | |
1448 | "", ""); | |
1449 | ||
1450 | ||
1451 | ||
1452 | DocDeclStr( | |
1453 | wxFont , GetFont(), | |
1454 | "Returns the default font used for this window.", ""); | |
1455 | ||
1456 | ||
1457 | ||
1458 | DocDeclStr( | |
1459 | void , SetCaret(wxCaret *caret), | |
1460 | "Sets the caret associated with the window.", ""); | |
1461 | ||
1462 | DocDeclStr( | |
1463 | wxCaret *, GetCaret() const, | |
1464 | "Returns the caret associated with the window.", ""); | |
1465 | ||
1466 | ||
1467 | ||
1468 | DocDeclStr( | |
1469 | virtual int , GetCharHeight() const, | |
1470 | "Get the (average) character size for the current font.", ""); | |
1471 | ||
1472 | DocDeclStr( | |
1473 | virtual int , GetCharWidth() const, | |
1474 | "Get the (average) character size for the current font.", ""); | |
1475 | ||
1476 | ||
1477 | ||
1478 | DocDeclAStr( | |
1479 | void, GetTextExtent(const wxString& string, int *OUTPUT, int *OUTPUT), | |
1480 | "GetTextExtent(String string) -> (width, height)", | |
1481 | "Get the width and height of the text using the current font.", ""); | |
1482 | DocDeclAStrName( | |
1483 | void, GetTextExtent(const wxString& string, | |
1484 | int *OUTPUT, int *OUTPUT, int *OUTPUT, int* OUTPUT, | |
1485 | const wxFont* font = NULL), | |
1486 | "GetFullTextExtent(String string, Font font=None) ->\n (width, height, descent, externalLeading)", | |
1487 | "Get the width, height, decent and leading of the text using the | |
1488 | current or specified font.", "", | |
1489 | GetFullTextExtent); | |
1490 | ||
1491 | ||
1492 | ||
1493 | // client <-> screen coords | |
1494 | // ------------------------ | |
1495 | ||
1496 | %apply int * INOUT { int* x, int* y }; | |
1497 | ||
1498 | // translate to/from screen/client coordinates | |
1499 | DocDeclAStrName( | |
1500 | void , ClientToScreen( int *x, int *y ) const, | |
1501 | "ClientToScreenXY(int x, int y) -> (x,y)", | |
1502 | "Converts to screen coordinates from coordinates relative to this window.", "", | |
1503 | ClientToScreenXY); | |
1504 | ||
1505 | DocDeclAStrName( | |
1506 | void , ScreenToClient( int *x, int *y ) const, | |
1507 | "ScreenToClientXY(int x, int y) -> (x,y)", | |
1508 | "Converts from screen to client window coordinates.", "", | |
1509 | ScreenToClientXY); | |
1510 | ||
1511 | ||
1512 | DocDeclStr( | |
1513 | wxPoint , ClientToScreen(const wxPoint& pt) const, | |
1514 | "Converts to screen coordinates from coordinates relative to this window.", ""); | |
1515 | ||
1516 | DocDeclStr( | |
1517 | wxPoint , ScreenToClient(const wxPoint& pt) const, | |
1518 | "Converts from screen to client window coordinates.", ""); | |
1519 | ||
1520 | ||
1521 | ||
1522 | DocDeclStrName( | |
1523 | wxHitTest , HitTest(wxCoord x, wxCoord y) const, | |
1524 | "Test where the given (in client coords) point lies", "", | |
1525 | HitTestXY); | |
1526 | ||
1527 | DocDeclStr( | |
1528 | wxHitTest , HitTest(const wxPoint& pt) const, | |
1529 | "Test where the given (in client coords) point lies", ""); | |
1530 | ||
1531 | ||
1532 | ||
1533 | ||
1534 | // misc | |
1535 | // ---- | |
1536 | ||
1537 | %nokwargs GetBorder; | |
1538 | DocDeclStr( | |
1539 | wxBorder , GetBorder(long flags) const, | |
1540 | "Get the window border style from the given flags: this is different | |
1541 | from simply doing flags & wxBORDER_MASK because it uses | |
1542 | GetDefaultBorder() to translate wxBORDER_DEFAULT to something | |
1543 | reasonable. | |
1544 | ", ""); | |
1545 | ||
1546 | DocDeclStr( | |
1547 | wxBorder , GetBorder() const, | |
1548 | "Get border for the flags of this window", ""); | |
1549 | ||
1550 | ||
1551 | ||
1552 | ||
1553 | DocDeclStr( | |
1554 | virtual void , UpdateWindowUI(long flags = wxUPDATE_UI_NONE), | |
1555 | "This function sends EVT_UPDATE_UI events to the window. The particular | |
1556 | implementation depends on the window; for example a wx.ToolBar will | |
1557 | send an update UI event for each toolbar button, and a wx.Frame will | |
1558 | send an update UI event for each menubar menu item. You can call this | |
1559 | function from your application to ensure that your UI is up-to-date at | |
1560 | a particular point in time (as far as your EVT_UPDATE_UI handlers are | |
1561 | concerned). This may be necessary if you have called | |
1562 | `wx.UpdateUIEvent.SetMode` or `wx.UpdateUIEvent.SetUpdateInterval` to | |
1563 | limit the overhead that wxWindows incurs by sending update UI events | |
1564 | in idle time.", | |
1565 | " | |
1566 | The flags should be a bitlist of one or more of the following values: | |
1567 | ||
1568 | ===================== ============================== | |
1569 | wx.UPDATE_UI_NONE No particular value | |
1570 | wx.UPDATE_UI_RECURSE Call the function for descendants | |
1571 | wx.UPDATE_UI_FROMIDLE Invoked from OnIdle | |
1572 | ===================== ============================== | |
1573 | ||
1574 | If you are calling this function from an OnIdle function, make sure | |
1575 | you pass the wx.UPDATE_UI_FROMIDLE flag, since this tells the window | |
1576 | to only update the UI elements that need to be updated in idle | |
1577 | time. Some windows update their elements only when necessary, for | |
1578 | example when a menu is about to be shown. The following is an example | |
1579 | of how to call UpdateWindowUI from an idle function:: | |
1580 | ||
1581 | def OnIdle(self, evt): | |
1582 | if wx.UpdateUIEvent.CanUpdate(self): | |
1583 | self.UpdateWindowUI(wx.UPDATE_UI_FROMIDLE); | |
1584 | "); | |
1585 | ||
1586 | ||
1587 | // TODO: using directors? | |
1588 | // // do the window-specific processing after processing the update event | |
1589 | // virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) ; | |
1590 | ||
1591 | ||
1592 | DocStr(PopupMenu, | |
1593 | "Pops up the given menu at the specified coordinates, relative to this window, | |
1594 | and returns control when the user has dismissed the menu. If a menu item is | |
1595 | selected, the corresponding menu event is generated and will be processed as | |
1596 | usual. If the default position is given then the current position of the | |
1597 | mouse cursor will be used.", ""); | |
1598 | %Rename(PopupMenuXY, bool, PopupMenu(wxMenu *menu, int x=-1, int y=-1)); | |
1599 | bool PopupMenu(wxMenu *menu, const wxPoint& pos=wxDefaultPosition); | |
1600 | ||
1601 | ||
1602 | ||
1603 | ||
1604 | %extend { | |
1605 | DocStr(GetHandle, | |
1606 | "Returns the platform-specific handle (as a long integer) of the | |
1607 | physical window. Currently on wxMac it returns the handle of the | |
1608 | toplevel parent of the window.", ""); | |
1609 | long GetHandle() { | |
1610 | return wxPyGetWinHandle(self); | |
1611 | } | |
1612 | } | |
1613 | ||
1614 | DocStr( | |
1615 | AssociateHandle, | |
1616 | "Associate the window with a new native handle", ""); | |
1617 | %extend { | |
1618 | void AssociateHandle(long handle) { | |
1619 | self->AssociateHandle((WXWidget)handle); | |
1620 | } | |
1621 | } | |
1622 | ||
1623 | ||
1624 | DocDeclStr( | |
1625 | virtual void , DissociateHandle(), | |
1626 | "Dissociate the current native handle from the window", ""); | |
1627 | ||
1628 | ||
1629 | ||
1630 | #ifdef __WXMSW__ | |
1631 | // A way to do the native draw first... Too bad it isn't in wxGTK too. | |
1632 | void OnPaint(wxPaintEvent& event); | |
1633 | #endif | |
1634 | ||
1635 | ||
1636 | ||
1637 | // scrollbars | |
1638 | // ---------- | |
1639 | ||
1640 | ||
1641 | DocDeclStr( | |
1642 | bool , HasScrollbar(int orient) const, | |
1643 | "Does the window have the scrollbar for this orientation?", ""); | |
1644 | ||
1645 | ||
1646 | // configure the window scrollbars | |
1647 | DocDeclStr( | |
1648 | virtual void , SetScrollbar( int orientation, | |
1649 | int position, | |
1650 | int thumbSize, | |
1651 | int range, | |
1652 | bool refresh = true ), | |
1653 | "Sets the scrollbar properties of a built-in scrollbar.", | |
1654 | " | |
1655 | :param orientation: Determines the scrollbar whose page size is to | |
1656 | be set. May be wx.HORIZONTAL or wx.VERTICAL. | |
1657 | ||
1658 | :param position: The position of the scrollbar in scroll units. | |
1659 | ||
1660 | :param thumbSize: The size of the thumb, or visible portion of the | |
1661 | scrollbar, in scroll units. | |
1662 | ||
1663 | :param range: The maximum position of the scrollbar. | |
1664 | ||
1665 | :param refresh: True to redraw the scrollbar, false otherwise. | |
1666 | "); | |
1667 | ||
1668 | DocDeclStr( | |
1669 | virtual void , SetScrollPos( int orientation, int pos, bool refresh = true ), | |
1670 | "Sets the position of one of the built-in scrollbars.", ""); | |
1671 | ||
1672 | DocDeclStr( | |
1673 | virtual int , GetScrollPos( int orientation ) const, | |
1674 | "Returns the built-in scrollbar position.", ""); | |
1675 | ||
1676 | DocDeclStr( | |
1677 | virtual int , GetScrollThumb( int orientation ) const, | |
1678 | "Returns the built-in scrollbar thumb size.", ""); | |
1679 | ||
1680 | DocDeclStr( | |
1681 | virtual int , GetScrollRange( int orientation ) const, | |
1682 | "Returns the built-in scrollbar range.", ""); | |
1683 | ||
1684 | ||
1685 | ||
1686 | ||
1687 | DocDeclStr( | |
1688 | virtual void , ScrollWindow( int dx, int dy, | |
1689 | const wxRect* rect = NULL ), | |
1690 | "Physically scrolls the pixels in the window and move child windows | |
1691 | accordingly. Use this function to optimise your scrolling | |
1692 | implementations, to minimise the area that must be redrawn. Note that | |
1693 | it is rarely required to call this function from a user program."," | |
1694 | ||
1695 | :param dx: Amount to scroll horizontally. | |
1696 | ||
1697 | :param dy: Amount to scroll vertically. | |
1698 | ||
1699 | :param rect: Rectangle to invalidate. If this is None, the whole | |
1700 | window is invalidated. If you pass a rectangle corresponding | |
1701 | to the area of the window exposed by the scroll, your | |
1702 | painting handler can optimize painting by checking for the | |
1703 | invalidated region."); | |
1704 | ||
1705 | ||
1706 | DocDeclStr( | |
1707 | virtual bool , ScrollLines(int lines), | |
1708 | "If the platform and window class supports it, scrolls the window by | |
1709 | the given number of lines down, if lines is positive, or up if lines | |
1710 | is negative. Returns True if the window was scrolled, False if it was | |
1711 | already on top/bottom and nothing was done.", ""); | |
1712 | ||
1713 | DocDeclStr( | |
1714 | virtual bool , ScrollPages(int pages), | |
1715 | "If the platform and window class supports it, scrolls the window by | |
1716 | the given number of pages down, if pages is positive, or up if pages | |
1717 | is negative. Returns True if the window was scrolled, False if it was | |
1718 | already on top/bottom and nothing was done.", ""); | |
1719 | ||
1720 | ||
1721 | DocDeclStr( | |
1722 | bool , LineUp(), | |
1723 | "This is just a wrapper for ScrollLines(-1).", ""); | |
1724 | ||
1725 | DocDeclStr( | |
1726 | bool , LineDown(), | |
1727 | "This is just a wrapper for ScrollLines(1).", ""); | |
1728 | ||
1729 | DocDeclStr( | |
1730 | bool , PageUp(), | |
1731 | "This is just a wrapper for ScrollPages(-1).", ""); | |
1732 | ||
1733 | DocDeclStr( | |
1734 | bool , PageDown(), | |
1735 | "This is just a wrapper for ScrollPages(1).", ""); | |
1736 | ||
1737 | ||
1738 | ||
1739 | ||
1740 | // context-sensitive help | |
1741 | // ---------------------- | |
1742 | ||
1743 | DocDeclStr( | |
1744 | void , SetHelpText(const wxString& text), | |
1745 | "Sets the help text to be used as context-sensitive help for this | |
1746 | window. Note that the text is actually stored by the current | |
1747 | wxHelpProvider implementation, and not in the window object itself.", ""); | |
1748 | ||
1749 | ||
1750 | DocDeclStr( | |
1751 | void , SetHelpTextForId(const wxString& text), | |
1752 | "Associate this help text with all windows with the same id as this | |
1753 | one.", ""); | |
1754 | ||
1755 | ||
1756 | DocDeclStr( | |
1757 | wxString , GetHelpText() const, | |
1758 | "Gets the help text to be used as context-sensitive help for this | |
1759 | window. Note that the text is actually stored by the current | |
1760 | wxHelpProvider implementation, and not in the window object itself.", ""); | |
1761 | ||
1762 | ||
1763 | ||
1764 | #ifndef __WXX11__ | |
1765 | // tooltips | |
1766 | // -------- | |
1767 | ||
1768 | DocStr(SetToolTip, | |
1769 | "Attach a tooltip to the window.", ""); | |
1770 | %Rename(SetToolTipString, void, SetToolTip( const wxString &tip )); | |
1771 | void SetToolTip( wxToolTip *tip ); | |
1772 | ||
1773 | DocDeclStr( | |
1774 | wxToolTip* , GetToolTip() const, | |
1775 | "get the associated tooltip or None if none", ""); | |
1776 | ||
1777 | // LINK ERROR --> wxString GetToolTipText() const; | |
1778 | #endif | |
1779 | ||
1780 | ||
1781 | ||
1782 | #ifndef __WXX11__ | |
1783 | // drag and drop | |
1784 | // ------------- | |
1785 | ||
1786 | // set/retrieve the drop target associated with this window (may be | |
1787 | // NULL; it's owned by the window and will be deleted by it) | |
1788 | %apply SWIGTYPE *DISOWN { wxPyDropTarget *dropTarget }; | |
1789 | ||
1790 | DocDeclStr( | |
1791 | virtual void , SetDropTarget( wxPyDropTarget *dropTarget ), | |
1792 | "Associates a drop target with this window. If the window already has | |
1793 | a drop target, it is deleted.", ""); | |
1794 | ||
1795 | %clear wxPyDropTarget *dropTarget; | |
1796 | ||
1797 | ||
1798 | DocDeclStr( | |
1799 | virtual wxPyDropTarget *, GetDropTarget() const, | |
1800 | "Returns the associated drop target, which may be None.", ""); | |
1801 | ||
1802 | ||
1803 | DocStr(DragAcceptFiles, | |
1804 | "Enables or disables eligibility for drop file events, EVT_DROP_FILES. | |
1805 | Only functional on Windows.", ""); | |
1806 | #ifdef __WXMSW__ | |
1807 | void DragAcceptFiles(bool accept); | |
1808 | #else | |
1809 | %extend { | |
1810 | void DragAcceptFiles(bool accept) {} | |
1811 | } | |
1812 | #endif | |
1813 | #endif | |
1814 | ||
1815 | ||
1816 | // constraints and sizers | |
1817 | // ---------------------- | |
1818 | ||
1819 | // set the constraints for this window or retrieve them (may be NULL) | |
1820 | DocDeclStr( | |
1821 | void , SetConstraints( wxLayoutConstraints *constraints ), | |
1822 | "Sets the window to have the given layout constraints. If an existing | |
1823 | layout constraints object is already owned by the window, it will be | |
1824 | deleted. Pass None to disassociate and delete the window's current | |
1825 | constraints. | |
1826 | ||
1827 | You must call SetAutoLayout to tell a window to use the constraints | |
1828 | automatically in its default EVT_SIZE handler; otherwise, you must | |
1829 | handle EVT_SIZE yourself and call Layout() explicitly. When setting | |
1830 | both a wx.LayoutConstraints and a wx.Sizer, only the sizer will have | |
1831 | effect.", ""); | |
1832 | ||
1833 | DocDeclStr( | |
1834 | wxLayoutConstraints *, GetConstraints() const, | |
1835 | "Returns a pointer to the window's layout constraints, or None if there | |
1836 | are none.", ""); | |
1837 | ||
1838 | ||
1839 | DocDeclStr( | |
1840 | void , SetAutoLayout( bool autoLayout ), | |
1841 | "Determines whether the Layout function will be called automatically | |
1842 | when the window is resized. It is called implicitly by SetSizer but | |
1843 | if you use SetConstraints you should call it manually or otherwise the | |
1844 | window layout won't be correctly updated when its size changes.", ""); | |
1845 | ||
1846 | DocDeclStr( | |
1847 | bool , GetAutoLayout() const, | |
1848 | "Returns the current autoLayout setting", ""); | |
1849 | ||
1850 | ||
1851 | DocDeclStr( | |
1852 | virtual bool , Layout(), | |
1853 | "Invokes the constraint-based layout algorithm or the sizer-based | |
1854 | algorithm for this window. See SetAutoLayout: when auto layout is on, | |
1855 | this function gets called automatically by the default EVT_SIZE | |
1856 | handler when the window is resized.", ""); | |
1857 | ||
1858 | ||
1859 | DocDeclStr( | |
1860 | void , SetSizer(wxSizer *sizer, bool deleteOld = true ), | |
1861 | "Sets the window to have the given layout sizer. The window will then | |
1862 | own the object, and will take care of its deletion. If an existing | |
1863 | layout sizer object is already owned by the window, it will be deleted | |
1864 | if the deleteOld parameter is true. Note that this function will also | |
1865 | call SetAutoLayout implicitly with a True parameter if the sizer is | |
1866 | non-None, and False otherwise.", ""); | |
1867 | ||
1868 | DocDeclStr( | |
1869 | void , SetSizerAndFit( wxSizer *sizer, bool deleteOld = true ), | |
1870 | "The same as SetSizer, except it also sets the size hints for the | |
1871 | window based on the sizer's minimum size.", ""); | |
1872 | ||
1873 | ||
1874 | DocDeclStr( | |
1875 | wxSizer *, GetSizer() const, | |
1876 | "Return the sizer associated with the window by a previous call to | |
1877 | SetSizer or None if there isn't one.", ""); | |
1878 | ||
1879 | ||
1880 | // Track if this window is a member of a sizer | |
1881 | DocDeclStr( | |
1882 | void , SetContainingSizer(wxSizer* sizer), | |
1883 | "This normally does not need to be called by application code. It is | |
1884 | called internally when a window is added to a sizer, and is used so | |
1885 | the window can remove itself from the sizer when it is destroyed.", ""); | |
1886 | ||
1887 | DocDeclStr( | |
1888 | wxSizer *, GetContainingSizer() const, | |
1889 | "Return the sizer that this window is a member of, if any, otherwise None.", ""); | |
1890 | ||
1891 | ||
1892 | ||
1893 | ||
1894 | // accessibility | |
1895 | // ---------------------- | |
1896 | #if wxUSE_ACCESSIBILITY | |
1897 | // Override to create a specific accessible object. | |
1898 | virtual wxAccessible* CreateAccessible(); | |
1899 | ||
1900 | // Sets the accessible object. | |
1901 | void SetAccessible(wxAccessible* accessible) ; | |
1902 | ||
1903 | // Returns the accessible object. | |
1904 | wxAccessible* GetAccessible() { return m_accessible; }; | |
1905 | ||
1906 | // Returns the accessible object, creating if necessary. | |
1907 | wxAccessible* GetOrCreateAccessible() ; | |
1908 | #endif | |
1909 | ||
1910 | ||
1911 | ||
1912 | ||
1913 | DocDeclStr( | |
1914 | virtual void , InheritAttributes(), | |
1915 | "This function is (or should be, in case of custom controls) called | |
1916 | during window creation to intelligently set up the window visual | |
1917 | attributes, that is the font and the foreground and background | |
1918 | colours. | |
1919 | ||
1920 | By 'intelligently' the following is meant: by default, all windows use | |
1921 | their own default attributes. However if some of the parent's | |
1922 | attributes are explicitly changed (that is, using SetFont and not | |
1923 | SetOwnFont) and if the corresponding attribute hadn't been | |
1924 | explicitly set for this window itself, then this window takes the same | |
1925 | value as used by the parent. In addition, if the window overrides | |
1926 | ShouldInheritColours to return false, the colours will not be changed | |
1927 | no matter what and only the font might. | |
1928 | ||
1929 | This rather complicated logic is necessary in order to accommodate the | |
1930 | different usage scenarios. The most common one is when all default | |
1931 | attributes are used and in this case, nothing should be inherited as | |
1932 | in modern GUIs different controls use different fonts (and colours) | |
1933 | than their siblings so they can't inherit the same value from the | |
1934 | parent. However it was also deemed desirable to allow to simply change | |
1935 | the attributes of all children at once by just changing the font or | |
1936 | colour of their common parent, hence in this case we do inherit the | |
1937 | parents attributes. | |
1938 | ", ""); | |
1939 | ||
1940 | ||
1941 | // TODO: Virtualize this with directors | |
1942 | DocDeclStr( | |
1943 | virtual bool , ShouldInheritColours() const, | |
1944 | "Return true from here to allow the colours of this window to be | |
1945 | changed by InheritAttributes, returning false forbids inheriting them | |
1946 | from the parent window. | |
1947 | ||
1948 | The base class version returns false, but this method is overridden in | |
1949 | wxControl where it returns true.", ""); | |
1950 | ||
1951 | ||
1952 | ||
1953 | %pythoncode { | |
1954 | def PostCreate(self, pre): | |
1955 | """ | |
1956 | Phase 3 of the 2-phase create <wink!> | |
1957 | Call this method after precreating the window with the 2-phase create method. | |
1958 | """ | |
1959 | self.this = pre.this | |
1960 | self.thisown = pre.thisown | |
1961 | pre.thisown = 0 | |
1962 | if hasattr(self, '_setOORInfo'): | |
1963 | self._setOORInfo(self) | |
1964 | if hasattr(self, '_setCallbackInfo'): | |
1965 | self._setCallbackInfo(self, self.__class__) | |
1966 | } | |
1967 | }; | |
1968 | ||
1969 | ||
1970 | ||
1971 | ||
1972 | ||
1973 | ||
1974 | ||
1975 | ||
1976 | %pythoncode { | |
1977 | def DLG_PNT(win, point_or_x, y=None): | |
1978 | """ | |
1979 | Convenience function for converting a Point or (x,y) in | |
1980 | dialog units to pixel units. | |
1981 | """ | |
1982 | if y is None: | |
1983 | return win.ConvertDialogPointToPixels(point_or_x) | |
1984 | else: | |
1985 | return win.ConvertDialogPointToPixels(wx.Point(point_or_x, y)) | |
1986 | ||
1987 | def DLG_SZE(win, size_width, height=None): | |
1988 | """ | |
1989 | Convenience function for converting a Size or (w,h) in | |
1990 | dialog units to pixel units. | |
1991 | """ | |
1992 | if height is None: | |
1993 | return win.ConvertDialogSizeToPixels(size_width) | |
1994 | else: | |
1995 | return win.ConvertDialogSizeToPixels(wx.Size(size_width, height)) | |
1996 | } | |
1997 | ||
1998 | ||
1999 | ||
2000 | ||
2001 | // Unfortunatly the names of these new static methods clash with the | |
2002 | // names wxPython has been using forever for the overloaded | |
2003 | // wxWindow::FindWindow, so instead of swigging them as statics create | |
2004 | // standalone functions for them. | |
2005 | ||
2006 | ||
2007 | DocStr(wxFindWindowById, | |
2008 | "Find the first window in the application with the given id. If parent | |
2009 | is None, the search will start from all top-level frames and dialog | |
2010 | boxes; if non-None, the search will be limited to the given window | |
2011 | hierarchy. The search is recursive in both cases.", ""); | |
2012 | ||
2013 | DocStr(wxFindWindowByName, | |
2014 | "Find a window by its name (as given in a window constructor or Create | |
2015 | function call). If parent is None, the search will start from all | |
2016 | top-level frames and dialog boxes; if non-None, the search will be | |
2017 | limited to the given window hierarchy. The search is recursive in both | |
2018 | cases. | |
2019 | ||
2020 | If no window with such name is found, wx.FindWindowByLabel is called.", ""); | |
2021 | ||
2022 | DocStr(wxFindWindowByLabel, | |
2023 | "Find a window by its label. Depending on the type of window, the label | |
2024 | may be a window title or panel item label. If parent is None, the | |
2025 | search will start from all top-level frames and dialog boxes; if | |
2026 | non-None, the search will be limited to the given window | |
2027 | hierarchy. The search is recursive in both cases.", ""); | |
2028 | ||
2029 | ||
2030 | MustHaveApp(wxFindWindowById); | |
2031 | MustHaveApp(wxFindWindowByName); | |
2032 | MustHaveApp(wxFindWindowByLabel); | |
2033 | ||
2034 | %inline %{ | |
2035 | wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) { | |
2036 | return wxWindow::FindWindowById(id, parent); | |
2037 | } | |
2038 | ||
2039 | wxWindow* wxFindWindowByName( const wxString& name, | |
2040 | const wxWindow *parent = NULL ) { | |
2041 | return wxWindow::FindWindowByName(name, parent); | |
2042 | } | |
2043 | ||
2044 | wxWindow* wxFindWindowByLabel( const wxString& label, | |
2045 | const wxWindow *parent = NULL ) { | |
2046 | return wxWindow::FindWindowByLabel(label, parent); | |
2047 | } | |
2048 | %} | |
2049 | ||
2050 | ||
2051 | ||
2052 | %{ | |
2053 | #ifdef __WXMSW__ | |
2054 | #include <wx/msw/private.h> // to get wxGetWindowId | |
2055 | #endif | |
2056 | %} | |
2057 | ||
2058 | %inline %{ | |
2059 | wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) { | |
2060 | #ifdef __WXMSW__ | |
2061 | WXHWND hWnd = (WXHWND)_hWnd; | |
2062 | long id = wxGetWindowId(hWnd); | |
2063 | wxWindow* win = new wxWindow; | |
2064 | parent->AddChild(win); | |
2065 | win->SetEventHandler(win); | |
2066 | win->SetHWND(hWnd); | |
2067 | win->SetId(id); | |
2068 | win->SubclassWin(hWnd); | |
2069 | win->AdoptAttributesFromHWND(); | |
2070 | win->SetupColours(); | |
2071 | return win; | |
2072 | #else | |
2073 | wxPyRaiseNotImplemented(); | |
2074 | return NULL; | |
2075 | #endif | |
2076 | } | |
2077 | %} | |
2078 | ||
2079 | //--------------------------------------------------------------------------- | |
2080 | ||
2081 | DocStr(GetTopLevelWindows, | |
2082 | "Returns a list of the the application's top-level windows, (frames, | |
2083 | dialogs, etc.) NOTE: Currently this is a copy of the list maintained | |
2084 | by wxWidgets, and so it is only valid as long as no top-level windows | |
2085 | are closed or new top-level windows are created. | |
2086 | ", ""); | |
2087 | %inline %{ | |
2088 | PyObject* GetTopLevelWindows() { | |
2089 | return wxPy_ConvertList(&wxTopLevelWindows); | |
2090 | } | |
2091 | %} | |
2092 | ||
2093 | //--------------------------------------------------------------------------- | |
2094 | //--------------------------------------------------------------------------- | |
2095 |