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