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