]> git.saurik.com Git - wxWidgets.git/blob - docs/latex/wx/window.tex
document ShowHidden() (patch 1619786)
[wxWidgets.git] / docs / latex / wx / window.tex
1 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2 %% Name: window.tex
3 %% Purpose: wxWindow documentation
4 %% Author: wxWidgets Team
5 %% Modified by:
6 %% Created:
7 %% RCS-ID: $Id$
8 %% Copyright: (c) wxWidgets Team
9 %% License: wxWindows license
10 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11
12 \section{\class{wxWindow}}\label{wxwindow}
13
14 wxWindow is the base class for all windows and represents any visible object on
15 screen. All controls, top level windows and so on are windows. Sizers and
16 device contexts are not, however, as they don't appear on screen themselves.
17
18 Please note that all children of the window will be deleted automatically by
19 the destructor before the window itself is deleted which means that you don't
20 have to worry about deleting them manually. Please see the \helpref{window
21 deletion overview}{windowdeletionoverview} for more information.
22
23 Also note that in this, and many others, wxWidgets classes some
24 \texttt{GetXXX()} methods may be overloaded (as, for example,
25 \helpref{GetSize}{wxwindowgetsize} or
26 \helpref{GetClientSize}{wxwindowgetclientsize}). In this case, the overloads
27 are non-virtual because having multiple virtual functions with the same name
28 results in a virtual function name hiding at the derived class level (in
29 English, this means that the derived class has to override all overloaded
30 variants if it overrides any of them). To allow overriding them in the derived
31 class, wxWidgets uses a unique protected virtual \texttt{DoGetXXX()} method
32 and all \texttt{GetXXX()} ones are forwarded to it, so overriding the former
33 changes the behaviour of the latter.
34
35 \wxheading{Derived from}
36
37 \helpref{wxEvtHandler}{wxevthandler}\\
38 \helpref{wxObject}{wxobject}
39
40 \wxheading{Include files}
41
42 <wx/window.h>
43
44 \wxheading{Window styles}
45
46 The following styles can apply to all windows, although they will not always make sense for a particular
47 window class or on all platforms.
48
49 \twocolwidtha{5cm}%
50 \begin{twocollist}\itemsep=0pt
51 \twocolitem{\windowstyle{wxSIMPLE\_BORDER}}{Displays a thin border around the window. wxBORDER is the old name
52 for this style. }
53 \twocolitem{\windowstyle{wxDOUBLE\_BORDER}}{Displays a double border. Windows and Mac only.}
54 \twocolitem{\windowstyle{wxSUNKEN\_BORDER}}{Displays a sunken border.}
55 \twocolitem{\windowstyle{wxRAISED\_BORDER}}{Displays a raised border.}
56 \twocolitem{\windowstyle{wxSTATIC\_BORDER}}{Displays a border suitable for a static control. Windows only. }
57 \twocolitem{\windowstyle{wxNO\_BORDER}}{Displays no border, overriding the default border style for the window.}
58 \twocolitem{\windowstyle{wxTRANSPARENT\_WINDOW}}{The window is transparent, that is, it will not receive paint
59 events. Windows only.}
60 \twocolitem{\windowstyle{wxTAB\_TRAVERSAL}}{Use this to enable tab traversal for non-dialog windows.}
61 \twocolitem{\windowstyle{wxWANTS\_CHARS}}{Use this to indicate that
62 the window wants to get all char/key events for all keys - even for
63 keys like TAB or ENTER which are usually used for dialog navigation
64 and which wouldn't be generated without this style. If you need to
65 use this style in order to get the arrows or etc., but would still like to have
66 normal keyboard navigation take place, you should create and send a
67 wxNavigationKeyEvent in response to the key events for Tab and
68 Shift-Tab.}
69 \twocolitem{\windowstyle{wxNO\_FULL\_REPAINT\_ON\_RESIZE}}{On Windows, this style used to disable repainting
70 the window completely when its size is changed. Since this behaviour is now the default, the style is now obsolete
71 and no longer has an effect.}
72 \twocolitem{\windowstyle{wxVSCROLL}}{Use this style to enable a vertical scrollbar.}
73 \twocolitem{\windowstyle{wxHSCROLL}}{Use this style to enable a horizontal scrollbar.}
74 \twocolitem{\windowstyle{wxALWAYS\_SHOW\_SB}}{If a window has scrollbars,
75 disable them instead of hiding them when they are not needed (i.e. when the
76 size of the window is big enough to not require the scrollbars to navigate it).
77 This style is currently implemented for wxMSW, wxGTK and wxUniversal and does
78 nothing on the other platforms.}
79 \twocolitem{\windowstyle{wxCLIP\_CHILDREN}}{Use this style to eliminate flicker caused by the background being
80 repainted, then children being painted over them. Windows only.}
81 \twocolitem{\windowstyle{wxFULL\_REPAINT\_ON\_RESIZE}}{Use this style to force
82 a complete redraw of the window whenever it is resized instead of redrawing
83 just the part of the window affected by resizing. Note that this was the
84 behaviour by default before 2.5.1 release and that if you experience redraw
85 problems with code which previously used to work you may want to try this.
86 Currently this style applies on GTK+ 2 and Windows only, and full repainting is always
87 done on other platforms.}
88 \end{twocollist}
89
90 See also \helpref{window styles overview}{windowstyles}.
91
92 \wxheading{Extra window styles}
93
94 The following are extra styles, set using \helpref{wxWindow::SetExtraStyle}{wxwindowsetextrastyle}.
95
96 \twocolwidtha{5cm}%
97 \begin{twocollist}\itemsep=0pt
98 \twocolitem{\windowstyle{wxWS\_EX\_VALIDATE\_RECURSIVELY}}{By default, Validate/TransferDataTo/FromWindow()
99 only work on direct children of the window (compatible behaviour). Set this flag to make them recursively
100 descend into all subwindows.}
101 \twocolitem{\windowstyle{wxWS\_EX\_BLOCK\_EVENTS}}{wxCommandEvents and the objects of the derived classes are forwarded to the
102 parent window and so on recursively by default. Using this flag for the
103 given window allows to block this propagation at this window, i.e. prevent
104 the events from being propagated further upwards. Dialogs have this
105 flag on by default.}
106 \twocolitem{\windowstyle{wxWS\_EX\_TRANSIENT}}{Don't use this window as an implicit parent for the other windows: this must
107 be used with transient windows as otherwise there is the risk of creating a
108 dialog/frame with this window as a parent which would lead to a crash if the
109 parent is destroyed before the child.}
110 \twocolitem{\windowstyle{wxWS\_EX\_PROCESS\_IDLE}}{This window should always process idle events, even
111 if the mode set by \helpref{wxIdleEvent::SetMode}{wxidleeventsetmode} is wxIDLE\_PROCESS\_SPECIFIED.}
112 \twocolitem{\windowstyle{wxWS\_EX\_PROCESS\_UI\_UPDATES}}{This window should always process UI update events,
113 even if the mode set by \helpref{wxUpdateUIEvent::SetMode}{wxupdateuieventsetmode} is wxUPDATE\_UI\_PROCESS\_SPECIFIED.}
114 \end{twocollist}
115
116 \wxheading{See also}
117
118 \helpref{Event handling overview}{eventhandlingoverview}\\
119 \helpref{Window sizing overview}{windowsizingoverview}
120
121 \latexignore{\rtfignore{\wxheading{Members}}}
122
123
124 \membersection{wxWindow::wxWindow}\label{wxwindowctor}
125
126 \func{}{wxWindow}{\void}
127
128 Default constructor.
129
130 \func{}{wxWindow}{\param{wxWindow*}{ parent}, \param{wxWindowID }{id},
131 \param{const wxPoint\& }{pos = wxDefaultPosition},
132 \param{const wxSize\& }{size = wxDefaultSize},
133 \param{long }{style = 0},
134 \param{const wxString\& }{name = wxPanelNameStr}}
135
136 Constructs a window, which can be a child of a frame, dialog or any other non-control window.
137
138 \wxheading{Parameters}
139
140 \docparam{parent}{Pointer to a parent window.}
141
142 \docparam{id}{Window identifier. If wxID\_ANY, will automatically create an identifier.}
143
144 \docparam{pos}{Window position. wxDefaultPosition indicates that wxWidgets
145 should generate a default position for the window. If using the wxWindow class directly, supply
146 an actual position.}
147
148 \docparam{size}{Window size. wxDefaultSize indicates that wxWidgets
149 should generate a default size for the window. If no suitable size can be found, the
150 window will be sized to 20x20 pixels so that the window is visible but obviously not
151 correctly sized. }
152
153 \docparam{style}{Window style. For generic window styles, please see \helpref{wxWindow}{wxwindow}.}
154
155 \docparam{name}{Window name.}
156
157
158 \membersection{wxWindow::\destruct{wxWindow}}\label{wxwindowdtor}
159
160 \func{}{\destruct{wxWindow}}{\void}
161
162 Destructor. Deletes all subwindows, then deletes itself. Instead of using
163 the {\bf delete} operator explicitly, you should normally
164 use \helpref{wxWindow::Destroy}{wxwindowdestroy} so that wxWidgets
165 can delete a window only when it is safe to do so, in idle time.
166
167 \wxheading{See also}
168
169 \helpref{Window deletion overview}{windowdeletionoverview},\rtfsp
170 \helpref{wxWindow::Destroy}{wxwindowdestroy},\rtfsp
171 \helpref{wxCloseEvent}{wxcloseevent}
172
173
174 \membersection{wxWindow::AddChild}\label{wxwindowaddchild}
175
176 \func{virtual void}{AddChild}{\param{wxWindow* }{child}}
177
178 Adds a child window. This is called automatically by window creation
179 functions so should not be required by the application programmer.
180
181 Notice that this function is mostly internal to wxWidgets and shouldn't be
182 called by the user code.
183
184 \wxheading{Parameters}
185
186 \docparam{child}{Child window to add.}
187
188
189 \membersection{wxWindow::CacheBestSize}\label{wxwindowcachebestsize}
190
191 \constfunc{void}{CacheBestSize}{\param{const wxSize\& }{size}}
192
193 Sets the cached best size value.
194
195
196 \membersection{wxWindow::CaptureMouse}\label{wxwindowcapturemouse}
197
198 \func{virtual void}{CaptureMouse}{\void}
199
200 Directs all mouse input to this window. Call \helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse} to
201 release the capture.
202
203 Note that wxWidgets maintains the stack of windows having captured the mouse
204 and when the mouse is released the capture returns to the window which had had
205 captured it previously and it is only really released if there were no previous
206 window. In particular, this means that you must release the mouse as many times
207 as you capture it, unless the window receives
208 the \helpref{wxMouseCaptureLostEvent}{wxmousecapturelostevent} event.
209
210 Any application which captures the mouse in the beginning of some operation
211 {\em must} handle \helpref{wxMouseCaptureLostEvent}{wxmousecapturelostevent}
212 and cancel this operation when it receives the event. The event handler must
213 not recapture mouse.
214
215 \wxheading{See also}
216
217 \helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse}
218 \helpref{wxMouseCaptureLostEvent}{wxmousecapturelostevent}
219
220
221 \membersection{wxWindow::Center}\label{wxwindowcenter}
222
223 \func{void}{Center}{\param{int}{ direction}}
224
225 A synonym for \helpref{Centre}{wxwindowcentre}.
226
227
228 \membersection{wxWindow::CenterOnParent}\label{wxwindowcenteronparent}
229
230 \func{void}{CenterOnParent}{\param{int}{ direction}}
231
232 A synonym for \helpref{CentreOnParent}{wxwindowcentreonparent}.
233
234
235 \membersection{wxWindow::CenterOnScreen}\label{wxwindowcenteronscreen}
236
237 \func{void}{CenterOnScreen}{\param{int}{ direction}}
238
239 A synonym for \helpref{CentreOnScreen}{wxwindowcentreonscreen}.
240
241
242 \membersection{wxWindow::Centre}\label{wxwindowcentre}
243
244 \func{void}{Centre}{\param{int}{ direction = wxBOTH}}
245
246 Centres the window.
247
248 \wxheading{Parameters}
249
250 \docparam{direction}{Specifies the direction for the centering. May be {\tt wxHORIZONTAL}, {\tt wxVERTICAL}\rtfsp
251 or {\tt wxBOTH}. It may also include {\tt wxCENTRE\_ON\_SCREEN} flag
252 if you want to center the window on the entire screen and not on its
253 parent window.}
254
255 The flag {\tt wxCENTRE\_FRAME} is obsolete and should not be used any longer
256 (it has no effect).
257
258 \wxheading{Remarks}
259
260 If the window is a top level one (i.e. doesn't have a parent), it will be
261 centered relative to the screen anyhow.
262
263 \wxheading{See also}
264
265 \helpref{wxWindow::Center}{wxwindowcenter}
266
267
268 \membersection{wxWindow::CentreOnParent}\label{wxwindowcentreonparent}
269
270 \func{void}{CentreOnParent}{\param{int}{ direction = wxBOTH}}
271
272 Centres the window on its parent. This is a more readable synonym for
273 \helpref{Centre}{wxwindowcentre}.
274
275 \wxheading{Parameters}
276
277 \docparam{direction}{Specifies the direction for the centering. May be {\tt wxHORIZONTAL}, {\tt wxVERTICAL}\rtfsp
278 or {\tt wxBOTH}.}
279
280 \wxheading{Remarks}
281
282 This methods provides for a way to center top level windows over their
283 parents instead of the entire screen. If there is no parent or if the
284 window is not a top level window, then behaviour is the same as
285 \helpref{wxWindow::Centre}{wxwindowcentre}.
286
287 \wxheading{See also}
288
289 \helpref{wxWindow::CentreOnScreen}{wxwindowcenteronscreen}
290
291
292 \membersection{wxWindow::CentreOnScreen}\label{wxwindowcentreonscreen}
293
294 \func{void}{CentreOnScreen}{\param{int}{ direction = wxBOTH}}
295
296 Centres the window on screen. This only works for top level windows -
297 otherwise, the window will still be centered on its parent.
298
299 \wxheading{Parameters}
300
301 \docparam{direction}{Specifies the direction for the centering. May be {\tt wxHORIZONTAL}, {\tt wxVERTICAL}\rtfsp
302 or {\tt wxBOTH}.}
303
304 \wxheading{See also}
305
306 \helpref{wxWindow::CentreOnParent}{wxwindowcenteronparent}
307
308
309 \membersection{wxWindow::ClearBackground}\label{wxwindowclearbackground}
310
311 \func{void}{ClearBackground}{\void}
312
313 Clears the window by filling it with the current background colour. Does not
314 cause an erase background event to be generated.
315
316
317 \membersection{wxWindow::ClientToScreen}\label{wxwindowclienttoscreen}
318
319 \constfunc{virtual void}{ClientToScreen}{\param{int* }{x}, \param{int* }{y}}
320
321 \perlnote{In wxPerl this method returns a 2-element list instead of
322 modifying its parameters.}
323
324 \constfunc{virtual wxPoint}{ClientToScreen}{\param{const wxPoint\&}{ pt}}
325
326 Converts to screen coordinates from coordinates relative to this window.
327
328 \docparam{x}{A pointer to a integer value for the x coordinate. Pass the client coordinate in, and
329 a screen coordinate will be passed out.}
330
331 \docparam{y}{A pointer to a integer value for the y coordinate. Pass the client coordinate in, and
332 a screen coordinate will be passed out.}
333
334 \docparam{pt}{The client position for the second form of the function.}
335
336 \pythonnote{In place of a single overloaded method name, wxPython
337 implements the following methods:\par
338 \indented{2cm}{\begin{twocollist}
339 \twocolitem{{\bf ClientToScreen(point)}}{Accepts and returns a wxPoint}
340 \twocolitem{{\bf ClientToScreenXY(x, y)}}{Returns a 2-tuple, (x, y)}
341 \end{twocollist}}
342 }
343
344
345 \membersection{wxWindow::Close}\label{wxwindowclose}
346
347 \func{bool}{Close}{\param{bool}{ force = {\tt false}}}
348
349 This function simply generates a \helpref{wxCloseEvent}{wxcloseevent} whose
350 handler usually tries to close the window. It doesn't close the window itself,
351 however.
352
353 \wxheading{Parameters}
354
355 \docparam{force}{{\tt false} if the window's close handler should be able to veto the destruction
356 of this window, {\tt true} if it cannot.}
357
358 \wxheading{Remarks}
359
360 Close calls the \helpref{close handler}{wxcloseevent} for the window, providing
361 an opportunity for the window to choose whether to destroy the window.
362 Usually it is only used with the top level windows (wxFrame and wxDialog
363 classes) as the others are not supposed to have any special OnClose() logic.
364
365 The close handler should check whether the window is being deleted forcibly,
366 using \helpref{wxCloseEvent::CanVeto}{wxcloseeventcanveto}, in which case it
367 should destroy the window using \helpref{wxWindow::Destroy}{wxwindowdestroy}.
368
369 {\it Note} that calling Close does not guarantee that the window will be
370 destroyed; but it provides a way to simulate a manual close of a window, which
371 may or may not be implemented by destroying the window. The default
372 implementation of wxDialog::OnCloseWindow does not necessarily delete the
373 dialog, since it will simply simulate an wxID\_CANCEL event which is handled by
374 the appropriate button event handler and may do anything at all.
375
376 To guarantee that the window will be destroyed, call
377 \helpref{wxWindow::Destroy}{wxwindowdestroy} instead
378
379 \wxheading{See also}
380
381 \helpref{Window deletion overview}{windowdeletionoverview},\rtfsp
382 \helpref{wxWindow::Destroy}{wxwindowdestroy},\rtfsp
383 \helpref{wxCloseEvent}{wxcloseevent}
384
385
386 \membersection{wxWindow::ConvertDialogToPixels}\label{wxwindowconvertdialogtopixels}
387
388 \func{wxPoint}{ConvertDialogToPixels}{\param{const wxPoint\&}{ pt}}
389
390 \func{wxSize}{ConvertDialogToPixels}{\param{const wxSize\&}{ sz}}
391
392 Converts a point or size from dialog units to pixels.
393
394 For the x dimension, the dialog units are multiplied by the average character width
395 and then divided by 4.
396
397 For the y dimension, the dialog units are multiplied by the average character height
398 and then divided by 8.
399
400 \wxheading{Remarks}
401
402 Dialog units are used for maintaining a dialog's proportions even if the font changes.
403
404 You can also use these functions programmatically. A convenience macro is defined:
405
406 {\small
407 \begin{verbatim}
408 #define wxDLG_UNIT(parent, pt) parent->ConvertDialogToPixels(pt)
409 \end{verbatim}
410 }
411
412 \wxheading{See also}
413
414 \helpref{wxWindow::ConvertPixelsToDialog}{wxwindowconvertpixelstodialog}
415
416 \pythonnote{In place of a single overloaded method name, wxPython
417 implements the following methods:\par
418 \indented{2cm}{\begin{twocollist}
419 \twocolitem{{\bf ConvertDialogPointToPixels(point)}}{Accepts and returns a wxPoint}
420 \twocolitem{{\bf ConvertDialogSizeToPixels(size)}}{Accepts and returns a wxSize}
421 \end{twocollist}}
422
423 Additionally, the following helper functions are defined:\par
424 \indented{2cm}{\begin{twocollist}
425 \twocolitem{{\bf wxDLG\_PNT(win, point)}}{Converts a wxPoint from dialog
426 units to pixels}
427 \twocolitem{{\bf wxDLG\_SZE(win, size)}}{Converts a wxSize from dialog
428 units to pixels}
429 \end{twocollist}}
430 }
431
432
433
434 \membersection{wxWindow::ConvertPixelsToDialog}\label{wxwindowconvertpixelstodialog}
435
436 \func{wxPoint}{ConvertPixelsToDialog}{\param{const wxPoint\&}{ pt}}
437
438 \func{wxSize}{ConvertPixelsToDialog}{\param{const wxSize\&}{ sz}}
439
440 Converts a point or size from pixels to dialog units.
441
442 For the x dimension, the pixels are multiplied by 4 and then divided by the average
443 character width.
444
445 For the y dimension, the pixels are multiplied by 8 and then divided by the average
446 character height.
447
448 \wxheading{Remarks}
449
450 Dialog units are used for maintaining a dialog's proportions even if the font changes.
451
452 \wxheading{See also}
453
454 \helpref{wxWindow::ConvertDialogToPixels}{wxwindowconvertdialogtopixels}
455
456 \pythonnote{In place of a single overloaded method name, wxPython implements the following methods:\par
457 \indented{2cm}{\begin{twocollist}
458 \twocolitem{{\bf ConvertDialogPointToPixels(point)}}{Accepts and returns a wxPoint}
459 \twocolitem{{\bf ConvertDialogSizeToPixels(size)}}{Accepts and returns a wxSize}
460 \end{twocollist}}
461 }
462
463
464 \membersection{wxWindow::Destroy}\label{wxwindowdestroy}
465
466 \func{virtual bool}{Destroy}{\void}
467
468 Destroys the window safely. Use this function instead of the delete operator, since
469 different window classes can be destroyed differently. Frames and dialogs
470 are not destroyed immediately when this function is called -- they are added
471 to a list of windows to be deleted on idle time, when all the window's events
472 have been processed. This prevents problems with events being sent to non-existent
473 windows.
474
475 \wxheading{Return value}
476
477 {\tt true} if the window has either been successfully deleted, or it has been added
478 to the list of windows pending real deletion.
479
480
481 \membersection{wxWindow::DestroyChildren}\label{wxwindowdestroychildren}
482
483 \func{virtual void}{DestroyChildren}{\void}
484
485 Destroys all children of a window. Called automatically by the destructor.
486
487
488 \membersection{wxWindow::Disable}\label{wxwindowdisable}
489
490 \func{bool}{Disable}{\void}
491
492 Disables the window, same as \helpref{Enable({\tt false})}{wxwindowenable}.
493
494 \wxheading{Return value}
495
496 Returns {\tt true} if the window has been disabled, {\tt false} if it had been
497 already disabled before the call to this function.
498
499
500 \membersection{wxWindow::DoGetBestSize}\label{wxwindowdogetbestsize}
501
502 \constfunc{virtual wxSize}{DoGetBestSize}{\void}
503
504 Gets the size which best suits the window: for a control, it would be
505 the minimal size which doesn't truncate the control, for a panel - the
506 same size as it would have after a call to \helpref{Fit()}{wxwindowfit}.
507
508
509 \membersection{wxWindow::DoUpdateWindowUI}\label{wxwindowdoupdatewindowui}
510
511 \func{virtual void}{DoUpdateWindowUI}{\param{wxUpdateUIEvent\&}{ event}}
512
513 Does the window-specific updating after processing the update event.
514 This function is called by \helpref{wxWindow::UpdateWindowUI}{wxwindowupdatewindowui}
515 in order to check return values in the \helpref{wxUpdateUIEvent}{wxupdateuievent} and
516 act appropriately. For example, to allow frame and dialog title updating, wxWidgets
517 implements this function as follows:
518
519 \begin{verbatim}
520 // do the window-specific processing after processing the update event
521 void wxTopLevelWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
522 {
523 if ( event.GetSetEnabled() )
524 Enable(event.GetEnabled());
525
526 if ( event.GetSetText() )
527 {
528 if ( event.GetText() != GetTitle() )
529 SetTitle(event.GetText());
530 }
531 }
532 \end{verbatim}
533
534
535
536 \membersection{wxWindow::DragAcceptFiles}\label{wxwindowdragacceptfiles}
537
538 \func{virtual void}{DragAcceptFiles}{\param{bool}{ accept}}
539
540 Enables or disables eligibility for drop file events (OnDropFiles).
541
542 \wxheading{Parameters}
543
544 \docparam{accept}{If {\tt true}, the window is eligible for drop file events. If {\tt false}, the window
545 will not accept drop file events.}
546
547 \wxheading{Remarks}
548
549 Windows only.
550
551
552 \membersection{wxWindow::Enable}\label{wxwindowenable}
553
554 \func{virtual bool}{Enable}{\param{bool}{ enable = {\tt true}}}
555
556 Enable or disable the window for user input. Note that when a parent window is
557 disabled, all of its children are disabled as well and they are reenabled again
558 when the parent is.
559
560 \wxheading{Parameters}
561
562 \docparam{enable}{If {\tt true}, enables the window for input. If {\tt false}, disables the window.}
563
564 \wxheading{Return value}
565
566 Returns {\tt true} if the window has been enabled or disabled, {\tt false} if
567 nothing was done, i.e. if the window had already been in the specified state.
568
569 \wxheading{See also}
570
571 \helpref{wxWindow::IsEnabled}{wxwindowisenabled},\rtfsp
572 \helpref{wxWindow::Disable}{wxwindowdisable},\rtfsp
573 \helpref{wxRadioBox::Enable}{wxradioboxenable}
574
575
576 \membersection{wxWindow::FindFocus}\label{wxwindowfindfocus}
577
578 \func{static wxWindow*}{FindFocus}{\void}
579
580 Finds the window or control which currently has the keyboard focus.
581
582 \wxheading{Remarks}
583
584 Note that this is a static function, so it can be called without needing a wxWindow pointer.
585
586 \wxheading{See also}
587
588 \helpref{wxWindow::SetFocus}{wxwindowsetfocus}
589
590
591
592 \membersection{wxWindow::FindWindow}\label{wxwindowfindwindow}
593
594 \constfunc{wxWindow*}{FindWindow}{\param{long}{ id}}
595
596 Find a child of this window, by identifier.
597
598 \constfunc{wxWindow*}{FindWindow}{\param{const wxString\&}{ name}}
599
600 Find a child of this window, by name.
601
602 \pythonnote{In place of a single overloaded method name, wxPython
603 implements the following methods:\par
604 \indented{2cm}{\begin{twocollist}
605 \twocolitem{{\bf FindWindowById(id)}}{Accepts an integer}
606 \twocolitem{{\bf FindWindowByName(name)}}{Accepts a string}
607 \end{twocollist}}
608 }
609
610
611 \membersection{wxWindow::FindWindowById}\label{wxwindowfindwindowbyid}
612
613 \func{static wxWindow*}{FindWindowById}{\param{long}{ id}, \param{wxWindow*}{ parent = NULL}}
614
615 Find the first window with the given {\it id}.
616
617 If {\it parent} is NULL, the search will start from all top-level
618 frames and dialog boxes; if non-NULL, the search will be limited to the given window hierarchy.
619 The search is recursive in both cases.
620
621 \wxheading{See also}
622
623 \helpref{FindWindow}{wxwindowfindwindow}
624
625
626 \membersection{wxWindow::FindWindowByLabel}\label{wxwindowfindwindowbylabel}
627
628 \func{static wxWindow*}{FindWindowByLabel}{\param{const wxString\&}{ label}, \param{wxWindow*}{ parent = NULL}}
629
630 Find a window by its label. Depending on the type of window, the label may be a window title
631 or panel item label. If {\it parent} is NULL, the search will start from all top-level
632 frames and dialog boxes; if non-NULL, the search will be limited to the given window hierarchy.
633 The search is recursive in both cases.
634
635 \wxheading{See also}
636
637 \helpref{FindWindow}{wxwindowfindwindow}
638
639
640 \membersection{wxWindow::FindWindowByName}\label{wxwindowfindwindowbyname}
641
642 \func{static wxWindow*}{FindWindowByName}{\param{const wxString\&}{ name}, \param{wxWindow*}{ parent = NULL}}
643
644 Find a window by its name (as given in a window constructor or {\bf Create} function call).
645 If {\it parent} is NULL, the search will start from all top-level
646 frames and dialog boxes; if non-NULL, the search will be limited to the given window hierarchy.
647 The search is recursive in both cases.
648
649 If no window with such name is found,
650 \helpref{FindWindowByLabel}{wxwindowfindwindowbylabel} is called.
651
652 \wxheading{See also}
653
654 \helpref{FindWindow}{wxwindowfindwindow}
655
656
657 \membersection{wxWindow::Fit}\label{wxwindowfit}
658
659 \func{virtual void}{Fit}{\void}
660
661 Sizes the window so that it fits around its subwindows. This function won't do
662 anything if there are no subwindows and will only really work correctly if the
663 sizers are used for the subwindows layout. Also, if the window has exactly one
664 subwindow it is better (faster and the result is more precise as Fit adds some
665 margin to account for fuzziness of its calculations) to call
666
667 \begin{verbatim}
668 window->SetClientSize(child->GetSize());
669 \end{verbatim}
670
671 instead of calling Fit.
672
673
674 \membersection{wxWindow::FitInside}\label{wxwindowfitinside}
675
676 \func{virtual void}{FitInside}{\void}
677
678 Similar to \helpref{Fit}{wxwindowfit}, but sizes the interior (virtual) size
679 of a window. Mainly useful with scrolled windows to reset scrollbars after
680 sizing changes that do not trigger a size event, and/or scrolled windows without
681 an interior sizer. This function similarly won't do anything if there are no
682 subwindows.
683
684
685 \membersection{wxWindow::Freeze}\label{wxwindowfreeze}
686
687 \func{virtual void}{Freeze}{\void}
688
689 Freezes the window or, in other words, prevents any updates from taking place
690 on screen, the window is not redrawn at all. \helpref{Thaw}{wxwindowthaw} must
691 be called to reenable window redrawing. Calls to these two functions may be
692 nested.
693
694 This method is useful for visual appearance optimization (for example, it
695 is a good idea to use it before doing many large text insertions in a row into
696 a wxTextCtrl under wxGTK) but is not implemented on all platforms nor for all
697 controls so it is mostly just a hint to wxWidgets and not a mandatory
698 directive.
699
700 \wxheading{See also}
701
702 \helpref{wxWindowUpdateLocker}{wxwindowupdatelocker}
703
704
705 \membersection{wxWindow::GetAcceleratorTable}\label{wxwindowgetacceleratortable}
706
707 \constfunc{wxAcceleratorTable*}{GetAcceleratorTable}{\void}
708
709 Gets the accelerator table for this window. See \helpref{wxAcceleratorTable}{wxacceleratortable}.
710
711
712 \membersection{wxWindow::GetAccessible}\label{wxwindowgetaccessible}
713
714 \func{wxAccessible*}{GetAccessible}{\void}
715
716 Returns the accessible object for this window, if any.
717
718 See also \helpref{wxAccessible}{wxaccessible}.
719
720
721 \membersection{wxWindow::GetAdjustedBestSize}\label{wxwindowgetadjustedbestsize}
722
723 \constfunc{wxSize}{GetAdjustedBestSize}{\void}
724
725 This method is deprecated, use \helpref{GetEffectiveMinSize}{wxwindowgeteffectiveminsize}
726 instead.
727
728
729 \membersection{wxWindow::GetBackgroundColour}\label{wxwindowgetbackgroundcolour}
730
731 \constfunc{virtual wxColour}{GetBackgroundColour}{\void}
732
733 Returns the background colour of the window.
734
735 \wxheading{See also}
736
737 \helpref{wxWindow::SetBackgroundColour}{wxwindowsetbackgroundcolour},\rtfsp
738 \helpref{wxWindow::SetForegroundColour}{wxwindowsetforegroundcolour},\rtfsp
739 \helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour}
740
741 \membersection{wxWindow::GetBackgroundStyle}\label{wxwindowgetbackgroundstyle}
742
743 \constfunc{virtual wxBackgroundStyle}{GetBackgroundStyle}{\void}
744
745 Returns the background style of the window. The background style indicates
746 whether background colour should be determined by the system (wxBG\_STYLE\_SYSTEM),
747 be set to a specific colour (wxBG\_STYLE\_COLOUR), or should be left to the
748 application to implement (wxBG\_STYLE\_CUSTOM).
749
750 On GTK+, use of wxBG\_STYLE\_CUSTOM allows the flicker-free drawing of a custom
751 background, such as a tiled bitmap. Currently the style has no effect on other platforms.
752
753 \wxheading{See also}
754
755 \helpref{wxWindow::SetBackgroundColour}{wxwindowsetbackgroundcolour},\rtfsp
756 \helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour},\rtfsp
757 \helpref{wxWindow::SetBackgroundStyle}{wxwindowsetbackgroundstyle}
758
759 \membersection{wxWindow::GetEffectiveMinSize}\label{wxwindowgeteffectiveminsize}
760
761 \constfunc{wxSize}{GetEffectiveMinSize}{\void}
762
763 Merges the window's best size into the min size and returns the
764 result. This is the value used by sizers to determine the appropriate
765 ammount of sapce to allocate for the widget.
766
767 \wxheading{See also}
768
769 \helpref{wxWindow::GetBestSize}{wxwindowgetbestsize},\rtfsp
770 \helpref{wxWindow::SetInitialSize}{wxwindowsetinitialsize}
771
772
773 \membersection{wxWindow::GetBestSize}\label{wxwindowgetbestsize}
774
775 \constfunc{wxSize}{GetBestSize}{\void}
776
777 This functions returns the best acceptable minimal size for the window. For
778 example, for a static control, it will be the minimal size such that the
779 control label is not truncated. For windows containing subwindows (typically
780 \helpref{wxPanel}{wxpanel}), the size returned by this function will be the
781 same as the size the window would have had after calling
782 \helpref{Fit}{wxwindowfit}.
783
784
785 \membersection{wxWindow::GetCapture}\label{wxwindowgetcapture}
786
787 \func{static wxWindow *}{GetCapture}{\void}
788
789 Returns the currently captured window.
790
791 \wxheading{See also}
792
793 \helpref{wxWindow::HasCapture}{wxwindowhascapture},
794 \helpref{wxWindow::CaptureMouse}{wxwindowcapturemouse},
795 \helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse},
796 \helpref{wxMouseCaptureLostEvent}{wxmousecapturelostevent}
797 \helpref{wxMouseCaptureChangedEvent}{wxmousecapturechangedevent}
798
799
800 \membersection{wxWindow::GetCaret}\label{wxwindowgetcaret}
801
802 \constfunc{wxCaret *}{GetCaret}{\void}
803
804 Returns the \helpref{caret}{wxcaret} associated with the window.
805
806
807 \membersection{wxWindow::GetCharHeight}\label{wxwindowgetcharheight}
808
809 \constfunc{virtual int}{GetCharHeight}{\void}
810
811 Returns the character height for this window.
812
813
814 \membersection{wxWindow::GetCharWidth}\label{wxwindowgetcharwidth}
815
816 \constfunc{virtual int}{GetCharWidth}{\void}
817
818 Returns the average character width for this window.
819
820
821 \membersection{wxWindow::GetChildren}\label{wxwindowgetchildren}
822
823 \func{wxWindowList\&}{GetChildren}{\void}
824
825 \constfunc{const wxWindowList\&}{GetChildren}{\void}
826
827 Returns a reference to the list of the window's children. \texttt{wxWindowList}
828 is a type-safe \helpref{wxList}{wxlist}-like class whose elements are of type
829 \texttt{wxWindow *}.
830
831
832 \membersection{wxWindow::GetClassDefaultAttributes}\label{wxwindowgetclassdefaultattributes}
833
834 \func{static wxVisualAttributes}{GetClassDefaultAttributes}{\param{wxWindowVariant}{ variant = \texttt{wxWINDOW\_VARIANT\_NORMAL}}}
835
836 Returns the default font and colours which are used by the control. This is
837 useful if you want to use the same font or colour in your own control as in a
838 standard control -- which is a much better idea than hard coding specific
839 colours or fonts which might look completely out of place on the users
840 system, especially if it uses themes.
841
842 The \arg{variant} parameter is only relevant under Mac currently and is
843 ignore under other platforms. Under Mac, it will change the size of the
844 returned font. See \helpref{wxWindow::SetWindowVariant}{wxwindowsetwindowvariant}
845 for more about this.
846
847 This static method is ``overridden'' in many derived classes and so calling,
848 for example, \helpref{wxButton}{wxbutton}::GetClassDefaultAttributes() will typically
849 return the values appropriate for a button which will be normally different
850 from those returned by, say, \helpref{wxListCtrl}{wxlistctrl}::GetClassDefaultAttributes().
851
852 The \texttt{wxVisualAttributes} structure has at least the fields
853 \texttt{font}, \texttt{colFg} and \texttt{colBg}. All of them may be invalid
854 if it was not possible to determine the default control appearance or,
855 especially for the background colour, if the field doesn't make sense as is
856 the case for \texttt{colBg} for the controls with themed background.
857
858 \wxheading{See also}
859
860 \helpref{InheritAttributes}{wxwindowinheritattributes}
861
862
863 \membersection{wxWindow::GetClientSize}\label{wxwindowgetclientsize}
864
865 \constfunc{void}{GetClientSize}{\param{int* }{width}, \param{int* }{height}}
866
867 \perlnote{In wxPerl this method takes no parameter and returns
868 a 2-element list {\tt (width, height)}.}
869
870 \constfunc{wxSize}{GetClientSize}{\void}
871
872 This gets the size of the window `client area' in pixels.
873 The client area is the area which may be drawn on by the programmer,
874 excluding title bar, border, scrollbars, etc.
875
876 \wxheading{Parameters}
877
878 \docparam{width}{Receives the client width in pixels.}
879
880 \docparam{height}{Receives the client height in pixels.}
881
882 \pythonnote{In place of a single overloaded method name, wxPython
883 implements the following methods:\par
884 \indented{2cm}{\begin{twocollist}
885 \twocolitem{{\bf GetClientSizeTuple()}}{Returns a 2-tuple of (width, height)}
886 \twocolitem{{\bf GetClientSize()}}{Returns a wxSize object}
887 \end{twocollist}}
888 }
889
890 \wxheading{See also}
891
892 \helpref{GetSize}{wxwindowgetsize},\rtfsp
893 \helpref{GetVirtualSize}{wxwindowgetvirtualsize}
894
895
896
897 \membersection{wxWindow::GetConstraints}\label{wxwindowgetconstraints}
898
899 \constfunc{wxLayoutConstraints*}{GetConstraints}{\void}
900
901 Returns a pointer to the window's layout constraints, or NULL if there are none.
902
903
904 \membersection{wxWindow::GetContainingSizer}\label{wxwindowgetcontainingsizer}
905
906 \constfunc{const wxSizer *}{GetContainingSizer}{\void}
907
908 Return the sizer that this window is a member of, if any, otherwise
909 {\tt NULL}.
910
911
912 \membersection{wxWindow::GetCursor}\label{wxwindowgetcursor}
913
914 \constfunc{const wxCursor\&}{GetCursor}{\void}
915
916 Return the cursor associated with this window.
917
918 \wxheading{See also}
919
920 \helpref{wxWindow::SetCursor}{wxwindowsetcursor}
921
922
923 \membersection{wxWindow::GetDefaultAttributes}\label{wxwindowgetdefaultattributes}
924
925 \constfunc{virtual wxVisualAttributes}{GetDefaultAttributes}{\void}
926
927 Currently this is the same as calling
928 \helpref{GetClassDefaultAttributes}{wxwindowgetclassdefaultattributes}(\helpref{GetWindowVariant}{wxwindowgetwindowvariant}()).
929
930 One advantage of using this function compared to the static version is that
931 the call is automatically dispatched to the correct class (as usual with
932 virtual functions) and you don't have to specify the class name explicitly.
933
934 The other one is that in the future this function could return different
935 results, for example it might return a different font for an ``Ok'' button
936 than for a generic button if the users GUI is configured to show such buttons
937 in bold font. Of course, the down side is that it is impossible to call this
938 function without actually having an object to apply it to whereas the static
939 version can be used without having to create an object first.
940
941
942 \membersection{wxWindow::GetDropTarget}\label{wxwindowgetdroptarget}
943
944 \constfunc{wxDropTarget*}{GetDropTarget}{\void}
945
946 Returns the associated drop target, which may be NULL.
947
948 \wxheading{See also}
949
950 \helpref{wxWindow::SetDropTarget}{wxwindowsetdroptarget},
951 \helpref{Drag and drop overview}{wxdndoverview}
952
953
954 \membersection{wxWindow::GetEventHandler}\label{wxwindowgeteventhandler}
955
956 \constfunc{wxEvtHandler*}{GetEventHandler}{\void}
957
958 Returns the event handler for this window. By default, the window is its
959 own event handler.
960
961 \wxheading{See also}
962
963 \helpref{wxWindow::SetEventHandler}{wxwindowseteventhandler},\rtfsp
964 \helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler},\rtfsp
965 \helpref{wxWindow::PopEventHandler}{wxwindowpusheventhandler},\rtfsp
966 \helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
967 \helpref{wxEvtHandler}{wxevthandler}\rtfsp
968
969
970 \membersection{wxWindow::GetExtraStyle}\label{wxwindowgetextrastyle}
971
972 \constfunc{long}{GetExtraStyle}{\void}
973
974 Returns the extra style bits for the window.
975
976
977 \membersection{wxWindow::GetFont}\label{wxwindowgetfont}
978
979 \constfunc{wxFont}{GetFont}{\void}
980
981 Returns the font for this window.
982
983 \wxheading{See also}
984
985 \helpref{wxWindow::SetFont}{wxwindowsetfont}
986
987
988 \membersection{wxWindow::GetForegroundColour}\label{wxwindowgetforegroundcolour}
989
990 \func{virtual wxColour}{GetForegroundColour}{\void}
991
992 Returns the foreground colour of the window.
993
994 \wxheading{Remarks}
995
996 The interpretation of foreground colour is open to interpretation according
997 to the window class; it may be the text colour or other colour, or it may not
998 be used at all.
999
1000 \wxheading{See also}
1001
1002 \helpref{wxWindow::SetForegroundColour}{wxwindowsetforegroundcolour},\rtfsp
1003 \helpref{wxWindow::SetBackgroundColour}{wxwindowsetbackgroundcolour},\rtfsp
1004 \helpref{wxWindow::GetBackgroundColour}{wxwindowgetbackgroundcolour}
1005
1006
1007 \membersection{wxWindow::GetGrandParent}\label{wxwindowgetgrandparent}
1008
1009 \constfunc{wxWindow*}{GetGrandParent}{\void}
1010
1011 Returns the grandparent of a window, or NULL if there isn't one.
1012
1013
1014 \membersection{wxWindow::GetHandle}\label{wxwindowgethandle}
1015
1016 \constfunc{void*}{GetHandle}{\void}
1017
1018 Returns the platform-specific handle of the physical window. Cast it to an appropriate
1019 handle, such as {\bf HWND} for Windows, {\bf Widget} for Motif, {\bf GtkWidget} for GTK or {\bf WinHandle} for PalmOS.
1020
1021 \pythonnote{This method will return an integer in wxPython.}
1022
1023 \perlnote{This method will return an integer in wxPerl.}
1024
1025
1026 \membersection{wxWindow::GetHelpTextAtPoint}\label{wxwindowgethelptextatpoint}
1027
1028 \constfunc{virtual wxString}{GetHelpTextAtPoint}{\param{const wxPoint &}{point}, \param{wxHelpEvent::Origin }{origin}}
1029
1030 Gets the help text to be used as context-sensitive help for this window. This
1031 method should be overridden if the help message depends on the position inside
1032 the window, otherwise \helpref{GetHelpText}{wxwindowgethelptext} can be used.
1033
1034 \wxheading{Parameters}
1035
1036 \docparam{point}{Coordinates of the mouse at the moment of help event emission.}
1037
1038 \docparam{origin}{Help event origin, see also \helpref{wxHelpEvent::GetOrigin}{wxhelpeventgetorigin}.}
1039
1040 \newsince{2.7.0}
1041
1042
1043 \membersection{wxWindow::GetHelpText}\label{wxwindowgethelptext}
1044
1045 \constfunc{virtual wxString}{GetHelpText}{\void}
1046
1047 Gets the help text to be used as context-sensitive help for this window.
1048
1049 Note that the text is actually stored by the current \helpref{wxHelpProvider}{wxhelpprovider} implementation,
1050 and not in the window object itself.
1051
1052 \wxheading{See also}
1053
1054 \helpref{SetHelpText}{wxwindowsethelptext}, \helpref{GetHelpTextAtPoint}{wxwindowgethelptextatpoint}, \helpref{wxHelpProvider}{wxhelpprovider}
1055
1056
1057 \membersection{wxWindow::GetId}\label{wxwindowgetid}
1058
1059 \constfunc{int}{GetId}{\void}
1060
1061 Returns the identifier of the window.
1062
1063 \wxheading{Remarks}
1064
1065 Each window has an integer identifier. If the application has not provided one
1066 (or the default wxID\_ANY) an unique identifier with a negative value will be generated.
1067
1068 \wxheading{See also}
1069
1070 \helpref{wxWindow::SetId}{wxwindowsetid},\rtfsp
1071 \helpref{Window identifiers}{windowids}
1072
1073
1074 \membersection{wxWindow::GetLabel}\label{wxwindowgetlabel}
1075
1076 \constfunc{virtual wxString }{GetLabel}{\void}
1077
1078 Generic way of getting a label from any window, for
1079 identification purposes.
1080
1081 \wxheading{Remarks}
1082
1083 The interpretation of this function differs from class to class.
1084 For frames and dialogs, the value returned is the title. For buttons or static text controls, it is
1085 the button text. This function can be useful for meta-programs (such as testing
1086 tools or special-needs access programs) which need to identify windows
1087 by name.
1088
1089 \membersection{wxWindow::GetMaxSize}\label{wxwindowgetmaxsize}
1090
1091 \constfunc{wxSize}{GetMaxSize}{\void}
1092
1093 Returns the maximum size of the window, an indication to the sizer layout mechanism
1094 that this is the maximum possible size.
1095
1096 \membersection{wxWindow::GetMinSize}\label{wxwindowgetminsize}
1097
1098 \constfunc{virtual wxSize}{GetMinSize}{\void}
1099
1100 Returns the minimum size of the window, an indication to the sizer layout mechanism
1101 that this is the minimum required size. It normally just returns the value set
1102 by \helpref{SetMinSize}{wxwindowsetminsize}, but it can be overridden to do the
1103 calculation on demand.
1104
1105 \membersection{wxWindow::GetName}\label{wxwindowgetname}
1106
1107 \constfunc{virtual wxString }{GetName}{\void}
1108
1109 Returns the window's name.
1110
1111 \wxheading{Remarks}
1112
1113 This name is not guaranteed to be unique; it is up to the programmer to supply an appropriate
1114 name in the window constructor or via \helpref{wxWindow::SetName}{wxwindowsetname}.
1115
1116 \wxheading{See also}
1117
1118 \helpref{wxWindow::SetName}{wxwindowsetname}
1119
1120
1121 \membersection{wxWindow::GetParent}\label{wxwindowgetparent}
1122
1123 \constfunc{virtual wxWindow*}{GetParent}{\void}
1124
1125 Returns the parent of the window, or NULL if there is no parent.
1126
1127
1128 \membersection{wxWindow::GetPosition}\label{wxwindowgetposition}
1129
1130 \constfunc{virtual void}{GetPosition}{\param{int* }{x}, \param{int* }{y}}
1131
1132 \constfunc{wxPoint}{GetPosition}{\void}
1133
1134 This gets the position of the window in pixels, relative to the parent window
1135 for the child windows or relative to the display origin for the top level
1136 windows.
1137
1138 \wxheading{Parameters}
1139
1140 \docparam{x}{Receives the x position of the window if non-\NULL.}
1141
1142 \docparam{y}{Receives the y position of the window if non-\NULL.}
1143
1144 \pythonnote{In place of a single overloaded method name, wxPython
1145 implements the following methods:\par
1146 \indented{2cm}{\begin{twocollist}
1147 \twocolitem{{\bf GetPosition()}}{Returns a wxPoint}
1148 \twocolitem{{\bf GetPositionTuple()}}{Returns a tuple (x, y)}
1149 \end{twocollist}}
1150 }
1151
1152 \perlnote{In wxPerl there are two methods instead of a single overloaded
1153 method:\par
1154 \indented{2cm}{\begin{twocollist}
1155 \twocolitem{{\bf GetPosition()}}{Returns a Wx::Point}
1156 \twocolitem{{\bf GetPositionXY()}}{Returns a 2-element list
1157 {\tt ( x, y )}}
1158 \end{twocollist}
1159 }}
1160
1161
1162 \wxheading{See also}
1163
1164 \helpref{GetScreenPosition}{wxwindowgetscreenposition}
1165
1166
1167 \membersection{wxWindow::GetRect}\label{wxwindowgetrect}
1168
1169 \constfunc{virtual wxRect}{GetRect}{\void}
1170
1171 Returns the size and position of the window as a \helpref{wxRect}{wxrect} object.
1172
1173 \wxheading{See also}
1174
1175 \helpref{GetScreenRect}{wxwindowgetscreenrect}
1176
1177
1178 \membersection{wxWindow::GetScreenPosition}\label{wxwindowgetscreenposition}
1179
1180 \constfunc{virtual void}{GetScreenPosition}{\param{int* }{x}, \param{int* }{y}}
1181
1182 \constfunc{wxPoint}{GetScreenPosition}{\void}
1183
1184 Returns the window position in screen coordinates, whether the window is a
1185 child window or a top level one.
1186
1187 \wxheading{Parameters}
1188
1189 \docparam{x}{Receives the x position of the window on the screen if non-\NULL.}
1190
1191 \docparam{y}{Receives the y position of the window on the screen if non-\NULL.}
1192
1193 \wxheading{See also}
1194
1195 \helpref{GetPosition}{wxwindowgetposition}
1196
1197
1198 \membersection{wxWindow::GetScreenRect}\label{wxwindowgetscreenrect}
1199
1200 \constfunc{virtual wxRect}{GetScreenRect}{\void}
1201
1202 Returns the size and position of the window on the screen as a
1203 \helpref{wxRect}{wxrect} object.
1204
1205 \wxheading{See also}
1206
1207 \helpref{GetRect}{wxwindowgetrect}
1208
1209
1210 \membersection{wxWindow::GetScrollPos}\label{wxwindowgetscrollpos}
1211
1212 \func{virtual int}{GetScrollPos}{\param{int }{orientation}}
1213
1214 Returns the built-in scrollbar position.
1215
1216 \wxheading{See also}
1217
1218 See \helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar}
1219
1220
1221 \membersection{wxWindow::GetScrollRange}\label{wxwindowgetscrollrange}
1222
1223 \func{virtual int}{GetScrollRange}{\param{int }{orientation}}
1224
1225 Returns the built-in scrollbar range.
1226
1227 \wxheading{See also}
1228
1229 \helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar}
1230
1231
1232 \membersection{wxWindow::GetScrollThumb}\label{wxwindowgetscrollthumb}
1233
1234 \func{virtual int}{GetScrollThumb}{\param{int }{orientation}}
1235
1236 Returns the built-in scrollbar thumb size.
1237
1238 \wxheading{See also}
1239
1240 \helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar}
1241
1242
1243 \membersection{wxWindow::GetSize}\label{wxwindowgetsize}
1244
1245 \constfunc{void}{GetSize}{\param{int* }{width}, \param{int* }{height}}
1246
1247 \constfunc{wxSize}{GetSize}{\void}
1248
1249 This gets the size of the entire window in pixels,
1250 including title bar, border, scrollbars, etc.
1251
1252 \wxheading{Parameters}
1253
1254 \docparam{width}{Receives the window width.}
1255
1256 \docparam{height}{Receives the window height.}
1257
1258 \pythonnote{In place of a single overloaded method name, wxPython
1259 implements the following methods:\par
1260 \indented{2cm}{\begin{twocollist}
1261 \twocolitem{{\bf GetSize()}}{Returns a wxSize}
1262 \twocolitem{{\bf GetSizeTuple()}}{Returns a 2-tuple (width, height)}
1263 \end{twocollist}}
1264 }
1265
1266 \perlnote{In wxPerl there are two methods instead of a single overloaded
1267 method:\par
1268 \indented{2cm}{\begin{twocollist}
1269 \twocolitem{{\bf GetSize()}}{Returns a Wx::Size}
1270 \twocolitem{{\bf GetSizeWH()}}{Returns a 2-element list
1271 {\tt ( width, height )}}
1272 \end{twocollist}
1273 }}
1274
1275 \wxheading{See also}
1276
1277 \helpref{GetClientSize}{wxwindowgetclientsize},\rtfsp
1278 \helpref{GetVirtualSize}{wxwindowgetvirtualsize}
1279
1280
1281 \membersection{wxWindow::GetSizer}\label{wxwindowgetsizer}
1282
1283 \constfunc{wxSizer *}{GetSizer}{\void}
1284
1285 Return the sizer associated with the window by a previous call to
1286 \helpref{SetSizer()}{wxwindowsetsizer} or {\tt NULL}.
1287
1288
1289 \membersection{wxWindow::GetTextExtent}\label{wxwindowgettextextent}
1290
1291 \constfunc{virtual void}{GetTextExtent}{\param{const wxString\& }{string}, \param{int* }{x}, \param{int* }{y},
1292 \param{int* }{descent = NULL}, \param{int* }{externalLeading = NULL},
1293 \param{const wxFont* }{font = NULL}, \param{bool}{ use16 = {\tt false}}}
1294
1295 Gets the dimensions of the string as it would be drawn on the
1296 window with the currently selected font.
1297
1298 \wxheading{Parameters}
1299
1300 \docparam{string}{String whose extent is to be measured.}
1301
1302 \docparam{x}{Return value for width.}
1303
1304 \docparam{y}{Return value for height.}
1305
1306 \docparam{descent}{Return value for descent (optional).}
1307
1308 \docparam{externalLeading}{Return value for external leading (optional).}
1309
1310 \docparam{font}{Font to use instead of the current window font (optional).}
1311
1312 \docparam{use16}{If {\tt true}, {\it string} contains 16-bit characters. The default is {\tt false}.}
1313
1314 \pythonnote{In place of a single overloaded method name, wxPython
1315 implements the following methods:\par
1316 \indented{2cm}{\begin{twocollist}
1317 \twocolitem{{\bf GetTextExtent(string)}}{Returns a 2-tuple, (width, height)}
1318 \twocolitem{{\bf GetFullTextExtent(string, font=NULL)}}{Returns a
1319 4-tuple, (width, height, descent, externalLeading) }
1320 \end{twocollist}}
1321 }
1322
1323 \perlnote{In wxPerl this method takes only the {\tt string} and optionally
1324 {\tt font} parameters, and returns a 4-element list
1325 {\tt ( x, y, descent, externalLeading )}.}
1326
1327
1328 \membersection{wxWindow::GetToolTip}\label{wxwindowgettooltip}
1329
1330 \constfunc{wxToolTip*}{GetToolTip}{\void}
1331
1332 Get the associated tooltip or NULL if none.
1333
1334
1335 \membersection{wxWindow::GetUpdateRegion}\label{wxwindowgetupdateregion}
1336
1337 \constfunc{virtual wxRegion}{GetUpdateRegion}{\void}
1338
1339 Returns the region specifying which parts of the window have been damaged. Should
1340 only be called within an \helpref{wxPaintEvent}{wxpaintevent} handler.
1341
1342 \wxheading{See also}
1343
1344 \helpref{wxRegion}{wxregion},\rtfsp
1345 \helpref{wxRegionIterator}{wxregioniterator}
1346
1347
1348 \membersection{wxWindow::GetValidator}\label{wxwindowgetvalidator}
1349
1350 \constfunc{wxValidator*}{GetValidator}{\void}
1351
1352 Returns a pointer to the current validator for the window, or NULL if there is none.
1353
1354
1355 \membersection{wxWindow::GetVirtualSize}\label{wxwindowgetvirtualsize}
1356
1357 \constfunc{void}{GetVirtualSize}{\param{int* }{width}, \param{int* }{height}}
1358
1359 \constfunc{wxSize}{GetVirtualSize}{\void}
1360
1361 This gets the virtual size of the window in pixels. By default it
1362 returns the client size of the window, but after a call to
1363 \helpref{SetVirtualSize}{wxwindowsetvirtualsize} it will return
1364 that size.
1365
1366 \wxheading{Parameters}
1367
1368 \docparam{width}{Receives the window virtual width.}
1369
1370 \docparam{height}{Receives the window virtual height.}
1371
1372 \helpref{GetSize}{wxwindowgetsize},\rtfsp
1373 \helpref{GetClientSize}{wxwindowgetclientsize}
1374
1375
1376 \membersection{wxWindow::GetWindowBorderSize}\label{wxwindowgetwindowbordersize}
1377
1378 \constfunc{wxSize}{GetWindowBorderSize}{\void}
1379
1380 Returns the size of the left/right and top/bottom borders of this window in x
1381 and y components of the result respectively.
1382
1383
1384 \membersection{wxWindow::GetWindowStyleFlag}\label{wxwindowgetwindowstyleflag}
1385
1386 \constfunc{long}{GetWindowStyleFlag}{\void}
1387
1388 Gets the window style that was passed to the constructor or {\bf Create}
1389 method. {\bf GetWindowStyle()} is another name for the same function.
1390
1391
1392 \membersection{wxWindow::GetWindowVariant}\label{wxwindowgetwindowvariant}
1393
1394 \constfunc{wxWindowVariant}{GetWindowVariant}{\void}
1395
1396 Returns the value previously passed to
1397 \helpref{wxWindow::SetWindowVariant}{wxwindowsetwindowvariant}.
1398
1399
1400 \membersection{wxWindow::HasCapture}\label{wxwindowhascapture}
1401
1402 \constfunc{virtual bool}{HasCapture}{\void}
1403
1404 Returns {\tt true} if this window has the current mouse capture.
1405
1406 \wxheading{See also}
1407
1408 \helpref{wxWindow::CaptureMouse}{wxwindowcapturemouse},
1409 \helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse},
1410 \helpref{wxMouseCaptureLostEvent}{wxmousecapturelostevent}
1411 \helpref{wxMouseCaptureChangedEvent}{wxmousecapturechangedevent}
1412
1413
1414 \membersection{wxWindow::HasFlag}\label{wxwindowhasflag}
1415
1416 \constfunc{bool}{HasFlag}{\param{int }{flag}}
1417
1418 Returns \texttt{true} if the window has the given \arg{flag} bit set.
1419
1420
1421 \membersection{wxWindow::HasMultiplePages}\label{wxwindowhasmultiplepages}
1422
1423 \constfunc{virtual bool}{HasMultiplePages}{\void}
1424
1425 This method should be overridden to return \texttt{true} if this window has
1426 multiple pages. All standard class with multiple pages such as
1427 \helpref{wxNotebook}{wxnotebook}, \helpref{wxListbook}{wxlistbook} and
1428 \helpref{wxTreebook}{wxtreebook} already override it to return \texttt{true}
1429 and user-defined classes with similar behaviour should do it as well to allow
1430 the library to handle such windows appropriately.
1431
1432
1433 \membersection{wxWindow::HasScrollbar}\label{wxwindowhasscrollbar}
1434
1435 \constfunc{virtual bool}{HasScrollbar}{\param{int }{orient}}
1436
1437 Returns {\tt true} if this window has a scroll bar for this orientation.
1438
1439 \wxheading{Parameters}
1440
1441 \docparam{orient}{Orientation to check, either {\tt wxHORIZONTAL} or {\tt wxVERTICAL}.}
1442
1443
1444 \membersection{wxWindow::HasTransparentBackground}\label{wxwindowhastransparentbackground}
1445
1446 \constfunc{virtual bool}{HasTransparentBackground}{\void}
1447
1448 Returns \true if this window background is transparent (as, for example, for
1449 wxStaticText) and should show the parent window background.
1450
1451 This method is mostly used internally by the library itself and you normally
1452 shouldn't have to call it. You may, however, have to override it in your
1453 wxWindow-derived class to ensure that background is painted correctly.
1454
1455
1456 \membersection{wxWindow::Hide}\label{wxwindowhide}
1457
1458 \func{bool}{Hide}{\void}
1459
1460 Equivalent to calling \helpref{Show}{wxwindowshow}({\tt false}).
1461
1462
1463 \membersection{wxWindow::InheritAttributes}\label{wxwindowinheritattributes}
1464
1465 \func{void}{InheritAttributes}{\void}
1466
1467 This function is (or should be, in case of custom controls) called during
1468 window creation to intelligently set up the window visual attributes, that is
1469 the font and the foreground and background colours.
1470
1471 By ``intelligently'' the following is meant: by default, all windows use their
1472 own \helpref{default}{wxwindowgetclassdefaultattributes} attributes. However
1473 if some of the parents attributes are explicitly (that is, using
1474 \helpref{SetFont}{wxwindowsetfont} and not
1475 \helpref{SetOwnFont}{wxwindowsetownfont}) changed \emph{and} if the
1476 corresponding attribute hadn't been explicitly set for this window itself,
1477 then this window takes the same value as used by the parent. In addition, if
1478 the window overrides \helpref{ShouldInheritColours}{wxwindowshouldinheritcolours}
1479 to return \false, the colours will not be changed no matter what and only the
1480 font might.
1481
1482 This rather complicated logic is necessary in order to accommodate the
1483 different usage scenarios. The most common one is when all default attributes
1484 are used and in this case, nothing should be inherited as in modern GUIs
1485 different controls use different fonts (and colours) than their siblings so
1486 they can't inherit the same value from the parent. However it was also deemed
1487 desirable to allow to simply change the attributes of all children at once by
1488 just changing the font or colour of their common parent, hence in this case we
1489 do inherit the parents attributes.
1490
1491
1492 \membersection{wxWindow::InitDialog}\label{wxwindowinitdialog}
1493
1494 \func{void}{InitDialog}{\void}
1495
1496 Sends an {\tt wxEVT\_INIT\_DIALOG} event, whose handler usually transfers data
1497 to the dialog via validators.
1498
1499
1500 \membersection{wxWindow::InvalidateBestSize}\label{wxwindowinvalidatebestsize}
1501
1502 \func{void}{InvalidateBestSize}{\void}
1503
1504 Resets the cached best size value so it will be recalculated the next time it is needed.
1505
1506
1507 \membersection{wxWindow::IsDoubleBuffered}\label{wxwindowisdoublebuffered}
1508
1509 \constfunc{virtual bool}{IsDoubleBuffered}{\void}
1510
1511 Returns \true if the window contents is double-buffered by the system, i.e. if
1512 any drawing done on the window is really done on a temporary backing surface
1513 and transferred to the screen all at once later.
1514
1515 \wxheading{See also}
1516
1517 \helpref{wxBufferedDC}{wxbuffereddc}
1518
1519
1520 \membersection{wxWindow::IsEnabled}\label{wxwindowisenabled}
1521
1522 \constfunc{virtual bool}{IsEnabled}{\void}
1523
1524 Returns {\tt true} if the window is enabled for input, {\tt false} otherwise.
1525
1526 \wxheading{See also}
1527
1528 \helpref{wxWindow::Enable}{wxwindowenable}
1529
1530
1531 \membersection{wxWindow::IsExposed}\label{wxwindowisexposed}
1532
1533 \constfunc{bool}{IsExposed}{\param{int }{x}, \param{int }{y}}
1534
1535 \constfunc{bool}{IsExposed}{\param{wxPoint }{\&pt}}
1536
1537 \constfunc{bool}{IsExposed}{\param{int }{x}, \param{int }{y}, \param{int }{w}, \param{int }{h}}
1538
1539 \constfunc{bool}{IsExposed}{\param{wxRect }{\&rect}}
1540
1541 Returns {\tt true} if the given point or rectangle area has been exposed since the
1542 last repaint. Call this in an paint event handler to optimize redrawing by
1543 only redrawing those areas, which have been exposed.
1544
1545 \pythonnote{In place of a single overloaded method name, wxPython
1546 implements the following methods:\par
1547 \indented{2cm}{\begin{twocollist}
1548 \twocolitem{{\bf IsExposed(x,y, w=0,h=0)}}{}
1549 \twocolitem{{\bf IsExposedPoint(pt)}}{}
1550 \twocolitem{{\bf IsExposedRect(rect)}}{}
1551 \end{twocollist}}}
1552
1553
1554 \membersection{wxWindow::IsFrozen}\label{wxwindowisfrozen}
1555
1556 \constfunc{virtual bool}{IsFrozen}{\void}
1557
1558 Returns \true if the window is currently frozen by a call to
1559 \helpref{Freeze()}{wxwindowfreeze}.
1560
1561 \wxheading{See also}
1562
1563 \helpref{Thaw()}{wxwindowthaw}
1564
1565
1566 \membersection{wxWindow::IsRetained}\label{wxwindowisretained}
1567
1568 \constfunc{virtual bool}{IsRetained}{\void}
1569
1570 Returns {\tt true} if the window is retained, {\tt false} otherwise.
1571
1572 \wxheading{Remarks}
1573
1574 Retained windows are only available on X platforms.
1575
1576
1577 \membersection{wxWindow::IsShown}\label{wxwindowisshown}
1578
1579 \constfunc{virtual bool}{IsShown}{\void}
1580
1581 Returns {\tt true} if the window is shown, {\tt false} if it has been hidden.
1582
1583 \wxheading{See also}
1584
1585 \helpref{wxWindow::IsShownOnScreen}{wxwindowisshownonscreen}
1586
1587
1588 \membersection{wxWindow::IsShownOnScreen}\label{wxwindowisshownonscreen}
1589
1590 \constfunc{virtual bool}{IsShownOnScreen}{\void}
1591
1592 Returns {\tt true} if the window is physically visible on the screen, i.e. it
1593 is shown and all its parents up to the toplevel window are shown as well.
1594
1595 \wxheading{See also}
1596
1597 \helpref{wxWindow::IsShown}{wxwindowisshown}
1598
1599
1600 \membersection{wxWindow::IsTopLevel}\label{wxwindowistoplevel}
1601
1602 \constfunc{bool}{IsTopLevel}{\void}
1603
1604 Returns {\tt true} if the given window is a top-level one. Currently all frames and
1605 dialogs are considered to be top-level windows (even if they have a parent
1606 window).
1607
1608
1609 \membersection{wxWindow::Layout}\label{wxwindowlayout}
1610
1611 \func{void}{Layout}{\void}
1612
1613 Invokes the constraint-based layout algorithm or the sizer-based algorithm
1614 for this window.
1615
1616 See \helpref{wxWindow::SetAutoLayout}{wxwindowsetautolayout}: when auto
1617 layout is on, this function gets called automatically when the window is resized.
1618
1619
1620 \membersection{wxWindow::LineDown}\label{wxwindowlinedown}
1621
1622 This is just a wrapper for \helpref{ScrollLines}{wxwindowscrolllines}$(1)$.
1623
1624
1625 \membersection{wxWindow::LineUp}\label{wxwindowlineup}
1626
1627 This is just a wrapper for \helpref{ScrollLines}{wxwindowscrolllines}$(-1)$.
1628
1629
1630 \membersection{wxWindow::Lower}\label{wxwindowlower}
1631
1632 \func{void}{Lower}{\void}
1633
1634 Lowers the window to the bottom of the window hierarchy (z-order).
1635
1636 \wxheading{See also}
1637
1638 \helpref{Raise}{wxwindowraise}
1639
1640
1641 \membersection{wxWindow::MakeModal}\label{wxwindowmakemodal}
1642
1643 \func{virtual void}{MakeModal}{\param{bool }{flag}}
1644
1645 Disables all other windows in the application so that
1646 the user can only interact with this window.
1647
1648 \wxheading{Parameters}
1649
1650 \docparam{flag}{If {\tt true}, this call disables all other windows in the application so that
1651 the user can only interact with this window. If {\tt false}, the effect is reversed.}
1652
1653
1654 \membersection{wxWindow::Move}\label{wxwindowmove}
1655
1656 \func{void}{Move}{\param{int}{ x}, \param{int}{ y}}
1657
1658 \func{void}{Move}{\param{const wxPoint\&}{ pt}}
1659
1660 Moves the window to the given position.
1661
1662 \wxheading{Parameters}
1663
1664 \docparam{x}{Required x position.}
1665
1666 \docparam{y}{Required y position.}
1667
1668 \docparam{pt}{\helpref{wxPoint}{wxpoint} object representing the position.}
1669
1670 \wxheading{Remarks}
1671
1672 Implementations of SetSize can also implicitly implement the
1673 wxWindow::Move function, which is defined in the base wxWindow class
1674 as the call:
1675
1676 \begin{verbatim}
1677 SetSize(x, y, wxDefaultCoord, wxDefaultCoord, wxSIZE_USE_EXISTING);
1678 \end{verbatim}
1679
1680 \wxheading{See also}
1681
1682 \helpref{wxWindow::SetSize}{wxwindowsetsize}
1683
1684 \pythonnote{In place of a single overloaded method name, wxPython
1685 implements the following methods:\par
1686 \indented{2cm}{\begin{twocollist}
1687 \twocolitem{{\bf Move(point)}}{Accepts a wxPoint}
1688 \twocolitem{{\bf MoveXY(x, y)}}{Accepts a pair of integers}
1689 \end{twocollist}}
1690 }
1691
1692
1693 \membersection{wxWindow::MoveAfterInTabOrder}\label{wxwindowmoveafterintaborder}
1694
1695 \func{void}{MoveAfterInTabOrder}{\param{wxWindow *}{win}}
1696
1697 Moves this window in the tab navigation order after the specified \arg{win}.
1698 This means that when the user presses \texttt{TAB} key on that other window,
1699 the focus switches to this window.
1700
1701 Default tab order is the same as creation order, this function and
1702 \helpref{MoveBeforeInTabOrder()}{wxwindowmovebeforeintaborder} allow to change
1703 it after creating all the windows.
1704
1705 \wxheading{Parameters}
1706
1707 \docparam{win}{A sibling of this window which should precede it in tab order,
1708 must not be NULL}
1709
1710
1711 \membersection{wxWindow::MoveBeforeInTabOrder}\label{wxwindowmovebeforeintaborder}
1712
1713 \func{void}{MoveBeforeInTabOrder}{\param{wxWindow *}{win}}
1714
1715 Same as \helpref{MoveAfterInTabOrder}{wxwindowmoveafterintaborder} except that
1716 it inserts this window just before \arg{win} instead of putting it right after
1717 it.
1718
1719
1720 \membersection{wxWindow::Navigate}\label{wxwindownavigate}
1721
1722 \func{bool}{Navigate}{\param{int}{ flags = wxNavigationKeyEvent::IsForward}}
1723
1724 Does keyboard navigation from this window to another, by sending
1725 a wxNavigationKeyEvent.
1726
1727 \wxheading{Parameters}
1728
1729 \docparam{flags}{A combination of wxNavigationKeyEvent::IsForward and wxNavigationKeyEvent::WinChange.}
1730
1731 \wxheading{Remarks}
1732
1733 You may wish to call this from a text control custom keypress handler to do the default
1734 navigation behaviour for the tab key, since the standard default behaviour for
1735 a multiline text control with the wxTE\_PROCESS\_TAB style is to insert a tab
1736 and not navigate to the next control.
1737
1738 %% VZ: wxWindow::OnXXX() functions should not be documented but I'm leaving
1739 %% the old docs here in case we want to move any still needed bits to
1740 %% the right location (i.e. probably the corresponding events docs)
1741 %%
1742 %% \membersection{wxWindow::OnActivate}\label{wxwindowonactivate}
1743 %%
1744 %% \func{void}{OnActivate}{\param{wxActivateEvent\&}{ event}}
1745 %%
1746 %% Called when a window is activated or deactivated.
1747 %%
1748 %% \wxheading{Parameters}
1749 %%
1750 %% \docparam{event}{Object containing activation information.}
1751 %%
1752 %% \wxheading{Remarks}
1753 %%
1754 %% If the window is being activated, \helpref{wxActivateEvent::GetActive}{wxactivateeventgetactive} returns {\tt true},
1755 %% otherwise it returns {\tt false} (it is being deactivated).
1756 %%
1757 %% \wxheading{See also}
1758 %%
1759 %% \helpref{wxActivateEvent}{wxactivateevent},\rtfsp
1760 %% \helpref{Event handling overview}{eventhandlingoverview}
1761 %%
1762 %% \membersection{wxWindow::OnChar}\label{wxwindowonchar}
1763 %%
1764 %% \func{void}{OnChar}{\param{wxKeyEvent\&}{ event}}
1765 %%
1766 %% Called when the user has pressed a key that is not a modifier (SHIFT, CONTROL or ALT).
1767 %%
1768 %% \wxheading{Parameters}
1769 %%
1770 %% \docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
1771 %% details about this class.}
1772 %%
1773 %% \wxheading{Remarks}
1774 %%
1775 %% This member function is called in response to a keypress. To intercept this event,
1776 %% use the EVT\_CHAR macro in an event table definition. Your {\bf OnChar} handler may call this
1777 %% default function to achieve default keypress functionality.
1778 %%
1779 %% Note that the ASCII values do not have explicit key codes: they are passed as ASCII
1780 %% values.
1781 %%
1782 %% Note that not all keypresses can be intercepted this way. If you wish to intercept modifier
1783 %% keypresses, then you will need to use \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown} or
1784 %% \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup}.
1785 %%
1786 %% Most, but not all, windows allow keypresses to be intercepted.
1787 %%
1788 %% {\bf Tip:} be sure to call {\tt event.Skip()} for events that you don't process in this function,
1789 %% otherwise menu shortcuts may cease to work under Windows.
1790 %%
1791 %% \wxheading{See also}
1792 %%
1793 %% \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown}, \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup},\rtfsp
1794 %% \helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
1795 %% \helpref{Event handling overview}{eventhandlingoverview}
1796 %%
1797 %% \membersection{wxWindow::OnCharHook}\label{wxwindowoncharhook}
1798 %%
1799 %% \func{void}{OnCharHook}{\param{wxKeyEvent\&}{ event}}
1800 %%
1801 %% This member is called to allow the window to intercept keyboard events
1802 %% before they are processed by child windows.
1803 %%
1804 %% \wxheading{Parameters}
1805 %%
1806 %% \docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
1807 %% details about this class.}
1808 %%
1809 %% \wxheading{Remarks}
1810 %%
1811 %% This member function is called in response to a keypress, if the window is active. To intercept this event,
1812 %% use the EVT\_CHAR\_HOOK macro in an event table definition. If you do not process a particular
1813 %% keypress, call \helpref{wxEvent::Skip}{wxeventskip} to allow default processing.
1814 %%
1815 %% An example of using this function is in the implementation of escape-character processing for wxDialog,
1816 %% where pressing ESC dismisses the dialog by {\bf OnCharHook} 'forging' a cancel button press event.
1817 %%
1818 %% Note that the ASCII values do not have explicit key codes: they are passed as ASCII
1819 %% values.
1820 %%
1821 %% This function is only relevant to top-level windows (frames and dialogs), and under
1822 %% Windows only. Under GTK the normal EVT\_CHAR\_ event has the functionality, i.e.
1823 %% you can intercept it, and if you don't call \helpref{wxEvent::Skip}{wxeventskip}
1824 %% the window won't get the event.
1825 %%
1826 %% \wxheading{See also}
1827 %%
1828 %% \helpref{wxKeyEvent}{wxkeyevent},\rtfsp
1829 %% \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
1830 %% %% GD: OnXXX functions are not documented
1831 %% %%\helpref{wxApp::OnCharHook}{wxapponcharhook},\rtfsp
1832 %% \helpref{Event handling overview}{eventhandlingoverview}
1833 %%
1834 %% \membersection{wxWindow::OnCommand}\label{wxwindowoncommand}
1835 %%
1836 %% \func{virtual void}{OnCommand}{\param{wxEvtHandler\& }{object}, \param{wxCommandEvent\& }{event}}
1837 %%
1838 %% This virtual member function is called if the control does not handle the command event.
1839 %%
1840 %% \wxheading{Parameters}
1841 %%
1842 %% \docparam{object}{Object receiving the command event.}
1843 %%
1844 %% \docparam{event}{Command event}
1845 %%
1846 %% \wxheading{Remarks}
1847 %%
1848 %% This virtual function is provided mainly for backward compatibility. You can also intercept commands
1849 %% from child controls by using an event table, with identifiers or identifier ranges to identify
1850 %% the control(s) in question.
1851 %%
1852 %% \wxheading{See also}
1853 %%
1854 %% \helpref{wxCommandEvent}{wxcommandevent},\rtfsp
1855 %% \helpref{Event handling overview}{eventhandlingoverview}
1856 %%
1857 %% \membersection{wxWindow::OnClose}\label{wxwindowonclose}
1858 %%
1859 %% \func{virtual bool}{OnClose}{\void}
1860 %%
1861 %% Called when the user has tried to close a a frame
1862 %% or dialog box using the window manager (X) or system menu (Windows).
1863 %%
1864 %% {\bf Note:} This is an obsolete function.
1865 %% It is superseded by the \helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow} event
1866 %% handler.
1867 %%
1868 %% \wxheading{Return value}
1869 %%
1870 %% If {\tt true} is returned by OnClose, the window will be deleted by the system, otherwise the
1871 %% attempt will be ignored. Do not delete the window from within this handler, although
1872 %% you may delete other windows.
1873 %%
1874 %% \wxheading{See also}
1875 %%
1876 %% \helpref{Window deletion overview}{windowdeletionoverview},\rtfsp
1877 %% \helpref{wxWindow::Close}{wxwindowclose},\rtfsp
1878 %% \helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow},\rtfsp
1879 %% \helpref{wxCloseEvent}{wxcloseevent}
1880 %%
1881 %% \membersection{wxWindow::OnKeyDown}\label{wxwindowonkeydown}
1882 %%
1883 %% \func{void}{OnKeyDown}{\param{wxKeyEvent\&}{ event}}
1884 %%
1885 %% Called when the user has pressed a key, before it is translated into an ASCII value using other
1886 %% modifier keys that might be pressed at the same time.
1887 %%
1888 %% \wxheading{Parameters}
1889 %%
1890 %% \docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
1891 %% details about this class.}
1892 %%
1893 %% \wxheading{Remarks}
1894 %%
1895 %% This member function is called in response to a key down event. To intercept this event,
1896 %% use the EVT\_KEY\_DOWN macro in an event table definition. Your {\bf OnKeyDown} handler may call this
1897 %% default function to achieve default keypress functionality.
1898 %%
1899 %% Note that not all keypresses can be intercepted this way. If you wish to intercept special
1900 %% keys, such as shift, control, and function keys, then you will need to use \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown} or
1901 %% \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup}.
1902 %%
1903 %% Most, but not all, windows allow keypresses to be intercepted.
1904 %%
1905 %% {\bf Tip:} be sure to call {\tt event.Skip()} for events that you don't process in this function,
1906 %% otherwise menu shortcuts may cease to work under Windows.
1907 %%
1908 %% \wxheading{See also}
1909 %%
1910 %% \helpref{wxWindow::OnChar}{wxwindowonchar}, \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup},\rtfsp
1911 %% \helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
1912 %% \helpref{Event handling overview}{eventhandlingoverview}
1913 %%
1914 %% \membersection{wxWindow::OnKeyUp}\label{wxwindowonkeyup}
1915 %%
1916 %% \func{void}{OnKeyUp}{\param{wxKeyEvent\&}{ event}}
1917 %%
1918 %% Called when the user has released a key.
1919 %%
1920 %% \wxheading{Parameters}
1921 %%
1922 %% \docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
1923 %% details about this class.}
1924 %%
1925 %% \wxheading{Remarks}
1926 %%
1927 %% This member function is called in response to a key up event. To intercept this event,
1928 %% use the EVT\_KEY\_UP macro in an event table definition. Your {\bf OnKeyUp} handler may call this
1929 %% default function to achieve default keypress functionality.
1930 %%
1931 %% Note that not all keypresses can be intercepted this way. If you wish to intercept special
1932 %% keys, such as shift, control, and function keys, then you will need to use \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown} or
1933 %% \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup}.
1934 %%
1935 %% Most, but not all, windows allow key up events to be intercepted.
1936 %%
1937 %% \wxheading{See also}
1938 %%
1939 %% \helpref{wxWindow::OnChar}{wxwindowonchar}, \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown},\rtfsp
1940 %% \helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
1941 %% \helpref{Event handling overview}{eventhandlingoverview}
1942 %%
1943 %% \membersection{wxWindow::OnInitDialog}\label{wxwindowoninitdialog}
1944 %%
1945 %% \func{void}{OnInitDialog}{\param{wxInitDialogEvent\&}{ event}}
1946 %%
1947 %% Default handler for the wxEVT\_INIT\_DIALOG event. Calls \helpref{wxWindow::TransferDataToWindow}{wxwindowtransferdatatowindow}.
1948 %%
1949 %% \wxheading{Parameters}
1950 %%
1951 %% \docparam{event}{Dialog initialisation event.}
1952 %%
1953 %% \wxheading{Remarks}
1954 %%
1955 %% Gives the window the default behaviour of transferring data to child controls via
1956 %% the validator that each control has.
1957 %%
1958 %% \wxheading{See also}
1959 %%
1960 %% \helpref{wxValidator}{wxvalidator}, \helpref{wxWindow::TransferDataToWindow}{wxwindowtransferdatatowindow}
1961 %%
1962 %% \membersection{wxWindow::OnMenuHighlight}\label{wxwindowonmenuhighlight}
1963 %%
1964 %% \func{void}{OnMenuHighlight}{\param{wxMenuEvent\& }{event}}
1965 %%
1966 %% Called when a menu select is received from a menu bar: that is, the
1967 %% mouse cursor is over a menu item, but the left mouse button has not been
1968 %% pressed.
1969 %%
1970 %% \wxheading{Parameters}
1971 %%
1972 %% \docparam{event}{The menu highlight event. For more information, see \helpref{wxMenuEvent}{wxmenuevent}.}
1973 %%
1974 %% \wxheading{Remarks}
1975 %%
1976 %% You can choose any member function to receive
1977 %% menu select events, using the EVT\_MENU\_HIGHLIGHT macro for individual menu items or EVT\_MENU\_HIGHLIGHT\_ALL macro
1978 %% for all menu items.
1979 %%
1980 %% The default implementation for \helpref{wxFrame::OnMenuHighlight}{wxframeonmenuhighlight} displays help
1981 %% text in the first field of the status bar.
1982 %%
1983 %% This function was known as {\bf OnMenuSelect} in earlier versions of wxWidgets, but this was confusing
1984 %% since a selection is normally a left-click action.
1985 %%
1986 %% \wxheading{See also}
1987 %%
1988 %% \helpref{wxMenuEvent}{wxmenuevent},\rtfsp
1989 %% \helpref{Event handling overview}{eventhandlingoverview}
1990 %%
1991 %%
1992 %% \membersection{wxWindow::OnMouseEvent}\label{wxwindowonmouseevent}
1993 %%
1994 %% \func{void}{OnMouseEvent}{\param{wxMouseEvent\&}{ event}}
1995 %%
1996 %% Called when the user has initiated an event with the
1997 %% mouse.
1998 %%
1999 %% \wxheading{Parameters}
2000 %%
2001 %% \docparam{event}{The mouse event. See \helpref{wxMouseEvent}{wxmouseevent} for
2002 %% more details.}
2003 %%
2004 %% \wxheading{Remarks}
2005 %%
2006 %% Most, but not all, windows respond to this event.
2007 %%
2008 %% To intercept this event, use the EVT\_MOUSE\_EVENTS macro in an event table definition, or individual
2009 %% mouse event macros such as EVT\_LEFT\_DOWN.
2010 %%
2011 %% \wxheading{See also}
2012 %%
2013 %% \helpref{wxMouseEvent}{wxmouseevent},\rtfsp
2014 %% \helpref{Event handling overview}{eventhandlingoverview}
2015 %%
2016 %% \membersection{wxWindow::OnMove}\label{wxwindowonmove}
2017 %%
2018 %% \func{void}{OnMove}{\param{wxMoveEvent\& }{event}}
2019 %%
2020 %% Called when a window is moved.
2021 %%
2022 %% \wxheading{Parameters}
2023 %%
2024 %% \docparam{event}{The move event. For more information, see \helpref{wxMoveEvent}{wxmoveevent}.}
2025 %%
2026 %% \wxheading{Remarks}
2027 %%
2028 %% Use the EVT\_MOVE macro to intercept move events.
2029 %%
2030 %% \wxheading{Remarks}
2031 %%
2032 %% Not currently implemented.
2033 %%
2034 %% \wxheading{See also}
2035 %%
2036 %% \helpref{wxMoveEvent}{wxmoveevent},\rtfsp
2037 %% \helpref{wxFrame::OnSize}{wxframeonsize},\rtfsp
2038 %% \helpref{Event handling overview}{eventhandlingoverview}
2039 %%
2040 %% \membersection{wxWindow::OnPaint}\label{wxwindowonpaint}
2041 %%
2042 %% \func{void}{OnPaint}{\param{wxPaintEvent\& }{event}}
2043 %%
2044 %% Sent to the event handler when the window must be refreshed.
2045 %%
2046 %% \wxheading{Parameters}
2047 %%
2048 %% \docparam{event}{Paint event. For more information, see \helpref{wxPaintEvent}{wxpaintevent}.}
2049 %%
2050 %% \wxheading{Remarks}
2051 %%
2052 %% Use the EVT\_PAINT macro in an event table definition to intercept paint events.
2053 %%
2054 %% Note that In a paint event handler, the application must {\it always} create a \helpref{wxPaintDC}{wxpaintdc} object,
2055 %% even if you do not use it. Otherwise, under MS Windows, refreshing for this and other windows will go wrong.
2056 %%
2057 %% For example:
2058 %%
2059 %% \small{%
2060 %% \begin{verbatim}
2061 %% void MyWindow::OnPaint(wxPaintEvent\& event)
2062 %% {
2063 %% wxPaintDC dc(this);
2064 %%
2065 %% DrawMyDocument(dc);
2066 %% }
2067 %% \end{verbatim}
2068 %% }%
2069 %%
2070 %% You can optimize painting by retrieving the rectangles
2071 %% that have been damaged and only repainting these. The rectangles are in
2072 %% terms of the client area, and are unscrolled, so you will need to do
2073 %% some calculations using the current view position to obtain logical,
2074 %% scrolled units.
2075 %%
2076 %% Here is an example of using the \helpref{wxRegionIterator}{wxregioniterator} class:
2077 %%
2078 %% {\small%
2079 %% \begin{verbatim}
2080 %% // Called when window needs to be repainted.
2081 %% void MyWindow::OnPaint(wxPaintEvent\& event)
2082 %% {
2083 %% wxPaintDC dc(this);
2084 %%
2085 %% // Find Out where the window is scrolled to
2086 %% int vbX,vbY; // Top left corner of client
2087 %% GetViewStart(&vbX,&vbY);
2088 %%
2089 %% int vX,vY,vW,vH; // Dimensions of client area in pixels
2090 %% wxRegionIterator upd(GetUpdateRegion()); // get the update rect list
2091 %%
2092 %% while (upd)
2093 %% {
2094 %% vX = upd.GetX();
2095 %% vY = upd.GetY();
2096 %% vW = upd.GetW();
2097 %% vH = upd.GetH();
2098 %%
2099 %% // Alternatively we can do this:
2100 %% // wxRect rect;
2101 %% // upd.GetRect(&rect);
2102 %%
2103 %% // Repaint this rectangle
2104 %% ...some code...
2105 %%
2106 %% upd ++ ;
2107 %% }
2108 %% }
2109 %% \end{verbatim}
2110 %% }%
2111 %%
2112 %% \wxheading{See also}
2113 %%
2114 %% \helpref{wxPaintEvent}{wxpaintevent},\rtfsp
2115 %% \helpref{wxPaintDC}{wxpaintdc},\rtfsp
2116 %% \helpref{Event handling overview}{eventhandlingoverview}
2117 %%
2118 %% \membersection{wxWindow::OnScroll}\label{wxwindowonscroll}
2119 %%
2120 %% \func{void}{OnScroll}{\param{wxScrollWinEvent\& }{event}}
2121 %%
2122 %% Called when a scroll window event is received from one of the window's built-in scrollbars.
2123 %%
2124 %% \wxheading{Parameters}
2125 %%
2126 %% \docparam{event}{Command event. Retrieve the new scroll position by
2127 %% calling \helpref{wxScrollEvent::GetPosition}{wxscrolleventgetposition}, and the
2128 %% scrollbar orientation by calling \helpref{wxScrollEvent::GetOrientation}{wxscrolleventgetorientation}.}
2129 %%
2130 %% \wxheading{Remarks}
2131 %%
2132 %% Note that it is not possible to distinguish between horizontal and vertical scrollbars
2133 %% until the function is executing (you can't have one function for vertical, another
2134 %% for horizontal events).
2135 %%
2136 %% \wxheading{See also}
2137 %%
2138 %% \helpref{wxScrollWinEvent}{wxscrollwinevent},\rtfsp
2139 %% \helpref{Event handling overview}{eventhandlingoverview}
2140 %%
2141 %% \membersection{wxWindow::OnSetFocus}\label{wxwindowonsetfocus}
2142 %%
2143 %% \func{void}{OnSetFocus}{\param{wxFocusEvent\& }{event}}
2144 %%
2145 %% Called when a window's focus is being set.
2146 %%
2147 %% \wxheading{Parameters}
2148 %%
2149 %% \docparam{event}{The focus event. For more information, see \helpref{wxFocusEvent}{wxfocusevent}.}
2150 %%
2151 %% \wxheading{Remarks}
2152 %%
2153 %% To intercept this event, use the macro EVT\_SET\_FOCUS in an event table definition.
2154 %%
2155 %% Most, but not all, windows respond to this event.
2156 %%
2157 %% \wxheading{See also}
2158 %%
2159 %% \helpref{wxFocusEvent}{wxfocusevent}, \helpref{wxWindow::OnKillFocus}{wxwindowonkillfocus},\rtfsp
2160 %% \helpref{Event handling overview}{eventhandlingoverview}
2161 %%
2162 %% \membersection{wxWindow::OnSize}\label{wxwindowonsize}
2163 %%
2164 %% \func{void}{OnSize}{\param{wxSizeEvent\& }{event}}
2165 %%
2166 %% Called when the window has been resized. This is not a virtual function; you should
2167 %% provide your own non-virtual OnSize function and direct size events to it using EVT\_SIZE
2168 %% in an event table definition.
2169 %%
2170 %% \wxheading{Parameters}
2171 %%
2172 %% \docparam{event}{Size event. For more information, see \helpref{wxSizeEvent}{wxsizeevent}.}
2173 %%
2174 %% \wxheading{Remarks}
2175 %%
2176 %% You may wish to use this for frames to resize their child windows as appropriate.
2177 %%
2178 %% Note that the size passed is of
2179 %% the whole window: call \helpref{wxWindow::GetClientSize}{wxwindowgetclientsize} for the area which may be
2180 %% used by the application.
2181 %%
2182 %% When a window is resized, usually only a small part of the window is damaged and you
2183 %% may only need to repaint that area. However, if your drawing depends on the size of the window,
2184 %% you may need to clear the DC explicitly and repaint the whole window. In which case, you
2185 %% may need to call \helpref{wxWindow::Refresh}{wxwindowrefresh} to invalidate the entire window.
2186 %%
2187 %% \wxheading{See also}
2188 %%
2189 %% \helpref{wxSizeEvent}{wxsizeevent},\rtfsp
2190 %% \helpref{Event handling overview}{eventhandlingoverview}
2191 %%
2192 %% \membersection{wxWindow::OnSysColourChanged}\label{wxwindowonsyscolourchanged}
2193 %%
2194 %% \func{void}{OnSysColourChanged}{\param{wxOnSysColourChangedEvent\& }{event}}
2195 %%
2196 %% Called when the user has changed the system colours. Windows only.
2197 %%
2198 %% \wxheading{Parameters}
2199 %%
2200 %% \docparam{event}{System colour change event. For more information, see \helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent}.}
2201 %%
2202 %% \wxheading{See also}
2203 %%
2204 %% \helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent},\rtfsp
2205 %% \helpref{Event handling overview}{eventhandlingoverview}
2206
2207
2208 \membersection{wxWindow::OnInternalIdle}\label{wxwindowoninternalidle}
2209
2210 \func{virtual void}{OnInternalIdle}{\void}
2211
2212 This virtual function is normally only used internally, but
2213 sometimes an application may need it to implement functionality
2214 that should not be disabled by an application defining an OnIdle
2215 handler in a derived class.
2216
2217 This function may be used to do delayed painting, for example,
2218 and most implementations call \helpref{wxWindow::UpdateWindowUI}{wxwindowupdatewindowui}
2219 in order to send update events to the window in idle time.
2220
2221
2222 \membersection{wxWindow::PageDown}\label{wxwindowpagedown}
2223
2224 This is just a wrapper for \helpref{ScrollPages()}{wxwindowscrollpages}$(1)$.
2225
2226
2227 \membersection{wxWindow::PageUp}\label{wxwindowpageup}
2228
2229 This is just a wrapper for \helpref{ScrollPages()}{wxwindowscrollpages}$(-1)$.
2230
2231
2232 \membersection{wxWindow::PopEventHandler}\label{wxwindowpopeventhandler}
2233
2234 \constfunc{wxEvtHandler*}{PopEventHandler}{\param{bool }{deleteHandler = {\tt false}}}
2235
2236 Removes and returns the top-most event handler on the event handler stack.
2237
2238 \wxheading{Parameters}
2239
2240 \docparam{deleteHandler}{If this is {\tt true}, the handler will be deleted after it is removed. The
2241 default value is {\tt false}.}
2242
2243 \wxheading{See also}
2244
2245 \helpref{wxWindow::SetEventHandler}{wxwindowseteventhandler},\rtfsp
2246 \helpref{wxWindow::GetEventHandler}{wxwindowgeteventhandler},\rtfsp
2247 \helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler},\rtfsp
2248 \helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
2249 \helpref{wxEvtHandler}{wxevthandler}\rtfsp
2250
2251
2252 \membersection{wxWindow::PopupMenu}\label{wxwindowpopupmenu}
2253
2254 \func{bool}{PopupMenu}{\param{wxMenu* }{menu}, \param{const wxPoint\& }{pos = wxDefaultPosition}}
2255
2256 \func{bool}{PopupMenu}{\param{wxMenu* }{menu}, \param{int }{x}, \param{int }{y}}
2257
2258 Pops up the given menu at the specified coordinates, relative to this
2259 window, and returns control when the user has dismissed the menu. If a
2260 menu item is selected, the corresponding menu event is generated and will be
2261 processed as usually. If the coordinates are not specified, current mouse
2262 cursor position is used.
2263
2264 \wxheading{Parameters}
2265
2266 \docparam{menu}{Menu to pop up.}
2267
2268 \docparam{pos}{The position where the menu will appear.}
2269
2270 \docparam{x}{Required x position for the menu to appear.}
2271
2272 \docparam{y}{Required y position for the menu to appear.}
2273
2274 \wxheading{See also}
2275
2276 \helpref{wxMenu}{wxmenu}
2277
2278 \wxheading{Remarks}
2279
2280 Just before the menu is popped up, \helpref{wxMenu::UpdateUI}{wxmenuupdateui}
2281 is called to ensure that the menu items are in the correct state. The menu does
2282 not get deleted by the window.
2283
2284 It is recommended to not explicitly specify coordinates when calling PopupMenu
2285 in response to mouse click, because some of the ports (namely, wxGTK) can do
2286 a better job of positioning the menu in that case.
2287
2288 \pythonnote{In place of a single overloaded method name, wxPython
2289 implements the following methods:\par
2290 \indented{2cm}{\begin{twocollist}
2291 \twocolitem{{\bf PopupMenu(menu, point)}}{Specifies position with a wxPoint}
2292 \twocolitem{{\bf PopupMenuXY(menu, x, y)}}{Specifies position with two integers (x, y)}
2293 \end{twocollist}}
2294 }
2295
2296
2297 \membersection{wxWindow::PushEventHandler}\label{wxwindowpusheventhandler}
2298
2299 \func{void}{PushEventHandler}{\param{wxEvtHandler* }{handler}}
2300
2301 Pushes this event handler onto the event stack for the window.
2302
2303 \wxheading{Parameters}
2304
2305 \docparam{handler}{Specifies the handler to be pushed.}
2306
2307 \wxheading{Remarks}
2308
2309 An event handler is an object that is capable of processing the events
2310 sent to a window. By default, the window is its own event handler, but
2311 an application may wish to substitute another, for example to allow
2312 central implementation of event-handling for a variety of different
2313 window classes.
2314
2315 \helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler} allows
2316 an application to set up a chain of event handlers, where an event not handled by one event handler is
2317 handed to the next one in the chain. Use \helpref{wxWindow::PopEventHandler}{wxwindowpopeventhandler} to
2318 remove the event handler.
2319
2320 \wxheading{See also}
2321
2322 \helpref{wxWindow::SetEventHandler}{wxwindowseteventhandler},\rtfsp
2323 \helpref{wxWindow::GetEventHandler}{wxwindowgeteventhandler},\rtfsp
2324 \helpref{wxWindow::PopEventHandler}{wxwindowpusheventhandler},\rtfsp
2325 \helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
2326 \helpref{wxEvtHandler}{wxevthandler}
2327
2328
2329 \membersection{wxWindow::Raise}\label{wxwindowraise}
2330
2331 \func{void}{Raise}{\void}
2332
2333 Raises the window to the top of the window hierarchy (z-order).
2334
2335 In current version of wxWidgets this works both for managed and child windows.
2336
2337 \wxheading{See also}
2338
2339 \helpref{Lower}{wxwindowlower}
2340
2341
2342 \membersection{wxWindow::Refresh}\label{wxwindowrefresh}
2343
2344 \func{virtual void}{Refresh}{\param{bool}{ eraseBackground = {\tt true}}, \param{const wxRect* }{rect = NULL}}
2345
2346 Causes this window, and all of its children recursively (except under wxGTK1
2347 where this is not implemented), to be repainted. Note that repainting doesn't
2348 happen immediately but only during the next event loop iteration, if you need
2349 to update the window immediately you should use \helpref{Update}{wxwindowupdate}
2350 instead.
2351
2352 \wxheading{Parameters}
2353
2354 \docparam{eraseBackground}{If {\tt true}, the background will be
2355 erased.}
2356
2357 \docparam{rect}{If non-NULL, only the given rectangle will
2358 be treated as damaged.}
2359
2360 \wxheading{See also}
2361
2362 \helpref{wxWindow::RefreshRect}{wxwindowrefreshrect}
2363
2364
2365 \membersection{wxWindow::RefreshRect}\label{wxwindowrefreshrect}
2366
2367 \func{void}{RefreshRect}{\param{const wxRect\& }{rect}, \param{bool }{eraseBackground = \true}}
2368
2369 Redraws the contents of the given rectangle: only the area inside it will be
2370 repainted.
2371
2372 This is the same as \helpref{Refresh}{wxwindowrefresh} but has a nicer syntax
2373 as it can be called with a temporary wxRect object as argument like this
2374 \texttt{RefreshRect(wxRect(x, y, w, h))}.
2375
2376
2377 \membersection{wxWindow::RegisterHotKey}\label{wxwindowregisterhotkey}
2378
2379 \func{bool}{RegisterHotKey}{\param{int}{ hotkeyId}, \param{int}{ modifiers}, \param{int}{ virtualKeyCode}}
2380
2381 Registers a system wide hotkey. Every time the user presses the hotkey registered here, this window
2382 will receive a hotkey event. It will receive the event even if the application is in the background
2383 and does not have the input focus because the user is working with some other application.
2384
2385 \wxheading{Parameters}
2386
2387 \docparam{hotkeyId}{Numeric identifier of the hotkey. For applications this must be between 0 and 0xBFFF. If
2388 this function is called from a shared DLL, it must be a system wide unique identifier between 0xC000 and 0xFFFF.
2389 This is a MSW specific detail.}
2390
2391 \docparam{modifiers}{A bitwise combination of {\tt wxMOD\_SHIFT}, {\tt wxMOD\_CONTROL}, {\tt wxMOD\_ALT}
2392 or {\tt wxMOD\_WIN} specifying the modifier keys that have to be pressed along with the key.}
2393
2394 \docparam{virtualKeyCode}{The virtual key code of the hotkey.}
2395
2396 \wxheading{Return value}
2397
2398 {\tt true} if the hotkey was registered successfully. {\tt false} if some other application already registered a
2399 hotkey with this modifier/virtualKeyCode combination.
2400
2401 \wxheading{Remarks}
2402
2403 Use EVT\_HOTKEY(hotkeyId, fnc) in the event table to capture the event.
2404 This function is currently only implemented under Windows. It is used
2405 in the \helpref{Windows CE port}{wxwince} for detecting hardware button presses.
2406
2407 \wxheading{See also}
2408
2409 \helpref{wxWindow::UnregisterHotKey}{wxwindowunregisterhotkey}
2410
2411
2412 \membersection{wxWindow::ReleaseMouse}\label{wxwindowreleasemouse}
2413
2414 \func{virtual void}{ReleaseMouse}{\void}
2415
2416 Releases mouse input captured with \helpref{wxWindow::CaptureMouse}{wxwindowcapturemouse}.
2417
2418 \wxheading{See also}
2419
2420 \helpref{wxWindow::CaptureMouse}{wxwindowcapturemouse},
2421 \helpref{wxWindow::HasCapture}{wxwindowhascapture},
2422 \helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse},
2423 \helpref{wxMouseCaptureLostEvent}{wxmousecapturelostevent}
2424 \helpref{wxMouseCaptureChangedEvent}{wxmousecapturechangedevent}
2425
2426
2427 \membersection{wxWindow::RemoveChild}\label{wxwindowremovechild}
2428
2429 \func{virtual void}{RemoveChild}{\param{wxWindow* }{child}}
2430
2431 Removes a child window. This is called automatically by window deletion
2432 functions so should not be required by the application programmer.
2433
2434 Notice that this function is mostly internal to wxWidgets and shouldn't be
2435 called by the user code.
2436
2437 \wxheading{Parameters}
2438
2439 \docparam{child}{Child window to remove.}
2440
2441
2442 \membersection{wxWindow::RemoveEventHandler}\label{wxwindowremoveeventhandler}
2443
2444 \func{bool}{RemoveEventHandler}{\param{wxEvtHandler *}{handler}}
2445
2446 Find the given {\it handler} in the windows event handler chain and remove (but
2447 not delete) it from it.
2448
2449 \wxheading{Parameters}
2450
2451 \docparam{handler}{The event handler to remove, must be non-{\tt NULL} and
2452 must be present in this windows event handlers chain}
2453
2454 \wxheading{Return value}
2455
2456 Returns {\tt true} if it was found and {\tt false} otherwise (this also results
2457 in an assert failure so this function should only be called when the
2458 handler is supposed to be there).
2459
2460 \wxheading{See also}
2461
2462 \helpref{PushEventHandler}{wxwindowpusheventhandler},\rtfsp
2463 \helpref{PopEventHandler}{wxwindowpopeventhandler}
2464
2465
2466 \membersection{wxWindow::Reparent}\label{wxwindowreparent}
2467
2468 \func{virtual bool}{Reparent}{\param{wxWindow* }{newParent}}
2469
2470 Reparents the window, i.e the window will be removed from its
2471 current parent window (e.g. a non-standard toolbar in a wxFrame)
2472 and then re-inserted into another.
2473
2474 \wxheading{Parameters}
2475
2476 \docparam{newParent}{New parent.}
2477
2478
2479 \membersection{wxWindow::ScreenToClient}\label{wxwindowscreentoclient}
2480
2481 \constfunc{virtual void}{ScreenToClient}{\param{int* }{x}, \param{int* }{y}}
2482
2483 \constfunc{virtual wxPoint}{ScreenToClient}{\param{const wxPoint\& }{pt}}
2484
2485 Converts from screen to client window coordinates.
2486
2487 \wxheading{Parameters}
2488
2489 \docparam{x}{Stores the screen x coordinate and receives the client x coordinate.}
2490
2491 \docparam{y}{Stores the screen x coordinate and receives the client x coordinate.}
2492
2493 \docparam{pt}{The screen position for the second form of the function.}
2494
2495 \pythonnote{In place of a single overloaded method name, wxPython
2496 implements the following methods:\par
2497 \indented{2cm}{\begin{twocollist}
2498 \twocolitem{{\bf ScreenToClient(point)}}{Accepts and returns a wxPoint}
2499 \twocolitem{{\bf ScreenToClientXY(x, y)}}{Returns a 2-tuple, (x, y)}
2500 \end{twocollist}}
2501 }
2502
2503
2504 \membersection{wxWindow::ScrollLines}\label{wxwindowscrolllines}
2505
2506 \func{virtual bool}{ScrollLines}{\param{int }{lines}}
2507
2508 Scrolls the window by the given number of lines down (if {\it lines} is
2509 positive) or up.
2510
2511 \wxheading{Return value}
2512
2513 Returns {\tt true} if the window was scrolled, {\tt false} if it was already
2514 on top/bottom and nothing was done.
2515
2516 \wxheading{Remarks}
2517
2518 This function is currently only implemented under MSW and wxTextCtrl under
2519 wxGTK (it also works for wxScrolledWindow derived classes under all
2520 platforms).
2521
2522 \wxheading{See also}
2523
2524 \helpref{ScrollPages}{wxwindowscrollpages}
2525
2526
2527 \membersection{wxWindow::ScrollPages}\label{wxwindowscrollpages}
2528
2529 \func{virtual bool}{ScrollPages}{\param{int }{pages}}
2530
2531 Scrolls the window by the given number of pages down (if {\it pages} is
2532 positive) or up.
2533
2534 \wxheading{Return value}
2535
2536 Returns {\tt true} if the window was scrolled, {\tt false} if it was already
2537 on top/bottom and nothing was done.
2538
2539 \wxheading{Remarks}
2540
2541 This function is currently only implemented under MSW and wxGTK.
2542
2543 \wxheading{See also}
2544
2545 \helpref{ScrollLines}{wxwindowscrolllines}
2546
2547
2548 \membersection{wxWindow::ScrollWindow}\label{wxwindowscrollwindow}
2549
2550 \func{virtual void}{ScrollWindow}{\param{int }{dx}, \param{int }{dy}, \param{const wxRect*}{ rect = NULL}}
2551
2552 Physically scrolls the pixels in the window and move child windows accordingly.
2553
2554 \wxheading{Parameters}
2555
2556 \docparam{dx}{Amount to scroll horizontally.}
2557
2558 \docparam{dy}{Amount to scroll vertically.}
2559
2560 \docparam{rect}{Rectangle to scroll, if it is \NULL, the whole window is
2561 scrolled (this is always the case under wxGTK which doesn't support this
2562 parameter)}
2563
2564 \wxheading{Remarks}
2565
2566 Note that you can often use \helpref{wxScrolledWindow}{wxscrolledwindow}
2567 instead of using this function directly.
2568
2569
2570 \membersection{wxWindow::SetAcceleratorTable}\label{wxwindowsetacceleratortable}
2571
2572 \func{virtual void}{SetAcceleratorTable}{\param{const wxAcceleratorTable\&}{ accel}}
2573
2574 Sets the accelerator table for this window. See \helpref{wxAcceleratorTable}{wxacceleratortable}.
2575
2576
2577 \membersection{wxWindow::SetAccessible}\label{wxwindowsetaccessible}
2578
2579 \func{void}{SetAccessible}{\param{wxAccessible*}{ accessible}}
2580
2581 Sets the accessible for this window. Any existing accessible for this window
2582 will be deleted first, if not identical to {\it accessible}.
2583
2584 See also \helpref{wxAccessible}{wxaccessible}.
2585
2586
2587 \membersection{wxWindow::SetAutoLayout}\label{wxwindowsetautolayout}
2588
2589 \func{void}{SetAutoLayout}{\param{bool}{ autoLayout}}
2590
2591 Determines whether the \helpref{wxWindow::Layout}{wxwindowlayout} function will
2592 be called automatically when the window is resized. Please note that this only
2593 happens for the windows usually used to contain children, namely
2594 \helpref{wxPanel}{wxpanel} and \helpref{wxTopLevelWindow}{wxtoplevelwindow}
2595 (and the classes deriving from them).
2596
2597 This method is called implicitly by
2598 \helpref{wxWindow::SetSizer}{wxwindowsetsizer} but if you use
2599 \helpref{wxWindow::SetConstraints}{wxwindowsetconstraints} you should call it
2600 manually or otherwise the window layout won't be correctly updated when its
2601 size changes.
2602
2603 \wxheading{Parameters}
2604
2605 \docparam{autoLayout}{Set this to \true if you wish the Layout function to be
2606 called automatically when the window is resized.}
2607
2608 \wxheading{See also}
2609
2610 \helpref{wxWindow::SetConstraints}{wxwindowsetconstraints}
2611
2612
2613 \membersection{wxWindow::SetBackgroundColour}\label{wxwindowsetbackgroundcolour}
2614
2615 \func{virtual bool}{SetBackgroundColour}{\param{const wxColour\& }{colour}}
2616
2617 Sets the background colour of the window.
2618
2619 Please see \helpref{InheritAttributes}{wxwindowinheritattributes} for
2620 explanation of the difference between this method and
2621 \helpref{SetOwnBackgroundColour}{wxwindowsetownbackgroundcolour}.
2622
2623 \wxheading{Parameters}
2624
2625 \docparam{colour}{The colour to be used as the background colour, pass
2626 {\tt wxNullColour} to reset to the default colour.}
2627
2628 \wxheading{Remarks}
2629
2630 The background colour is usually painted by the default\rtfsp
2631 \helpref{wxEraseEvent}{wxeraseevent} event handler function
2632 under Windows and automatically under GTK.
2633
2634 Note that setting the background colour does not cause an immediate refresh, so you
2635 may wish to call \helpref{wxWindow::ClearBackground}{wxwindowclearbackground} or \helpref{wxWindow::Refresh}{wxwindowrefresh} after
2636 calling this function.
2637
2638 Using this function will disable attempts to use themes for this
2639 window, if the system supports them. Use with care since usually the
2640 themes represent the appearance chosen by the user to be used for all
2641 applications on the system.
2642
2643
2644 \wxheading{See also}
2645
2646 \helpref{wxWindow::GetBackgroundColour}{wxwindowgetbackgroundcolour},\rtfsp
2647 \helpref{wxWindow::SetForegroundColour}{wxwindowsetforegroundcolour},\rtfsp
2648 \helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour},\rtfsp
2649 \helpref{wxWindow::ClearBackground}{wxwindowclearbackground},\rtfsp
2650 \helpref{wxWindow::Refresh}{wxwindowrefresh},\rtfsp
2651 \helpref{wxEraseEvent}{wxeraseevent}
2652
2653 \membersection{wxWindow::SetBackgroundStyle}\label{wxwindowsetbackgroundstyle}
2654
2655 \func{virtual void}{SetBackgroundStyle}{\param{wxBackgroundStyle}{ style}}
2656
2657 Sets the background style of the window. The background style indicates
2658 whether background colour should be determined by the system (wxBG\_STYLE\_SYSTEM),
2659 be set to a specific colour (wxBG\_STYLE\_COLOUR), or should be left to the
2660 application to implement (wxBG\_STYLE\_CUSTOM).
2661
2662 On GTK+, use of wxBG\_STYLE\_CUSTOM allows the flicker-free drawing of a custom
2663 background, such as a tiled bitmap. Currently the style has no effect on other platforms.
2664
2665 \wxheading{See also}
2666
2667 \helpref{wxWindow::SetBackgroundColour}{wxwindowsetbackgroundcolour},\rtfsp
2668 \helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour},\rtfsp
2669 \helpref{wxWindow::GetBackgroundStyle}{wxwindowgetbackgroundstyle}
2670
2671
2672 \membersection{wxWindow::SetInitialSize}\label{wxwindowsetinitialsize}
2673
2674 \func{void}{SetInitialSize}{\param{const wxSize\& }{size = wxDefaultSize}}
2675
2676 A {\it smart} SetSize that will fill in default size components with the
2677 window's {\it best} size values. Also sets the window's minsize to
2678 the value passed in for use with sizers. This means that if a full or
2679 partial size is passed to this function then the sizers will use that
2680 size instead of the results of GetBestSize to determine the minimum
2681 needs of the window for layout.
2682
2683 Most controls will use this to set their initial size, and their min
2684 size to the passed in value (if any.)
2685
2686
2687 \wxheading{See also}
2688
2689 \helpref{wxWindow::SetSize}{wxwindowsetsize},\rtfsp
2690 \helpref{wxWindow::GetBestSize}{wxwindowgetbestsize},\rtfsp
2691 \helpref{wxWindow::GetEffectiveMinSize}{wxwindowgeteffectiveminsize}
2692
2693
2694 \membersection{wxWindow::SetCaret}\label{wxwindowsetcaret}
2695
2696 \constfunc{void}{SetCaret}{\param{wxCaret *}{caret}}
2697
2698 Sets the \helpref{caret}{wxcaret} associated with the window.
2699
2700
2701 \membersection{wxWindow::SetClientSize}\label{wxwindowsetclientsize}
2702
2703 \func{virtual void}{SetClientSize}{\param{int}{ width}, \param{int}{ height}}
2704
2705 \func{virtual void}{SetClientSize}{\param{const wxSize\&}{ size}}
2706
2707 This sets the size of the window client area in pixels. Using this function to size a window
2708 tends to be more device-independent than \helpref{wxWindow::SetSize}{wxwindowsetsize}, since the application need not
2709 worry about what dimensions the border or title bar have when trying to fit the window
2710 around panel items, for example.
2711
2712 \wxheading{Parameters}
2713
2714 \docparam{width}{The required client area width.}
2715
2716 \docparam{height}{The required client area height.}
2717
2718 \docparam{size}{The required client size.}
2719
2720 \pythonnote{In place of a single overloaded method name, wxPython
2721 implements the following methods:\par
2722 \indented{2cm}{\begin{twocollist}
2723 \twocolitem{{\bf SetClientSize(size)}}{Accepts a wxSize}
2724 \twocolitem{{\bf SetClientSizeWH(width, height)}}{}
2725 \end{twocollist}}
2726 }
2727
2728
2729 \membersection{wxWindow::SetConstraints}\label{wxwindowsetconstraints}
2730
2731 \func{void}{SetConstraints}{\param{wxLayoutConstraints* }{constraints}}
2732
2733 Sets the window to have the given layout constraints. The window
2734 will then own the object, and will take care of its deletion.
2735 If an existing layout constraints object is already owned by the
2736 window, it will be deleted.
2737
2738 \wxheading{Parameters}
2739
2740 \docparam{constraints}{The constraints to set. Pass NULL to disassociate and delete the window's
2741 constraints.}
2742
2743 \wxheading{Remarks}
2744
2745 You must call \helpref{wxWindow::SetAutoLayout}{wxwindowsetautolayout} to tell a window to use
2746 the constraints automatically in OnSize; otherwise, you must override OnSize and call Layout()
2747 explicitly. When setting both a wxLayoutConstraints and a \helpref{wxSizer}{wxsizer}, only the
2748 sizer will have effect.
2749
2750 \membersection{wxWindow::SetContainingSizer}\label{wxwindowsetcontainingsizer}
2751
2752 \func{void}{SetContainingSizer}{\param{wxSizer* }{sizer}}
2753
2754 This normally does not need to be called by user code. It is called
2755 when a window is added to a sizer, and is used so the window can
2756 remove itself from the sizer when it is destroyed.
2757
2758
2759 \membersection{wxWindow::SetCursor}\label{wxwindowsetcursor}
2760
2761 \func{virtual void}{SetCursor}{\param{const wxCursor\&}{cursor}}
2762
2763 % VZ: the docs are correct, if the code doesn't behave like this, it must be
2764 % changed
2765 Sets the window's cursor. Notice that the window cursor also sets it for the
2766 children of the window implicitly.
2767
2768 The {\it cursor} may be {\tt wxNullCursor} in which case the window cursor will
2769 be reset back to default.
2770
2771 \wxheading{Parameters}
2772
2773 \docparam{cursor}{Specifies the cursor that the window should normally display.}
2774
2775 \wxheading{See also}
2776
2777 \helpref{::wxSetCursor}{wxsetcursor}, \helpref{wxCursor}{wxcursor}
2778
2779
2780 \membersection{wxWindow::SetDropTarget}\label{wxwindowsetdroptarget}
2781
2782 \func{void}{SetDropTarget}{\param{wxDropTarget*}{ target}}
2783
2784 Associates a drop target with this window.
2785
2786 If the window already has a drop target, it is deleted.
2787
2788 \wxheading{See also}
2789
2790 \helpref{wxWindow::GetDropTarget}{wxwindowgetdroptarget},
2791 \helpref{Drag and drop overview}{wxdndoverview}
2792
2793
2794
2795 \membersection{wxWindow::SetInitialBestSize}\label{wxwindowsetinitialbestsize}
2796
2797 \func{virtual void}{SetInitialBestSize}{\param{const wxSize\& }{size}}
2798
2799 Sets the initial window size if none is given (i.e. at least one of the
2800 components of the size passed to ctor/Create() is wxDefaultCoord).
2801
2802 \membersection{wxWindow::SetEventHandler}\label{wxwindowseteventhandler}
2803
2804 \func{void}{SetEventHandler}{\param{wxEvtHandler* }{handler}}
2805
2806 Sets the event handler for this window.
2807
2808 \wxheading{Parameters}
2809
2810 \docparam{handler}{Specifies the handler to be set.}
2811
2812 \wxheading{Remarks}
2813
2814 An event handler is an object that is capable of processing the events
2815 sent to a window. By default, the window is its own event handler, but
2816 an application may wish to substitute another, for example to allow
2817 central implementation of event-handling for a variety of different
2818 window classes.
2819
2820 It is usually better to use \helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler} since
2821 this sets up a chain of event handlers, where an event not handled by one event handler is
2822 handed to the next one in the chain.
2823
2824 \wxheading{See also}
2825
2826 \helpref{wxWindow::GetEventHandler}{wxwindowgeteventhandler},\rtfsp
2827 \helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler},\rtfsp
2828 \helpref{wxWindow::PopEventHandler}{wxwindowpusheventhandler},\rtfsp
2829 \helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
2830 \helpref{wxEvtHandler}{wxevthandler}
2831
2832
2833 \membersection{wxWindow::SetExtraStyle}\label{wxwindowsetextrastyle}
2834
2835 \func{void}{SetExtraStyle}{\param{long }{exStyle}}
2836
2837 Sets the extra style bits for the window. The currently defined extra style
2838 bits are:
2839
2840 \twocolwidtha{5cm}%
2841 \begin{twocollist}\itemsep=0pt
2842 \twocolitem{\windowstyle{wxWS\_EX\_VALIDATE\_RECURSIVELY}}{TransferDataTo/FromWindow()
2843 and Validate() methods will recursively descend into all children of the
2844 window if it has this style flag set.}
2845 \twocolitem{\windowstyle{wxWS\_EX\_BLOCK\_EVENTS}}{Normally, the command
2846 events are propagated upwards to the window parent recursively until a handler
2847 for them is found. Using this style allows to prevent them from being
2848 propagated beyond this window. Notice that wxDialog has this style on by
2849 default for the reasons explained in the
2850 \helpref{event processing overview}{eventprocessing}.}
2851 \twocolitem{\windowstyle{wxWS\_EX\_TRANSIENT}}{This can be used to prevent a
2852 window from being used as an implicit parent for the dialogs which were
2853 created without a parent. It is useful for the windows which can disappear at
2854 any moment as creating children of such windows results in fatal problems.}
2855 \twocolitem{\windowstyle{wxWS\_EX\_CONTEXTHELP}}{Under Windows, puts a query
2856 button on the caption. When pressed, Windows will go into a context-sensitive
2857 help mode and wxWidgets will send a wxEVT\_HELP event if the user clicked on an
2858 application window.
2859 This style cannot be used together with wxMAXIMIZE\_BOX or wxMINIMIZE\_BOX, so
2860 these two styles are automatically turned of if this one is used.}
2861 \twocolitem{\windowstyle{wxWS\_EX\_PROCESS\_IDLE}}{This window should always process idle events, even
2862 if the mode set by \helpref{wxIdleEvent::SetMode}{wxidleeventsetmode} is wxIDLE\_PROCESS\_SPECIFIED.}
2863 \twocolitem{\windowstyle{wxWS\_EX\_PROCESS\_UI\_UPDATES}}{This window should always process UI update events,
2864 even if the mode set by \helpref{wxUpdateUIEvent::SetMode}{wxupdateuieventsetmode} is wxUPDATE\_UI\_PROCESS\_SPECIFIED.}
2865 \end{twocollist}
2866
2867
2868 \membersection{wxWindow::SetFocus}\label{wxwindowsetfocus}
2869
2870 \func{virtual void}{SetFocus}{\void}
2871
2872 This sets the window to receive keyboard input.
2873
2874 \wxheading{See also}
2875
2876 \helpref{wxFocusEvent}{wxfocusevent}
2877 \helpref{wxPanel::SetFocus}{wxpanelsetfocus}
2878 \helpref{wxPanel::SetFocusIgnoringChildren}{wxpanelsetfocusignoringchildren}
2879
2880
2881 \membersection{wxWindow::SetFocusFromKbd}\label{wxwindowsetfocusfromkbd}
2882
2883 \func{virtual void}{SetFocusFromKbd}{\void}
2884
2885 This function is called by wxWidgets keyboard navigation code when the user
2886 gives the focus to this window from keyboard (e.g. using {\tt TAB} key).
2887 By default this method simply calls \helpref{SetFocus}{wxwindowsetfocus} but
2888 can be overridden to do something in addition to this in the derived classes.
2889
2890
2891 \membersection{wxWindow::SetFont}\label{wxwindowsetfont}
2892
2893 \func{void}{SetFont}{\param{const wxFont\& }{font}}
2894
2895 Sets the font for this window. This function should not be called for the
2896 parent window if you don't want its font to be inherited by its children,
2897 use \helpref{SetOwnFont}{wxwindowsetownfont} instead in this case and
2898 see \helpref{InheritAttributes}{wxwindowinheritattributes} for more
2899 explanations.
2900
2901 Please notice that the given font is \emph{not} automatically used for
2902 \helpref{wxPaintDC}{wxpaintdc} objects associated with this window, you need to
2903 call \helpref{wxDC::SetFont()}{wxdcsetfont} too. However this font is used by
2904 any standard controls for drawing their text as well as by
2905 \helpref{wxWindow::GetTextExtent()}{wxwindowgettextextent}.
2906
2907 \wxheading{Parameters}
2908
2909 \docparam{font}{Font to associate with this window, pass
2910 {\tt wxNullFont} to reset to the default font.}
2911
2912 \wxheading{See also}
2913
2914 \helpref{wxWindow::GetFont}{wxwindowgetfont},\\
2915 \helpref{InheritAttributes}{wxwindowinheritattributes}
2916
2917
2918 \membersection{wxWindow::SetForegroundColour}\label{wxwindowsetforegroundcolour}
2919
2920 \func{virtual void}{SetForegroundColour}{\param{const wxColour\& }{colour}}
2921
2922 Sets the foreground colour of the window.
2923
2924 Please see \helpref{InheritAttributes}{wxwindowinheritattributes} for
2925 explanation of the difference between this method and
2926 \helpref{SetOwnForegroundColour}{wxwindowsetownforegroundcolour}.
2927
2928 \wxheading{Parameters}
2929
2930 \docparam{colour}{The colour to be used as the foreground colour, pass
2931 {\tt wxNullColour} to reset to the default colour.}
2932
2933 \wxheading{Remarks}
2934
2935 The interpretation of foreground colour is open to interpretation according
2936 to the window class; it may be the text colour or other colour, or it may not
2937 be used at all.
2938
2939 Using this function will disable attempts to use themes for this
2940 window, if the system supports them. Use with care since usually the
2941 themes represent the appearance chosen by the user to be used for all
2942 applications on the system.
2943
2944 \wxheading{See also}
2945
2946 \helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour},\rtfsp
2947 \helpref{wxWindow::SetBackgroundColour}{wxwindowsetbackgroundcolour},\rtfsp
2948 \helpref{wxWindow::GetBackgroundColour}{wxwindowgetbackgroundcolour},\rtfsp
2949 \helpref{wxWindow::ShouldInheritColours}{wxwindowshouldinheritcolours}
2950
2951
2952 \membersection{wxWindow::SetHelpText}\label{wxwindowsethelptext}
2953
2954 \func{virtual void}{SetHelpText}{\param{const wxString\& }{helpText}}
2955
2956 Sets the help text to be used as context-sensitive help for this window.
2957
2958 Note that the text is actually stored by the current \helpref{wxHelpProvider}{wxhelpprovider} implementation,
2959 and not in the window object itself.
2960
2961 \wxheading{See also}
2962
2963 \helpref{GetHelpText}{wxwindowgethelptext}, \helpref{wxHelpProvider}{wxhelpprovider}
2964
2965
2966 \membersection{wxWindow::SetId}\label{wxwindowsetid}
2967
2968 \func{void}{SetId}{\param{int}{ id}}
2969
2970 Sets the identifier of the window.
2971
2972 \wxheading{Remarks}
2973
2974 Each window has an integer identifier. If the application has not provided one,
2975 an identifier will be generated. Normally, the identifier should be provided
2976 on creation and should not be modified subsequently.
2977
2978 \wxheading{See also}
2979
2980 \helpref{wxWindow::GetId}{wxwindowgetid},\rtfsp
2981 \helpref{Window identifiers}{windowids}
2982
2983
2984
2985 \membersection{wxWindow::SetLabel}\label{wxwindowsetlabel}
2986
2987 \func{virtual void}{SetLabel}{\param{const wxString\& }{label}}
2988
2989 Sets the window's label.
2990
2991 \wxheading{Parameters}
2992
2993 \docparam{label}{The window label.}
2994
2995 \wxheading{See also}
2996
2997 \helpref{wxWindow::GetLabel}{wxwindowgetlabel}
2998
2999
3000 \membersection{wxWindow::SetMaxSize}\label{wxwindowsetmaxsize}
3001
3002 \func{void}{SetMaxSize}{\param{const wxSize\& }{size}}
3003
3004 Sets the maximum size of the window, to indicate to the sizer layout mechanism
3005 that this is the maximum possible size.
3006
3007 \membersection{wxWindow::SetMinSize}\label{wxwindowsetminsize}
3008
3009 \func{void}{SetMinSize}{\param{const wxSize\& }{size}}
3010
3011 Sets the minimum size of the window, to indicate to the sizer layout mechanism
3012 that this is the minimum required size. You may need to call this
3013 if you change the window size after construction and before adding
3014 to its parent sizer.
3015
3016 \membersection{wxWindow::SetName}\label{wxwindowsetname}
3017
3018 \func{virtual void}{SetName}{\param{const wxString\& }{name}}
3019
3020 Sets the window's name.
3021
3022 \wxheading{Parameters}
3023
3024 \docparam{name}{A name to set for the window.}
3025
3026 \wxheading{See also}
3027
3028 \helpref{wxWindow::GetName}{wxwindowgetname}
3029
3030
3031 \membersection{wxWindow::SetOwnBackgroundColour}\label{wxwindowsetownbackgroundcolour}
3032
3033 \func{void}{SetOwnBackgroundColour}{\param{const wxColour\& }{colour}}
3034
3035 Sets the background colour of the window but prevents it from being inherited
3036 by the children of this window.
3037
3038 \wxheading{See also}
3039
3040 \helpref{SetBackgroundColour}{wxwindowsetbackgroundcolour},\rtfsp
3041 \helpref{InheritAttributes}{wxwindowinheritattributes}
3042
3043
3044 \membersection{wxWindow::SetOwnFont}\label{wxwindowsetownfont}
3045
3046 \func{void}{SetOwnFont}{\param{const wxFont\& }{font}}
3047
3048 Sets the font of the window but prevents it from being inherited by the
3049 children of this window.
3050
3051 \wxheading{See also}
3052
3053 \helpref{SetFont}{wxwindowsetfont},\rtfsp
3054 \helpref{InheritAttributes}{wxwindowinheritattributes}
3055
3056
3057 \membersection{wxWindow::SetOwnForegroundColour}\label{wxwindowsetownforegroundcolour}
3058
3059 \func{void}{SetOwnForegroundColour}{\param{const wxColour\& }{colour}}
3060
3061 Sets the foreground colour of the window but prevents it from being inherited
3062 by the children of this window.
3063
3064 \wxheading{See also}
3065
3066 \helpref{SetForegroundColour}{wxwindowsetforegroundcolour},\rtfsp
3067 \helpref{InheritAttributes}{wxwindowinheritattributes}
3068
3069
3070 \membersection{wxWindow::SetPalette}\label{wxwindowsetpalette}
3071
3072 \func{virtual void}{SetPalette}{\param{wxPalette* }{palette}}
3073
3074 Obsolete - use \helpref{wxDC::SetPalette}{wxdcsetpalette} instead.
3075
3076
3077 \membersection{wxWindow::SetScrollbar}\label{wxwindowsetscrollbar}
3078
3079 \func{virtual void}{SetScrollbar}{\param{int }{orientation}, \param{int }{position},\rtfsp
3080 \param{int }{thumbSize}, \param{int }{range},\rtfsp
3081 \param{bool }{refresh = {\tt true}}}
3082
3083 Sets the scrollbar properties of a built-in scrollbar.
3084
3085 \wxheading{Parameters}
3086
3087 \docparam{orientation}{Determines the scrollbar whose page size is to be set. May be wxHORIZONTAL or wxVERTICAL.}
3088
3089 \docparam{position}{The position of the scrollbar in scroll units.}
3090
3091 \docparam{thumbSize}{The size of the thumb, or visible portion of the scrollbar, in scroll units.}
3092
3093 \docparam{range}{The maximum position of the scrollbar.}
3094
3095 \docparam{refresh}{{\tt true} to redraw the scrollbar, {\tt false} otherwise.}
3096
3097 \wxheading{Remarks}
3098
3099 Let's say you wish to display 50 lines of text, using the same font.
3100 The window is sized so that you can only see 16 lines at a time.
3101
3102 You would use:
3103
3104 {\small%
3105 \begin{verbatim}
3106 SetScrollbar(wxVERTICAL, 0, 16, 50);
3107 \end{verbatim}
3108 }
3109
3110 Note that with the window at this size, the thumb position can never go
3111 above 50 minus 16, or 34.
3112
3113 You can determine how many lines are currently visible by dividing the current view
3114 size by the character height in pixels.
3115
3116 When defining your own scrollbar behaviour, you will always need to recalculate
3117 the scrollbar settings when the window size changes. You could therefore put your
3118 scrollbar calculations and SetScrollbar
3119 call into a function named AdjustScrollbars, which can be called initially and also
3120 from your \helpref{wxSizeEvent}{wxsizeevent} handler function.
3121
3122 \wxheading{See also}
3123
3124 \helpref{Scrolling overview}{scrollingoverview},\rtfsp
3125 \helpref{wxScrollBar}{wxscrollbar}, \helpref{wxScrolledWindow}{wxscrolledwindow},\rtfsp
3126 \helpref{wxScrollWinEvent}{wxscrollwinevent}
3127
3128 \begin{comment}
3129
3130
3131 \membersection{wxWindow::SetScrollPage}\label{wxwindowsetscrollpage}
3132
3133 \func{virtual void}{SetScrollPage}{\param{int }{orientation}, \param{int }{pageSize}, \param{bool }{refresh = {\tt true}}}
3134
3135 Sets the page size of one of the built-in scrollbars.
3136
3137 \wxheading{Parameters}
3138
3139 \docparam{orientation}{Determines the scrollbar whose page size is to be set. May be wxHORIZONTAL or wxVERTICAL.}
3140
3141 \docparam{pageSize}{Page size in scroll units.}
3142
3143 \docparam{refresh}{{\tt true} to redraw the scrollbar, {\tt false} otherwise.}
3144
3145 \wxheading{Remarks}
3146
3147 The page size of a scrollbar is the number of scroll units that the scroll thumb travels when you
3148 click on the area above/left of or below/right of the thumb. Normally you will want a whole visible
3149 page to be scrolled, i.e. the size of the current view (perhaps the window client size). This
3150 value has to be adjusted when the window is resized, since the page size will have changed.
3151
3152 In addition to specifying how far the scroll thumb travels when paging, in Motif and some versions of Windows
3153 the thumb changes size to reflect the page size relative to the length of the document. When the
3154 document size is only slightly bigger than the current view (window) size, almost all of the scrollbar
3155 will be taken up by the thumb. When the two values become the same, the scrollbar will (on some systems)
3156 disappear.
3157
3158 Currently, this function should be called before SetPageRange, because of a quirk in the Windows
3159 handling of pages and ranges.
3160
3161 \wxheading{See also}
3162
3163 \helpref{wxWindow::SetScrollPos}{wxwindowsetscrollpos},\rtfsp
3164 \helpref{wxWindow::GetScrollPos}{wxwindowgetscrollpos},\rtfsp
3165 \helpref{wxWindow::GetScrollPage}{wxwindowgetscrollpage},\rtfsp
3166 \helpref{wxScrollBar}{wxscrollbar}, \helpref{wxScrolledWindow}{wxscrolledwindow}
3167 \end{comment}
3168
3169
3170 \membersection{wxWindow::SetScrollPos}\label{wxwindowsetscrollpos}
3171
3172 \func{virtual void}{SetScrollPos}{\param{int }{orientation}, \param{int }{pos}, \param{bool }{refresh = {\tt true}}}
3173
3174 Sets the position of one of the built-in scrollbars.
3175
3176 \wxheading{Parameters}
3177
3178 \docparam{orientation}{Determines the scrollbar whose position is to be set. May be wxHORIZONTAL or wxVERTICAL.}
3179
3180 \docparam{pos}{Position in scroll units.}
3181
3182 \docparam{refresh}{{\tt true} to redraw the scrollbar, {\tt false} otherwise.}
3183
3184 \wxheading{Remarks}
3185
3186 This function does not directly affect the contents of the window: it is up to the
3187 application to take note of scrollbar attributes and redraw contents accordingly.
3188
3189 \wxheading{See also}
3190
3191 \helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar},\rtfsp
3192 \helpref{wxWindow::GetScrollPos}{wxwindowgetscrollpos},\rtfsp
3193 \helpref{wxWindow::GetScrollThumb}{wxwindowgetscrollthumb},\rtfsp
3194 \helpref{wxScrollBar}{wxscrollbar}, \helpref{wxScrolledWindow}{wxscrolledwindow}
3195
3196 \begin{comment}
3197
3198
3199 \membersection{wxWindow::SetScrollRange}\label{wxwindowsetscrollrange}
3200
3201 \func{virtual void}{SetScrollRange}{\param{int }{orientation}, \param{int }{range}, \param{bool }{refresh = {\tt true}}}
3202
3203 Sets the range of one of the built-in scrollbars.
3204
3205 \wxheading{Parameters}
3206
3207 \docparam{orientation}{Determines the scrollbar whose range is to be set. May be wxHORIZONTAL or wxVERTICAL.}
3208
3209 \docparam{range}{Scroll range.}
3210
3211 \docparam{refresh}{{\tt true} to redraw the scrollbar, {\tt false} otherwise.}
3212
3213 \wxheading{Remarks}
3214
3215 The range of a scrollbar is the number of steps that the thumb may travel, rather than the total
3216 object length of the scrollbar. If you are implementing a scrolling window, for example, you
3217 would adjust the scroll range when the window is resized, by subtracting the window view size from the
3218 total virtual window size. When the two sizes are the same (all the window is visible), the range goes to zero
3219 and usually the scrollbar will be automatically hidden.
3220
3221 \wxheading{See also}
3222
3223 \helpref{wxWindow::SetScrollPos}{wxwindowsetscrollpos},\rtfsp
3224 \helpref{wxWindow::SetScrollPage}{wxwindowsetscrollpage},\rtfsp
3225 \helpref{wxWindow::GetScrollPos}{wxwindowgetscrollpos},\rtfsp
3226 \helpref{wxWindow::GetScrollPage}{wxwindowgetscrollpage},\rtfsp
3227 \helpref{wxScrollBar}{wxscrollbar}, \helpref{wxScrolledWindow}{wxscrolledwindow}
3228 \end{comment}
3229
3230
3231 \membersection{wxWindow::SetSize}\label{wxwindowsetsize}
3232
3233 \func{virtual void}{SetSize}{\param{int}{ x}, \param{int}{ y}, \param{int}{ width}, \param{int}{ height},
3234 \param{int}{ sizeFlags = wxSIZE\_AUTO}}
3235
3236 \func{virtual void}{SetSize}{\param{const wxRect\&}{ rect}}
3237
3238 Sets the size and position of the window in pixels.
3239
3240 \func{virtual void}{SetSize}{\param{int}{ width}, \param{int}{ height}}
3241
3242 \func{virtual void}{SetSize}{\param{const wxSize\&}{ size}}
3243
3244 Sets the size of the window in pixels.
3245
3246 \wxheading{Parameters}
3247
3248 \docparam{x}{Required x position in pixels, or wxDefaultCoord to indicate that the existing
3249 value should be used.}
3250
3251 \docparam{y}{Required y position in pixels, or wxDefaultCoord to indicate that the existing
3252 value should be used.}
3253
3254 \docparam{width}{Required width in pixels, or wxDefaultCoord to indicate that the existing
3255 value should be used.}
3256
3257 \docparam{height}{Required height position in pixels, or wxDefaultCoord to indicate that the existing
3258 value should be used.}
3259
3260 \docparam{size}{\helpref{wxSize}{wxsize} object for setting the size.}
3261
3262 \docparam{rect}{\helpref{wxRect}{wxrect} object for setting the position and size.}
3263
3264 \docparam{sizeFlags}{Indicates the interpretation of other parameters. It is a bit list of the following:
3265
3266 {\bf wxSIZE\_AUTO\_WIDTH}: a $wxDefaultCoord$ width value is taken to indicate
3267 a wxWidgets-supplied default width.\\
3268 {\bf wxSIZE\_AUTO\_HEIGHT}: a $wxDefaultCoord$ height value is taken to indicate
3269 a wxWidgets-supplied default height.\\
3270 {\bf wxSIZE\_AUTO}: $wxDefaultCoord$ size values are taken to indicate
3271 a wxWidgets-supplied default size.\\
3272 {\bf wxSIZE\_USE\_EXISTING}: existing dimensions should be used
3273 if $wxDefaultCoord$ values are supplied.\\
3274 {\bf wxSIZE\_ALLOW\_MINUS\_ONE}: allow negative dimensions (ie. value of $wxDefaultCoord$) to be interpreted
3275 as real dimensions, not default values.
3276 {\bf wxSIZE\_FORCE}: normally, if the position and the size of the window are
3277 already the same as the parameters of this function, nothing is done. but with
3278 this flag a window resize may be forced even in this case (supported in wx
3279 2.6.2 and later and only implemented for MSW and ignored elsewhere currently)
3280 }
3281
3282 \wxheading{Remarks}
3283
3284 The second form is a convenience for calling the first form with default
3285 x and y parameters, and must be used with non-default width and height values.
3286
3287 The first form sets the position and optionally size, of the window.
3288 Parameters may be $wxDefaultCoord$ to indicate either that a default should be supplied
3289 by wxWidgets, or that the current value of the dimension should be used.
3290
3291 \wxheading{See also}
3292
3293 \helpref{wxWindow::Move}{wxwindowmove}
3294
3295 \pythonnote{In place of a single overloaded method name, wxPython
3296 implements the following methods:\par
3297 \indented{2cm}{\begin{twocollist}
3298 \twocolitem{{\bf SetDimensions(x, y, width, height, sizeFlags=wxSIZE\_AUTO)}}{}
3299 \twocolitem{{\bf SetSize(size)}}{}
3300 \twocolitem{{\bf SetPosition(point)}}{}
3301 \end{twocollist}}
3302 }
3303
3304
3305 \membersection{wxWindow::SetSizeHints}\label{wxwindowsetsizehints}
3306
3307 Use of this function for windows which are not toplevel windows
3308 (such as wxDialog or wxFrame) is discouraged. Please use
3309 \helpref{SetMinSize}{wxwindowsetminsize} and \helpref{SetMaxSize}{wxwindowsetmaxsize}
3310 instead.
3311
3312 \wxheading{See also}
3313
3314 \helpref{wxTopLevelWindow::SetSizeHints}{wxtoplevelwindowsetsizehints}.
3315
3316
3317 \membersection{wxWindow::SetSizer}\label{wxwindowsetsizer}
3318
3319 \func{void}{SetSizer}{\param{wxSizer* }{sizer}, \param{bool }{deleteOld=true}}
3320
3321 Sets the window to have the given layout sizer. The window
3322 will then own the object, and will take care of its deletion.
3323 If an existing layout constraints object is already owned by the
3324 window, it will be deleted if the deleteOld parameter is true.
3325
3326 Note that this function will also call
3327 \helpref{SetAutoLayout}{wxwindowsetautolayout} implicitly with {\tt true}
3328 parameter if the {\it sizer}\/ is non-NULL and {\tt false} otherwise.
3329
3330 \wxheading{Parameters}
3331
3332 \docparam{sizer}{The sizer to set. Pass NULL to disassociate and conditionally delete
3333 the window's sizer. See below.}
3334
3335 \docparam{deleteOld}{If true (the default), this will delete any prexisting sizer.
3336 Pass false if you wish to handle deleting the old sizer yourself.}
3337
3338 \wxheading{Remarks}
3339
3340 SetSizer now enables and disables Layout automatically, but prior to wxWidgets 2.3.3
3341 the following applied:
3342
3343 You must call \helpref{wxWindow::SetAutoLayout}{wxwindowsetautolayout} to tell a window to use
3344 the sizer automatically in OnSize; otherwise, you must override OnSize and call Layout()
3345 explicitly. When setting both a wxSizer and a \helpref{wxLayoutConstraints}{wxlayoutconstraints},
3346 only the sizer will have effect.
3347
3348
3349 \membersection{wxWindow::SetSizerAndFit}\label{wxwindowsetsizerandfit}
3350
3351 \func{void}{SetSizerAndFit}{\param{wxSizer* }{sizer}, \param{bool }{deleteOld=true}}
3352
3353 The same as \helpref{SetSizer}{wxwindowsetsizer}, except it also sets the size hints
3354 for the window based on the sizer's minimum size.
3355
3356
3357 \membersection{wxWindow::SetThemeEnabled}\label{wxwindowsetthemeenabled}
3358
3359 \func{virtual void}{SetThemeEnabled}{\param{bool }{enable}}
3360
3361 This function tells a window if it should use the system's "theme" code
3362 to draw the windows' background instead if its own background drawing
3363 code. This does not always have any effect since the underlying platform
3364 obviously needs to support the notion of themes in user defined windows.
3365 One such platform is GTK+ where windows can have (very colourful) backgrounds
3366 defined by a user's selected theme.
3367
3368 Dialogs, notebook pages and the status bar have this flag set to true
3369 by default so that the default look and feel is simulated best.
3370
3371
3372 \membersection{wxWindow::SetToolTip}\label{wxwindowsettooltip}
3373
3374 \func{void}{SetToolTip}{\param{const wxString\& }{tip}}
3375
3376 \func{void}{SetToolTip}{\param{wxToolTip* }{tip}}
3377
3378 Attach a tooltip to the window.
3379
3380 See also: \helpref{GetToolTip}{wxwindowgettooltip},
3381 \helpref{wxToolTip}{wxtooltip}
3382
3383
3384 \membersection{wxWindow::SetValidator}\label{wxwindowsetvalidator}
3385
3386 \func{virtual void}{SetValidator}{\param{const wxValidator\&}{ validator}}
3387
3388 Deletes the current validator (if any) and sets the window validator, having called wxValidator::Clone to
3389 create a new validator of this type.
3390
3391
3392 \membersection{wxWindow::SetVirtualSize}\label{wxwindowsetvirtualsize}
3393
3394 \func{void}{SetVirtualSize}{\param{int}{ width}, \param{int}{ height}}
3395
3396 \func{void}{SetVirtualSize}{\param{const wxSize\&}{ size}}
3397
3398 Sets the virtual size of the window in pixels.
3399
3400
3401 \membersection{wxWindow::SetVirtualSizeHints}\label{wxwindowsetvirtualsizehints}
3402
3403 \func{virtual void}{SetVirtualSizeHints}{\param{int}{ minW},\param{int}{ minH}, \param{int}{ maxW=-1}, \param{int}{ maxH=-1}}
3404
3405 \func{void}{SetVirtualSizeHints}{\param{const wxSize\&}{ minSize=wxDefaultSize},
3406 \param{const wxSize\&}{ maxSize=wxDefaultSize}}
3407
3408
3409 Allows specification of minimum and maximum virtual window sizes.
3410 If a pair of values is not set (or set to -1), the default values
3411 will be used.
3412
3413 \wxheading{Parameters}
3414
3415 \docparam{minW}{Specifies the minimum width allowable.}
3416
3417 \docparam{minH}{Specifies the minimum height allowable.}
3418
3419 \docparam{maxW}{Specifies the maximum width allowable.}
3420
3421 \docparam{maxH}{Specifies the maximum height allowable.}
3422
3423 \docparam{minSize}{Minimum size.}
3424
3425 \docparam{maxSize}{Maximum size.}
3426
3427 \wxheading{Remarks}
3428
3429 If this function is called, the user will not be able to size the virtual area
3430 of the window outside the given bounds.
3431
3432
3433 \membersection{wxWindow::SetWindowStyle}\label{wxwindowsetwindowstyle}
3434
3435 \func{void}{SetWindowStyle}{\param{long}{ style}}
3436
3437 Identical to \helpref{SetWindowStyleFlag}{wxwindowsetwindowstyleflag}.
3438
3439
3440 \membersection{wxWindow::SetWindowStyleFlag}\label{wxwindowsetwindowstyleflag}
3441
3442 \func{virtual void}{SetWindowStyleFlag}{\param{long}{ style}}
3443
3444 Sets the style of the window. Please note that some styles cannot be changed
3445 after the window creation and that \helpref{Refresh()}{wxwindowrefresh} might
3446 need to be be called after changing the others for the change to take place
3447 immediately.
3448
3449 See \helpref{Window styles}{windowstyles} for more information about flags.
3450
3451 \wxheading{See also}
3452
3453 \helpref{GetWindowStyleFlag}{wxwindowgetwindowstyleflag}
3454
3455
3456 \membersection{wxWindow::SetWindowVariant}\label{wxwindowsetwindowvariant}
3457
3458 \func{void}{SetWindowVariant}{\param{wxWindowVariant}{variant}}
3459
3460 This function can be called under all platforms but only does anything under
3461 Mac OS X 10.3+ currently. Under this system, each of the standard control can
3462 exist in several sizes which correspond to the elements of wxWindowVariant
3463 enum:
3464 \begin{verbatim}
3465 enum wxWindowVariant
3466 {
3467 wxWINDOW_VARIANT_NORMAL, // Normal size
3468 wxWINDOW_VARIANT_SMALL, // Smaller size (about 25 % smaller than normal )
3469 wxWINDOW_VARIANT_MINI, // Mini size (about 33 % smaller than normal )
3470 wxWINDOW_VARIANT_LARGE, // Large size (about 25 % larger than normal )
3471 };
3472 \end{verbatim}
3473
3474 By default the controls use the normal size, of course, but this function can
3475 be used to change this.
3476
3477
3478 \membersection{wxWindow::ShouldInheritColours}\label{wxwindowshouldinheritcolours}
3479
3480 \func{virtual bool}{ShouldInheritColours}{\void}
3481
3482 Return \true from here to allow the colours of this window to be changed by
3483 \helpref{InheritAttributes}{wxwindowinheritattributes}, returning \false
3484 forbids inheriting them from the parent window.
3485
3486 The base class version returns \false, but this method is overridden in
3487 \helpref{wxControl}{wxcontrol} where it returns \true.
3488
3489
3490 \membersection{wxWindow::Show}\label{wxwindowshow}
3491
3492 \func{virtual bool}{Show}{\param{bool}{ show = {\tt true}}}
3493
3494 Shows or hides the window. You may need to call \helpref{Raise}{wxwindowraise}
3495 for a top level window if you want to bring it to top, although this is not
3496 needed if Show() is called immediately after the frame creation.
3497
3498 \wxheading{Parameters}
3499
3500 \docparam{show}{If {\tt true} displays the window. Otherwise, hides it.}
3501
3502 \wxheading{Return value}
3503
3504 {\tt true} if the window has been shown or hidden or {\tt false} if nothing was
3505 done because it already was in the requested state.
3506
3507 \wxheading{See also}
3508
3509 \helpref{wxWindow::IsShown}{wxwindowisshown},\rtfsp
3510 \helpref{wxWindow::Hide}{wxwindowhide},\rtfsp
3511 \helpref{wxRadioBox::Show}{wxradioboxshow}
3512
3513
3514 \membersection{wxWindow::Thaw}\label{wxwindowthaw}
3515
3516 \func{virtual void}{Thaw}{\void}
3517
3518 Reenables window updating after a previous call to
3519 \helpref{Freeze}{wxwindowfreeze}. To really thaw the control, it must be called
3520 exactly the same number of times as \helpref{Freeze}{wxwindowfreeze}.
3521
3522 \wxheading{See also}
3523
3524 \helpref{wxWindowUpdateLocker}{wxwindowupdatelocker}
3525
3526
3527 \membersection{wxWindow::ToggleWindowStyle}\label{wxwindowtogglewindowstyle}
3528
3529 \func{bool}{ToggleWindowStyle}{\param{int }{flag}}
3530
3531 Turns the given \arg{flag} on if it's currently turned off and vice versa.
3532 This function cannot be used if the value of the flag is $0$ (which is often
3533 the case for default flags).
3534
3535 Also, please notice that not all styles can be changed after the control
3536 creation.
3537
3538 \wxheading{Return value}
3539
3540 Returns \true if the style was turned on by this function, \false if it was
3541 switched off.
3542
3543 \wxheading{See also}
3544
3545 \helpref{wxWindow::SetWindowStyleFlag}{wxwindowsetwindowstyleflag},\rtfsp
3546 \helpref{wxWindow::HasFlag}{wxwindowhasflag}
3547
3548
3549 \membersection{wxWindow::TransferDataFromWindow}\label{wxwindowtransferdatafromwindow}
3550
3551 \func{virtual bool}{TransferDataFromWindow}{\void}
3552
3553 Transfers values from child controls to data areas specified by their validators. Returns
3554 {\tt false} if a transfer failed.
3555
3556 If the window has {\tt wxWS\_EX\_VALIDATE\_RECURSIVELY} extra style flag set,
3557 the method will also call TransferDataFromWindow() of all child windows.
3558
3559 \wxheading{See also}
3560
3561 \helpref{wxWindow::TransferDataToWindow}{wxwindowtransferdatatowindow},\rtfsp
3562 \helpref{wxValidator}{wxvalidator}, \helpref{wxWindow::Validate}{wxwindowvalidate}
3563
3564
3565 \membersection{wxWindow::TransferDataToWindow}\label{wxwindowtransferdatatowindow}
3566
3567 \func{virtual bool}{TransferDataToWindow}{\void}
3568
3569 Transfers values to child controls from data areas specified by their validators.
3570
3571 If the window has {\tt wxWS\_EX\_VALIDATE\_RECURSIVELY} extra style flag set,
3572 the method will also call TransferDataToWindow() of all child windows.
3573
3574 \wxheading{Return value}
3575
3576 Returns {\tt false} if a transfer failed.
3577
3578 \wxheading{See also}
3579
3580 \helpref{wxWindow::TransferDataFromWindow}{wxwindowtransferdatafromwindow},\rtfsp
3581 \helpref{wxValidator}{wxvalidator}, \helpref{wxWindow::Validate}{wxwindowvalidate}
3582
3583
3584 \membersection{wxWindow::UnregisterHotKey}\label{wxwindowunregisterhotkey}
3585
3586 \func{bool}{UnregisterHotKey}{\param{int}{ hotkeyId}}
3587
3588 Unregisters a system wide hotkey.
3589
3590 \wxheading{Parameters}
3591
3592 \docparam{hotkeyId}{Numeric identifier of the hotkey. Must be the same id that was passed to RegisterHotKey.}
3593
3594 \wxheading{Return value}
3595
3596 {\tt true} if the hotkey was unregistered successfully, {\tt false} if the id was invalid.
3597
3598 \wxheading{Remarks}
3599
3600 This function is currently only implemented under MSW.
3601
3602 \wxheading{See also}
3603
3604 \helpref{wxWindow::RegisterHotKey}{wxwindowregisterhotkey}
3605
3606
3607 \membersection{wxWindow::Update}\label{wxwindowupdate}
3608
3609 \func{virtual void}{Update}{\void}
3610
3611 Calling this method immediately repaints the invalidated area of the window and
3612 all of its children recursively while this would usually only happen when the
3613 flow of control returns to the event loop.
3614 Notice that this function doesn't invalidate any area of the window so
3615 nothing happens if nothing has been invalidated (i.e. marked as requiring
3616 a redraw). Use \helpref{Refresh}{wxwindowrefresh} first if you want to
3617 immediately redraw the window unconditionally.
3618
3619
3620 \membersection{wxWindow::UpdateWindowUI}\label{wxwindowupdatewindowui}
3621
3622 \func{virtual void}{UpdateWindowUI}{\param{long}{ flags = wxUPDATE\_UI\_NONE}}
3623
3624 This function sends \helpref{wxUpdateUIEvents}{wxupdateuievent} to
3625 the window. The particular implementation depends on the window; for
3626 example a wxToolBar will send an update UI event for each toolbar button,
3627 and a wxFrame will send an update UI event for each menubar menu item.
3628 You can call this function from your application to ensure that your
3629 UI is up-to-date at this point (as far as your wxUpdateUIEvent handlers
3630 are concerned). This may be necessary if you have called
3631 \helpref{wxUpdateUIEvent::SetMode}{wxupdateuieventsetmode} or
3632 \helpref{wxUpdateUIEvent::SetUpdateInterval}{wxupdateuieventsetupdateinterval} to
3633 limit the overhead that wxWidgets incurs by sending update UI events in idle time.
3634
3635 {\it flags} should be a bitlist of one or more of the following values.
3636
3637 \begin{verbatim}
3638 enum wxUpdateUI
3639 {
3640 wxUPDATE_UI_NONE = 0x0000, // No particular value
3641 wxUPDATE_UI_RECURSE = 0x0001, // Call the function for descendants
3642 wxUPDATE_UI_FROMIDLE = 0x0002 // Invoked from On(Internal)Idle
3643 };
3644 \end{verbatim}
3645
3646 If you are calling this function from an OnInternalIdle or OnIdle
3647 function, make sure you pass the wxUPDATE\_UI\_FROMIDLE flag, since
3648 this tells the window to only update the UI elements that need
3649 to be updated in idle time. Some windows update their elements
3650 only when necessary, for example when a menu is about to be shown.
3651 The following is an example of how to call UpdateWindowUI from
3652 an idle function.
3653
3654 \begin{verbatim}
3655 void MyWindow::OnInternalIdle()
3656 {
3657 if (wxUpdateUIEvent::CanUpdate(this))
3658 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
3659 }
3660 \end{verbatim}
3661
3662 \wxheading{See also}
3663
3664 \helpref{wxUpdateUIEvent}{wxupdateuievent},
3665 \helpref{wxWindow::DoUpdateWindowUI}{wxwindowdoupdatewindowui},
3666 \helpref{wxWindow::OnInternalIdle}{wxwindowoninternalidle}
3667
3668
3669 \membersection{wxWindow::Validate}\label{wxwindowvalidate}
3670
3671 \func{virtual bool}{Validate}{\void}
3672
3673 Validates the current values of the child controls using their validators.
3674
3675 If the window has {\tt wxWS\_EX\_VALIDATE\_RECURSIVELY} extra style flag set,
3676 the method will also call Validate() of all child windows.
3677
3678 \wxheading{Return value}
3679
3680 Returns {\tt false} if any of the validations failed.
3681
3682 \wxheading{See also}
3683
3684 \helpref{wxWindow::TransferDataFromWindow}{wxwindowtransferdatafromwindow},\rtfsp
3685 \helpref{wxWindow::TransferDataToWindow}{wxwindowtransferdatatowindow},\rtfsp
3686 \helpref{wxValidator}{wxvalidator}
3687
3688
3689 \membersection{wxWindow::WarpPointer}\label{wxwindowwarppointer}
3690
3691 \func{void}{WarpPointer}{\param{int}{ x}, \param{int}{ y}}
3692
3693 Moves the pointer to the given position on the window.
3694
3695 {\bf NB: } This function is not supported under Mac because Apple Human
3696 Interface Guidelines forbid moving the mouse cursor programmatically.
3697
3698 \wxheading{Parameters}
3699
3700 \docparam{x}{The new x position for the cursor.}
3701
3702 \docparam{y}{The new y position for the cursor.}
3703