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