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