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