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