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