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