1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: interface of wxWindow
4 // Author: wxWidgets team
6 // Licence: wxWindows licence
7 /////////////////////////////////////////////////////////////////////////////
11 Valid values for wxWindow::ShowWithEffect() and wxWindow::HideWithEffect().
16 No effect, equivalent to normal wxWindow::Show() or Hide() call.
22 /// Roll window to the left
23 wxSHOW_EFFECT_ROLL_TO_LEFT
,
25 /// Roll window to the right
26 wxSHOW_EFFECT_ROLL_TO_RIGHT
,
28 /// Roll window to the top
29 wxSHOW_EFFECT_ROLL_TO_TOP
,
31 /// Roll window to the bottom
32 wxSHOW_EFFECT_ROLL_TO_BOTTOM
,
34 /// Slide window to the left
35 wxSHOW_EFFECT_SLIDE_TO_LEFT
,
37 /// Slide window to the right
38 wxSHOW_EFFECT_SLIDE_TO_RIGHT
,
40 /// Slide window to the top
41 wxSHOW_EFFECT_SLIDE_TO_TOP
,
43 /// Slide window to the bottom
44 wxSHOW_EFFECT_SLIDE_TO_BOTTOM
,
46 /// Fade in or out effect
49 /// Expanding or collapsing effect
58 Struct containing all the visual attributes of a control.
60 struct wxVisualAttributes
62 /// The font used for control label/text inside it.
65 /// The foreground colour.
69 The background colour.
71 May be wxNullColour if the controls background colour is not solid.
78 Different window variants, on platforms like eg mac uses different
83 wxWINDOW_VARIANT_NORMAL
, //!< Normal size
84 wxWINDOW_VARIANT_SMALL
, //!< Smaller size (about 25 % smaller than normal)
85 wxWINDOW_VARIANT_MINI
, //!< Mini size (about 33 % smaller than normal)
86 wxWINDOW_VARIANT_LARGE
, //!< Large size (about 25 % larger than normal)
94 wxWindow is the base class for all windows and represents any visible object
95 on screen. All controls, top level windows and so on are windows. Sizers and
96 device contexts are not, however, as they don't appear on screen themselves.
98 Please note that all children of the window will be deleted automatically by
99 the destructor before the window itself is deleted which means that you don't
100 have to worry about deleting them manually. Please see the @ref
101 overview_windowdeletion "window deletion overview" for more information.
103 Also note that in this, and many others, wxWidgets classes some
104 @c GetXXX() methods may be overloaded (as, for example,
105 wxWindow::GetSize or wxWindow::GetClientSize). In this case, the overloads
106 are non-virtual because having multiple virtual functions with the same name
107 results in a virtual function name hiding at the derived class level (in
108 English, this means that the derived class has to override all overloaded
109 variants if it overrides any of them). To allow overriding them in the derived
110 class, wxWidgets uses a unique protected virtual @c DoGetXXX() method
111 and all @c GetXXX() ones are forwarded to it, so overriding the former
112 changes the behaviour of the latter.
115 @style{wxBORDER_DEFAULT}
116 The window class will decide the kind of border to show, if any.
117 @style{wxBORDER_SIMPLE}
118 Displays a thin border around the window. wxSIMPLE_BORDER is the
119 old name for this style.
120 @style{wxBORDER_SUNKEN}
121 Displays a sunken border. wxSUNKEN_BORDER is the old name for this
123 @style{wxBORDER_RAISED}
124 Displays a raised border. wxRAISED_BORDER is the old name for this
126 @style{wxBORDER_STATIC}
127 Displays a border suitable for a static control. wxSTATIC_BORDER
128 is the old name for this style. Windows only.
129 @style{wxBORDER_THEME}
130 Displays a native border suitable for a control, on the current
131 platform. On Windows XP or Vista, this will be a themed border; on
132 most other platforms a sunken border will be used. For more
133 information for themed borders on Windows, please see Themed
135 @style{wxBORDER_NONE}
136 Displays no border, overriding the default border style for the
137 window. wxNO_BORDER is the old name for this style.
138 @style{wxBORDER_DOUBLE}
139 This style is obsolete and should not be used.
140 @style{wxTRANSPARENT_WINDOW}
141 The window is transparent, that is, it will not receive paint
142 events. Windows only.
143 @style{wxTAB_TRAVERSAL}
144 Use this to enable tab traversal for non-dialog windows.
145 @style{wxWANTS_CHARS}
146 Use this to indicate that the window wants to get all char/key
147 events for all keys - even for keys like TAB or ENTER which are
148 usually used for dialog navigation and which wouldn't be generated
149 without this style. If you need to use this style in order to get
150 the arrows or etc., but would still like to have normal keyboard
151 navigation take place, you should call Navigate in response to the
152 key events for Tab and Shift-Tab.
153 @style{wxNO_FULL_REPAINT_ON_RESIZE}
154 On Windows, this style used to disable repainting the window
155 completely when its size is changed. Since this behaviour is now
156 the default, the style is now obsolete and no longer has an effect.
158 Use this style to enable a vertical scrollbar. Notice that this
159 style cannot be used with native controls which don't support
160 scrollbars nor with top-level windows in most ports.
162 Use this style to enable a horizontal scrollbar. The same
163 limitations as for wxVSCROLL apply to this style.
164 @style{wxALWAYS_SHOW_SB}
165 If a window has scrollbars, disable them instead of hiding them
166 when they are not needed (i.e. when the size of the window is big
167 enough to not require the scrollbars to navigate it). This style is
168 currently implemented for wxMSW, wxGTK and wxUniversal and does
169 nothing on the other platforms.
170 @style{wxCLIP_CHILDREN}
171 Use this style to eliminate flicker caused by the background being
172 repainted, then children being painted over them. Windows only.
173 @style{wxFULL_REPAINT_ON_RESIZE}
174 Use this style to force a complete redraw of the window whenever it
175 is resized instead of redrawing just the part of the window
176 affected by resizing. Note that this was the behaviour by default
177 before 2.5.1 release and that if you experience redraw problems
178 with code which previously used to work you may want to try this.
179 Currently this style applies on GTK+ 2 and Windows only, and full
180 repainting is always done on other platforms.
183 @beginExtraStyleTable
184 @style{wxWS_EX_VALIDATE_RECURSIVELY}
185 By default, wxWindow::Validate(), wxWindow::TransferDataTo() and
186 wxWindow::TransferDataFromWindow() only work on
187 direct children of the window (compatible behaviour).
188 Set this flag to make them recursively descend into all subwindows.
189 @style{wxWS_EX_BLOCK_EVENTS}
190 wxCommandEvents and the objects of the derived classes are
191 forwarded to the parent window and so on recursively by default.
192 Using this flag for the given window allows to block this
193 propagation at this window, i.e. prevent the events from being
194 propagated further upwards. Dialogs have this flag on by default
195 for the reasons explained in the @ref overview_events.
196 @style{wxWS_EX_TRANSIENT}
197 Don't use this window as an implicit parent for the other windows:
198 this must be used with transient windows as otherwise there is the
199 risk of creating a dialog/frame with this window as a parent, which
200 would lead to a crash if the parent were destroyed before the child.
201 @style{wxWS_EX_CONTEXTHELP}
202 Under Windows, puts a query button on the caption. When pressed,
203 Windows will go into a context-sensitive help mode and wxWidgets
204 will send a @c wxEVT_HELP event if the user clicked on an application window.
205 This style cannot be used (because of the underlying native behaviour)
206 together with @c wxMAXIMIZE_BOX or @c wxMINIMIZE_BOX, so these two styles
207 are automatically turned off if this one is used.
208 @style{wxWS_EX_PROCESS_IDLE}
209 This window should always process idle events, even if the mode set
210 by wxIdleEvent::SetMode is @c wxIDLE_PROCESS_SPECIFIED.
211 @style{wxWS_EX_PROCESS_UI_UPDATES}
212 This window should always process UI update events, even if the
213 mode set by wxUpdateUIEvent::SetMode is @c wxUPDATE_UI_PROCESS_SPECIFIED.
216 @beginEventEmissionTable
217 @event{EVT_ACTIVATE(id, func)}
218 Process a @c wxEVT_ACTIVATE event. See wxActivateEvent.
219 @event{EVT_CHILD_FOCUS(func)}
220 Process a @c wxEVT_CHILD_FOCUS event. See wxChildFocusEvent.
221 @event{EVT_CONTEXT_MENU(func)}
222 A right click (or other context menu command depending on platform) has been detected.
223 See wxContextMenuEvent.
224 @event{EVT_HELP(id, func)}
225 Process a @c wxEVT_HELP event. See wxHelpEvent.
226 @event{EVT_HELP_RANGE(id1, id2, func)}
227 Process a @c wxEVT_HELP event for a range of ids. See wxHelpEvent.
228 @event{EVT_DROP_FILES(func)}
229 Process a @c wxEVT_DROP_FILES event. See wxDropFilesEvent.
230 @event{EVT_ERASE_BACKGROUND(func)}
231 Process a @c wxEVT_ERASE_BACKGROUND event. See wxEraseEvent.
232 @event{EVT_SET_FOCUS(func)}
233 Process a @c wxEVT_SET_FOCUS event. See wxFocusEvent.
234 @event{EVT_KILL_FOCUS(func)}
235 Process a @c wxEVT_KILL_FOCUS event. See wxFocusEvent.
236 @event{EVT_IDLE(func)}
237 Process a @c wxEVT_IDLE event. See wxIdleEvent.
238 @event{EVT_JOY_*(func)}
239 Processes joystick events. See wxJoystickEvent.
240 @event{EVT_KEY_DOWN(func)}
241 Process a @c wxEVT_KEY_DOWN event (any key has been pressed).
243 @event{EVT_KEY_UP(func)}
244 Process a @c wxEVT_KEY_UP event (any key has been released).
246 @event{EVT_CHAR(func)}
247 Process a @c wxEVT_CHAR event.
249 @event{EVT_CHAR_HOOK(func)}
250 Process a @c wxEVT_CHAR_HOOK event.
252 @event{EVT_MOUSE_CAPTURE_LOST(func)}
253 Process a @c wxEVT_MOUSE_CAPTURE_LOST event. See wxMouseCaptureLostEvent.
254 @event{EVT_MOUSE_CAPTURE_CHANGED(func)}
255 Process a @c wxEVT_MOUSE_CAPTURE_CHANGED event. See wxMouseCaptureChangedEvent.
256 @event{EVT_MOUSE_*(func)}
258 @event{EVT_PAINT(func)}
259 Process a @c wxEVT_PAINT event. See wxPaintEvent.
260 @event{EVT_POWER_*(func)}
261 The system power state changed. See wxPowerEvent.
262 @event{EVT_SCROLLWIN_*(func)}
263 Process scroll events. See wxScrollWinEvent.
264 @event{EVT_SET_CURSOR(func)}
265 Process a @c wxEVT_SET_CURSOR event. See wxSetCursorEvent.
266 @event{EVT_SIZE(func)}
267 Process a @c wxEVT_SIZE event. See wxSizeEvent.
268 @event{EVT_SYS_COLOUR_CHANGED(func)}
269 Process a @c wxEVT_SYS_COLOUR_CHANGED event. See wxSysColourChangedEvent.
275 @see @ref overview_events, @ref overview_windowsizing
277 class wxWindow
: public wxEvtHandler
286 Constructs a window, which can be a child of a frame, dialog or any other
290 Pointer to a parent window.
292 Window identifier. If wxID_ANY, will automatically create an identifier.
294 Window position. wxDefaultPosition indicates that wxWidgets
295 should generate a default position for the window.
296 If using the wxWindow class directly, supply an actual position.
298 Window size. wxDefaultSize indicates that wxWidgets should generate
299 a default size for the window. If no suitable size can be found, the
300 window will be sized to 20x20 pixels so that the window is visible but
301 obviously not correctly sized.
303 Window style. For generic window styles, please see wxWindow.
307 wxWindow(wxWindow
* parent
, wxWindowID id
,
308 const wxPoint
& pos
= wxDefaultPosition
,
309 const wxSize
& size
= wxDefaultSize
,
311 const wxString
& name
= wxPanelNameStr
);
316 Deletes all sub-windows, then deletes itself. Instead of using
317 the @b delete operator explicitly, you should normally use Destroy()
318 so that wxWidgets can delete a window only when it is safe to do so, in idle time.
320 @see @ref overview_windowdeletion "Window Deletion Overview",
321 Destroy(), wxCloseEvent
326 bool Create(wxWindow
*parent
,
328 const wxPoint
& pos
= wxDefaultPosition
,
329 const wxSize
& size
= wxDefaultSize
,
331 const wxString
& name
= wxPanelNameStr
);
334 @name Focus functions
336 See also the static function FindFocus().
341 This method may be overridden in the derived classes to return @false to
342 indicate that this control doesn't accept input at all (i.e. behaves like
343 e.g. wxStaticText) and so doesn't need focus.
345 @see AcceptsFocusFromKeyboard()
347 virtual bool AcceptsFocus() const;
350 This method may be overridden in the derived classes to return @false to
351 indicate that while this control can, in principle, have focus if the user
352 clicks it with the mouse, it shouldn't be included in the TAB traversal chain
353 when using the keyboard.
355 virtual bool AcceptsFocusFromKeyboard() const;
358 Overridden to indicate whether this window or one of its children accepts
359 focus. Usually it's the same as AcceptsFocus() but is overridden for
362 virtual bool AcceptsFocusRecursively() const;
365 Returns @true if the window (or in case of composite controls, its main
366 child window) has focus.
370 virtual bool HasFocus() const;
373 This method is only implemented by ports which have support for
374 native TAB traversal (such as GTK+ 2.0).
376 It is called by wxWidgets' container control code to give the native
377 system a hint when doing TAB traversal. A call to this does not disable
378 or change the effect of programmatically calling SetFocus().
380 @see wxFocusEvent, wxPanel::SetFocus, wxPanel::SetFocusIgnoringChildren
382 virtual void SetCanFocus(bool canFocus
);
385 This sets the window to receive keyboard input.
387 @see HasFocus(), wxFocusEvent, wxPanel::SetFocus,
388 wxPanel::SetFocusIgnoringChildren
390 virtual void SetFocus();
393 This function is called by wxWidgets keyboard navigation code when the user
394 gives the focus to this window from keyboard (e.g. using @c TAB key).
396 By default this method simply calls SetFocus() but
397 can be overridden to do something in addition to this in the derived classes.
399 virtual void SetFocusFromKbd();
405 @name Child management functions
410 Adds a child window. This is called automatically by window creation
411 functions so should not be required by the application programmer.
412 Notice that this function is mostly internal to wxWidgets and shouldn't be
413 called by the user code.
418 virtual void AddChild(wxWindow
* child
);
421 Destroys all children of a window. Called automatically by the destructor.
423 bool DestroyChildren();
426 Find a child of this window, by @a id.
427 May return @a this if it matches itself.
429 wxWindow
* FindWindow(long id
) const;
432 Find a child of this window, by name.
433 May return @a this if it matches itself.
435 wxWindow
* FindWindow(const wxString
& name
) const;
438 Returns a reference to the list of the window's children. @c wxWindowList
439 is a type-safe wxList-like class whose elements are of type @c wxWindow*.
441 wxWindowList
& GetChildren();
446 const wxWindowList
& GetChildren() const;
449 Removes a child window.
451 This is called automatically by window deletion functions so should not
452 be required by the application programmer.
453 Notice that this function is mostly internal to wxWidgets and shouldn't be
454 called by the user code.
457 Child window to remove.
459 virtual void RemoveChild(wxWindow
* child
);
465 @name Sibling and parent management functions
470 Returns the grandparent of a window, or @NULL if there isn't one.
472 wxWindow
* GetGrandParent() const;
475 Returns the next window after this one among the parent's children or @NULL
476 if this window is the last child.
480 @see GetPrevSibling()
482 wxWindow
* GetNextSibling() const;
485 Returns the parent of the window, or @NULL if there is no parent.
487 wxWindow
* GetParent() const;
490 Returns the previous window before this one among the parent's children or @c
491 @NULL if this window is the first child.
495 @see GetNextSibling()
497 wxWindow
* GetPrevSibling() const;
500 Check if the specified window is a descendant of this one.
502 Returns @true if the window is a descendant (i.e. a child or
503 grand-child or grand-grand-child or ...) of this one.
505 Notice that a window can never be a descendant of another one if they
506 are in different top level windows, i.e. a child of a wxDialog is not
507 considered to be a descendant of dialogs parent wxFrame.
509 @param win Any window, possible @NULL (@false is always returned then).
513 bool IsDescendant(wxWindowBase
* win
) const;
516 Reparents the window, i.e. the window will be removed from its
517 current parent window (e.g. a non-standard toolbar in a wxFrame)
518 and then re-inserted into another.
520 Notice that currently you need to explicitly call
521 wxNotebook::RemovePage() before reparenting a notebook page.
526 virtual bool Reparent(wxWindow
* newParent
);
532 @name Scrolling and scrollbars functions
534 Note that these methods don't work with native controls which don't use
535 wxWidgets scrolling framework (i.e. don't derive from wxScrolledWindow).
540 Call this function to force one or both scrollbars to be always shown, even if
541 the window is big enough to show its entire contents without scrolling.
546 Whether the horizontal scroll bar should always be visible.
548 Whether the vertical scroll bar should always be visible.
550 @remarks This function is currently only implemented under Mac/Carbon.
552 virtual void AlwaysShowScrollbars(bool hflag
= true, bool vflag
= true);
555 Returns the built-in scrollbar position.
559 virtual int GetScrollPos(int orientation
) const;
562 Returns the built-in scrollbar range.
566 virtual int GetScrollRange(int orientation
) const;
569 Returns the built-in scrollbar thumb size.
573 virtual int GetScrollThumb(int orientation
) const;
576 Returns @true if this window can have a scroll bar in this orientation.
579 Orientation to check, either wxHORIZONTAL or wxVERTICAL.
583 bool CanScroll(int orient
) const;
586 Returns @true if this window currently has a scroll bar for this
589 This method may return @false even when CanScroll() for the same
590 orientation returns @true, but if CanScroll() returns @false, i.e.
591 scrolling in this direction is not enabled at all, HasScrollbar()
592 always returns @false as well.
595 Orientation to check, either wxHORIZONTAL or wxVERTICAL.
597 bool HasScrollbar(int orient
) const;
600 Return whether a scrollbar is always shown.
603 Orientation to check, either wxHORIZONTAL or wxVERTICAL.
605 @see AlwaysShowScrollbars()
607 virtual bool IsScrollbarAlwaysShown(int orient
) const;
610 Scrolls the window by the given number of lines down (if @a lines is
613 @return Returns @true if the window was scrolled, @false if it was already
614 on top/bottom and nothing was done.
616 @remarks This function is currently only implemented under MSW and
617 wxTextCtrl under wxGTK (it also works for wxScrolled classes
618 under all platforms).
622 virtual bool ScrollLines(int lines
);
625 Scrolls the window by the given number of pages down (if @a pages is
628 @return Returns @true if the window was scrolled, @false if it was already
629 on top/bottom and nothing was done.
631 @remarks This function is currently only implemented under MSW and wxGTK.
635 virtual bool ScrollPages(int pages
);
638 Physically scrolls the pixels in the window and move child windows accordingly.
641 Amount to scroll horizontally.
643 Amount to scroll vertically.
645 Rectangle to scroll, if it is @NULL, the whole window is
646 scrolled (this is always the case under wxGTK which doesn't support this
649 @remarks Note that you can often use wxScrolled instead of using this
652 virtual void ScrollWindow(int dx
, int dy
,
653 const wxRect
* rect
= NULL
);
656 Same as #ScrollLines (-1).
661 Same as #ScrollLines (1).
666 Same as #ScrollPages (-1).
671 Same as #ScrollPages (1).
676 Sets the position of one of the built-in scrollbars.
679 Determines the scrollbar whose position is to be set.
680 May be wxHORIZONTAL or wxVERTICAL.
682 Position in scroll units.
684 @true to redraw the scrollbar, @false otherwise.
686 @remarks This function does not directly affect the contents of the
687 window: it is up to the application to take note of
688 scrollbar attributes and redraw contents accordingly.
690 @see SetScrollbar(), GetScrollPos(), GetScrollThumb(), wxScrollBar,
693 virtual void SetScrollPos(int orientation
, int pos
,
694 bool refresh
= true);
697 Sets the scrollbar properties of a built-in scrollbar.
700 Determines the scrollbar whose page size is to be set.
701 May be wxHORIZONTAL or wxVERTICAL.
703 The position of the scrollbar in scroll units.
705 The size of the thumb, or visible portion of the scrollbar, in scroll units.
707 The maximum position of the scrollbar. Value of -1 can be used to
708 ask for the scrollbar to be shown but in the disabled state: this
709 can be used to avoid removing the scrollbar even when it is not
710 needed (currently this is only implemented in wxMSW port).
712 @true to redraw the scrollbar, @false otherwise.
715 Let's say you wish to display 50 lines of text, using the same font.
716 The window is sized so that you can only see 16 lines at a time.
719 SetScrollbar(wxVERTICAL, 0, 16, 50);
721 Note that with the window at this size, the thumb position can never
722 go above 50 minus 16, or 34. You can determine how many lines are
723 currently visible by dividing the current view size by the character
725 When defining your own scrollbar behaviour, you will always need
726 to recalculate the scrollbar settings when the window size changes.
727 You could therefore put your scrollbar calculations and SetScrollbar
728 call into a function named AdjustScrollbars, which can be called
729 initially and also from your wxSizeEvent handler function.
731 @see @ref overview_scrolling, wxScrollBar, wxScrolled, wxScrollWinEvent
733 virtual void SetScrollbar(int orientation
, int position
,
734 int thumbSize
, int range
,
735 bool refresh
= true);
740 @name Sizing functions
742 See also the protected functions DoGetBestSize() and
743 DoGetBestClientSize().
748 Sets the cached best size value.
752 void CacheBestSize(const wxSize
& size
) const;
755 Converts client area size @a size to corresponding window size.
757 In other words, the returned value is what would GetSize() return if this
758 window had client area of given size. Components with wxDefaultCoord
759 value are left unchanged. Note that the conversion is not always
760 exact, it assumes that non-client area doesn't change and so doesn't
761 take into account things like menu bar (un)wrapping or (dis)appearance
766 @see WindowToClientSize()
768 virtual wxSize
ClientToWindowSize(const wxSize
& size
) const;
771 Converts window size @a size to corresponding client area size
772 In other words, the returned value is what would GetClientSize() return if
773 this window had given window size. Components with wxDefaultCoord value
776 Note that the conversion is not always exact, it assumes that
777 non-client area doesn't change and so doesn't take into account things
778 like menu bar (un)wrapping or (dis)appearance of the scrollbars.
782 @see ClientToWindowSize()
784 virtual wxSize
WindowToClientSize(const wxSize
& size
) const;
787 Sizes the window so that it fits around its subwindows.
789 This function won't do anything if there are no subwindows and will only really
790 work correctly if sizers are used for the subwindows layout.
792 Also, if the window has exactly one subwindow it is better (faster and the result
793 is more precise as Fit() adds some margin to account for fuzziness of its calculations)
797 window->SetClientSize(child->GetSize());
800 instead of calling Fit().
802 @see @ref overview_windowsizing
807 Similar to Fit(), but sizes the interior (virtual) size of a window.
809 Mainly useful with scrolled windows to reset scrollbars after sizing
810 changes that do not trigger a size event, and/or scrolled windows without
811 an interior sizer. This function similarly won't do anything if there are
814 virtual void FitInside();
817 This functions returns the best acceptable minimal size for the window.
819 For example, for a static control, it will be the minimal size such that the
820 control label is not truncated. For windows containing subwindows (typically
821 wxPanel), the size returned by this function will be the same as the size
822 the window would have had after calling Fit().
824 Override virtual DoGetBestSize() or, better, because it's usually more
825 convenient, DoGetBestClientSize() when writing your own custom window
826 class to change the value returned by this public non-virtual method.
828 @see CacheBestSize(), @ref overview_windowsizing
830 wxSize
GetBestSize() const;
833 Returns the best height needed by this window if it had the given width.
835 @see DoGetBestClientHeight()
839 int GetBestHeight(int width
) const;
842 Returns the best width needed by this window if it had the given height.
844 @see DoGetBestClientWidth()
848 int GetBestWidth(int height
) const;
851 Returns the size of the window 'client area' in pixels.
853 The client area is the area which may be drawn on by the programmer,
854 excluding title bar, border, scrollbars, etc.
855 Note that if this window is a top-level one and it is currently minimized, the
856 return size is empty (both width and height are 0).
859 In wxPerl this method takes no parameters and returns
860 a 2-element list (width, height).
863 @see GetSize(), GetVirtualSize()
865 void GetClientSize(int* width
, int* height
) const;
870 wxSize
GetClientSize() const;
873 Merges the window's best size into the min size and returns the result.
874 This is the value used by sizers to determine the appropriate
875 amount of space to allocate for the widget.
877 This is the method called by a wxSizer when it queries the size
878 of a window or control.
880 @see GetBestSize(), SetInitialSize(), @ref overview_windowsizing
882 virtual wxSize
GetEffectiveMinSize() const;
885 Returns the maximum size of window's client area.
887 This is an indication to the sizer layout mechanism that this is the maximum
888 possible size as well as the upper bound on window's size settable using
891 @see GetMaxSize(), @ref overview_windowsizing
893 virtual wxSize
GetMaxClientSize() const;
896 Returns the maximum size of the window.
898 This is an indication to the sizer layout mechanism that this is the maximum
899 possible size as well as the upper bound on window's size settable using SetSize().
901 @see GetMaxClientSize(), @ref overview_windowsizing
903 virtual wxSize
GetMaxSize() const;
906 Returns the minimum size of window's client area, an indication to the sizer
907 layout mechanism that this is the minimum required size of its client area.
909 It normally just returns the value set by SetMinClientSize(), but it can be
910 overridden to do the calculation on demand.
912 @see GetMinSize(), @ref overview_windowsizing
914 virtual wxSize
GetMinClientSize() const;
917 Returns the minimum size of the window, an indication to the sizer layout
918 mechanism that this is the minimum required size.
920 This method normally just returns the value set by SetMinSize(), but it
921 can be overridden to do the calculation on demand.
923 @see GetMinClientSize(), @ref overview_windowsizing
925 virtual wxSize
GetMinSize() const;
927 int GetMinWidth() const;
928 int GetMinHeight() const;
929 int GetMaxWidth() const;
930 int GetMaxHeight() const;
933 Returns the size of the entire window in pixels, including title bar, border,
936 Note that if this window is a top-level one and it is currently minimized, the
937 returned size is the restored window size, not the size of the window icon.
940 Receives the window width.
942 Receives the window height.
945 In wxPerl this method is implemented as GetSizeWH() returning
946 a 2-element list (width, height).
949 @see GetClientSize(), GetVirtualSize(), @ref overview_windowsizing
951 void GetSize(int* width
, int* height
) const;
954 See the GetSize(int*,int*) overload for more info.
956 wxSize
GetSize() const;
959 This gets the virtual size of the window in pixels.
960 By default it returns the client size of the window, but after a call to
961 SetVirtualSize() it will return the size set with that method.
963 @see @ref overview_windowsizing
965 wxSize
GetVirtualSize() const;
968 Like the other GetVirtualSize() overload but uses pointers instead.
971 Receives the window virtual width.
973 Receives the window virtual height.
975 void GetVirtualSize(int* width
, int* height
) const;
978 Return the largest of ClientSize and BestSize (as determined
979 by a sizer, interior children, or other means)
981 virtual wxSize
GetBestVirtualSize() const;
984 Returns the size of the left/right and top/bottom borders of this window in x
985 and y components of the result respectively.
987 virtual wxSize
GetWindowBorderSize() const;
990 wxSizer and friends use this to give a chance to a component to recalc
991 its min size once one of the final size components is known. Override
992 this function when that is useful (such as for wxStaticText which can
993 stretch over several lines). Parameter availableOtherDir
994 tells the item how much more space there is available in the opposite
995 direction (-1 if unknown).
998 InformFirstDirection(int direction
,
1000 int availableOtherDir
);
1003 Resets the cached best size value so it will be recalculated the next time it
1006 @see CacheBestSize()
1008 void InvalidateBestSize();
1011 Posts a size event to the window.
1013 This is the same as SendSizeEvent() with @c wxSEND_EVENT_POST argument.
1015 void PostSizeEvent();
1018 Posts a size event to the parent of this window.
1020 This is the same as SendSizeEventToParent() with @c wxSEND_EVENT_POST
1023 void PostSizeEventToParent();
1026 This function sends a dummy @ref wxSizeEvent "size event" to
1027 the window allowing it to re-layout its children positions.
1029 It is sometimes useful to call this function after adding or deleting a
1030 children after the frame creation or if a child size changes. Note that
1031 if the frame is using either sizers or constraints for the children
1032 layout, it is enough to call wxWindow::Layout() directly and this
1033 function should not be used in this case.
1035 If @a flags includes @c wxSEND_EVENT_POST value, this function posts
1036 the event, i.e. schedules it for later processing, instead of
1037 dispatching it directly. You can also use PostSizeEvent() as a more
1038 readable equivalent of calling this function with this flag.
1041 May include @c wxSEND_EVENT_POST. Default value is 0.
1043 virtual void SendSizeEvent(int flags
= 0);
1046 Safe wrapper for GetParent()->SendSizeEvent().
1048 This function simply checks that the window has a valid parent which is
1049 not in process of being deleted and calls SendSizeEvent() on it. It is
1050 used internally by windows such as toolbars changes to whose state
1051 should result in parent re-layout (e.g. when a toolbar is added to the
1052 top of the window, all the other windows must be shifted down).
1054 @see PostSizeEventToParent()
1057 See description of this parameter in SendSizeEvent() documentation.
1059 void SendSizeEventToParent(int flags
= 0);
1062 This sets the size of the window client area in pixels.
1064 Using this function to size a window tends to be more device-independent
1065 than SetSize(), since the application need not worry about what dimensions
1066 the border or title bar have when trying to fit the window around panel
1069 @see @ref overview_windowsizing
1071 void SetClientSize(int width
, int height
);
1076 void SetClientSize(const wxSize
& size
);
1081 void SetClientSize(const wxRect
& rect
);
1084 This normally does not need to be called by user code.
1085 It is called when a window is added to a sizer, and is used so the window
1086 can remove itself from the sizer when it is destroyed.
1088 void SetContainingSizer(wxSizer
* sizer
);
1091 A @e smart SetSize that will fill in default size components with the
1092 window's @e best size values.
1094 Also sets the window's minsize to the value passed in for use with sizers.
1095 This means that if a full or partial size is passed to this function then
1096 the sizers will use that size instead of the results of GetBestSize() to
1097 determine the minimum needs of the window for layout.
1099 Most controls will use this to set their initial size, and their min
1100 size to the passed in value (if any.)
1102 @see SetSize(), GetBestSize(), GetEffectiveMinSize(),
1103 @ref overview_windowsizing
1105 void SetInitialSize(const wxSize
& size
= wxDefaultSize
);
1108 Sets the maximum client size of the window, to indicate to the sizer
1109 layout mechanism that this is the maximum possible size of its client area.
1111 Note that this method is just a shortcut for:
1113 SetMaxSize(ClientToWindowSize(size));
1116 @see SetMaxSize(), @ref overview_windowsizing
1118 virtual void SetMaxClientSize(const wxSize
& size
);
1121 Sets the maximum size of the window, to indicate to the sizer layout mechanism
1122 that this is the maximum possible size.
1124 @see SetMaxClientSize(), @ref overview_windowsizing
1126 virtual void SetMaxSize(const wxSize
& size
);
1129 Sets the minimum client size of the window, to indicate to the sizer
1130 layout mechanism that this is the minimum required size of window's client
1133 You may need to call this if you change the window size after
1134 construction and before adding to its parent sizer.
1136 Note, that just as with SetMinSize(), calling this method doesn't
1137 prevent the program from explicitly making the window smaller than the
1140 Note that this method is just a shortcut for:
1142 SetMinSize(ClientToWindowSize(size));
1145 @see SetMinSize(), @ref overview_windowsizing
1147 virtual void SetMinClientSize(const wxSize
& size
);
1150 Sets the minimum size of the window, to indicate to the sizer layout
1151 mechanism that this is the minimum required size.
1153 You may need to call this if you change the window size after
1154 construction and before adding to its parent sizer.
1156 Notice that calling this method doesn't prevent the program from making
1157 the window explicitly smaller than the specified size by calling
1158 SetSize(), it just ensures that it won't become smaller than this size
1159 during the automatic layout.
1161 @see SetMinClientSize(), @ref overview_windowsizing
1163 virtual void SetMinSize(const wxSize
& size
);
1166 Sets the size of the window in pixels.
1169 Required x position in pixels, or wxDefaultCoord to indicate that the
1170 existing value should be used.
1172 Required y position in pixels, or wxDefaultCoord to indicate that the
1173 existing value should be used.
1175 Required width in pixels, or wxDefaultCoord to indicate that the existing
1176 value should be used.
1178 Required height position in pixels, or wxDefaultCoord to indicate that the
1179 existing value should be used.
1181 Indicates the interpretation of other parameters.
1182 It is a bit list of the following:
1183 - @c wxSIZE_AUTO_WIDTH: a wxDefaultCoord width value is taken to indicate
1184 a wxWidgets-supplied default width.
1185 - @c wxSIZE_AUTO_HEIGHT: a wxDefaultCoord height value is taken to indicate
1186 a wxWidgets-supplied default height.
1187 - @c wxSIZE_AUTO: wxDefaultCoord size values are taken to indicate
1188 a wxWidgets-supplied default size.
1189 - @c wxSIZE_USE_EXISTING: existing dimensions should be used
1190 if wxDefaultCoord values are supplied.
1191 - @c wxSIZE_ALLOW_MINUS_ONE: allow negative dimensions (i.e. value of
1192 wxDefaultCoord) to be interpreted as real
1193 dimensions, not default values.
1194 - @c wxSIZE_FORCE: normally, if the position and the size of the window are
1195 already the same as the parameters of this function,
1196 nothing is done. but with this flag a window resize may
1197 be forced even in this case (supported in wx 2.6.2 and
1198 later and only implemented for MSW and ignored elsewhere
1201 @remarks This overload sets the position and optionally size, of the window.
1202 Parameters may be wxDefaultCoord to indicate either that a default
1203 should be supplied by wxWidgets, or that the current value of the
1204 dimension should be used.
1206 @see Move(), @ref overview_windowsizing
1208 void SetSize(int x
, int y
, int width
, int height
,
1209 int sizeFlags
= wxSIZE_AUTO
);
1212 Sets the size of the window in pixels.
1213 The size is specified using a wxRect, wxSize or by a couple of @c int objects.
1215 @remarks This form must be used with non-default width and height values.
1217 @see Move(), @ref overview_windowsizing
1219 void SetSize(const wxRect
& rect
);
1224 void SetSize(const wxSize
& size
);
1229 void SetSize(int width
, int height
);
1232 Use of this function for windows which are not toplevel windows
1233 (such as wxDialog or wxFrame) is discouraged.
1234 Please use SetMinSize() and SetMaxSize() instead.
1236 @see wxTopLevelWindow::SetSizeHints, @ref overview_windowsizing
1238 virtual void SetSizeHints( const wxSize
& minSize
,
1239 const wxSize
& maxSize
=wxDefaultSize
,
1240 const wxSize
& incSize
=wxDefaultSize
);
1241 virtual void SetSizeHints( int minW
, int minH
,
1242 int maxW
= -1, int maxH
= -1,
1243 int incW
= -1, int incH
= -1 );
1246 Sets the virtual size of the window in pixels.
1248 @see @ref overview_windowsizing
1250 void SetVirtualSize(int width
, int height
);
1255 void SetVirtualSize(const wxSize
& size
);
1261 @name Positioning functions
1266 A synonym for Centre().
1268 void Center(int dir
= wxBOTH
);
1271 A synonym for CentreOnParent().
1273 void CenterOnParent(int dir
= wxBOTH
);
1279 Specifies the direction for the centring. May be wxHORIZONTAL, wxVERTICAL
1280 or wxBOTH. It may also include the wxCENTRE_ON_SCREEN flag
1281 if you want to centre the window on the entire screen and not on its
1284 @remarks If the window is a top level one (i.e. doesn't have a parent),
1285 it will be centred relative to the screen anyhow.
1289 void Centre(int direction
= wxBOTH
);
1292 Centres the window on its parent. This is a more readable synonym for Centre().
1295 Specifies the direction for the centring. May be wxHORIZONTAL, wxVERTICAL
1298 @remarks This methods provides for a way to centre top level windows over
1299 their parents instead of the entire screen. If there
1300 is no parent or if the window is not a top level
1301 window, then behaviour is the same as Centre().
1303 @see wxTopLevelWindow::CentreOnScreen
1305 void CentreOnParent(int direction
= wxBOTH
);
1308 This gets the position of the window in pixels, relative to the parent window
1309 for the child windows or relative to the display origin for the top level windows.
1312 Receives the x position of the window if non-@NULL.
1314 Receives the y position of the window if non-@NULL.
1317 In wxPerl this method is implemented as GetPositionXY() returning
1318 a 2-element list (x, y).
1321 @see GetScreenPosition()
1323 void GetPosition(int* x
, int* y
) const;
1326 This gets the position of the window in pixels, relative to the parent window
1327 for the child windows or relative to the display origin for the top level windows.
1329 @see GetScreenPosition()
1331 wxPoint
GetPosition() const;
1334 Returns the position and size of the window as a wxRect object.
1336 @see GetScreenRect()
1338 wxRect
GetRect() const;
1341 Returns the window position in screen coordinates, whether the window is a
1342 child window or a top level one.
1345 Receives the x position of the window on the screen if non-@NULL.
1347 Receives the y position of the window on the screen if non-@NULL.
1351 void GetScreenPosition(int* x
, int* y
) const;
1354 Returns the window position in screen coordinates, whether the window is a
1355 child window or a top level one.
1359 wxPoint
GetScreenPosition() const;
1362 Returns the position and size of the window on the screen as a wxRect object.
1366 wxRect
GetScreenRect() const;
1369 Get the origin of the client area of the window relative to the
1370 window top left corner (the client area may be shifted because of
1371 the borders, scrollbars, other decorations...)
1373 virtual wxPoint
GetClientAreaOrigin() const;
1376 Get the client rectangle in window (i.e. client) coordinates
1378 wxRect
GetClientRect() const;
1383 Moves the window to the given position.
1386 Required x position.
1388 Required y position.
1390 See SetSize() for more info about this parameter.
1392 @remarks Implementations of SetSize can also implicitly implement the
1393 Move() function, which is defined in the base wxWindow class as the call:
1395 SetSize(x, y, wxDefaultCoord, wxDefaultCoord, wxSIZE_USE_EXISTING);
1400 void Move(int x
, int y
, int flags
= wxSIZE_USE_EXISTING
);
1403 Moves the window to the given position.
1406 wxPoint object representing the position.
1408 See SetSize() for more info about this parameter.
1410 @remarks Implementations of SetSize() can also implicitly implement the
1411 Move() function, which is defined in the base wxWindow class as the call:
1413 SetSize(x, y, wxDefaultCoord, wxDefaultCoord, wxSIZE_USE_EXISTING);
1418 void Move(const wxPoint
& pt
, int flags
= wxSIZE_USE_EXISTING
);
1420 void SetPosition(const wxPoint
& pt
);
1426 @name Coordinate conversion functions
1431 Converts to screen coordinates from coordinates relative to this window.
1434 A pointer to a integer value for the x coordinate. Pass the client
1435 coordinate in, and a screen coordinate will be passed out.
1437 A pointer to a integer value for the y coordinate. Pass the client
1438 coordinate in, and a screen coordinate will be passed out.
1441 In wxPerl this method returns a 2-element list instead of
1442 modifying its parameters.
1445 void ClientToScreen(int* x
, int* y
) const;
1448 Converts to screen coordinates from coordinates relative to this window.
1451 The client position for the second form of the function.
1453 wxPoint
ClientToScreen(const wxPoint
& pt
) const;
1456 Converts a point or size from dialog units to pixels.
1458 For the x dimension, the dialog units are multiplied by the average character
1459 width and then divided by 4.
1460 For the y dimension, the dialog units are multiplied by the average character
1461 height and then divided by 8.
1463 @remarks Dialog units are used for maintaining a dialog's proportions
1464 even if the font changes.
1465 You can also use these functions programmatically.
1466 A convenience macro is defined:
1468 #define wxDLG_UNIT(parent, pt) parent->ConvertDialogToPixels(pt)
1471 @see ConvertPixelsToDialog()
1473 wxPoint
ConvertDialogToPixels(const wxPoint
& pt
) const;
1478 wxSize
ConvertDialogToPixels(const wxSize
& sz
) const;
1481 Converts a point or size from pixels to dialog units.
1483 For the x dimension, the pixels are multiplied by 4 and then divided by the
1484 average character width.
1485 For the y dimension, the pixels are multiplied by 8 and then divided by the
1486 average character height.
1488 @remarks Dialog units are used for maintaining a dialog's proportions
1489 even if the font changes.
1491 @see ConvertDialogToPixels()
1493 wxPoint
ConvertPixelsToDialog(const wxPoint
& pt
) const;
1498 wxSize
ConvertPixelsToDialog(const wxSize
& sz
) const;
1501 Converts from screen to client window coordinates.
1504 Stores the screen x coordinate and receives the client x coordinate.
1506 Stores the screen x coordinate and receives the client x coordinate.
1508 void ScreenToClient(int* x
, int* y
) const;
1511 Converts from screen to client window coordinates.
1514 The screen position.
1516 wxPoint
ScreenToClient(const wxPoint
& pt
) const;
1522 @name Drawing-related functions
1527 Clears the window by filling it with the current background colour.
1529 Does not cause an erase background event to be generated.
1531 Notice that this uses wxClientDC to draw on the window and the results
1532 of doing it while also drawing on wxPaintDC for this window are
1533 undefined. Hence this method shouldn't be used from EVT_PAINT handlers,
1534 just use wxDC::Clear() on the wxPaintDC you already use there instead.
1536 virtual void ClearBackground();
1539 Freezes the window or, in other words, prevents any updates from taking
1540 place on screen, the window is not redrawn at all.
1542 Thaw() must be called to reenable window redrawing. Calls to these two
1543 functions may be nested but to ensure that the window is properly
1544 repainted again, you must thaw it exactly as many times as you froze it.
1546 If the window has any children, they are recursively frozen too.
1548 This method is useful for visual appearance optimization (for example,
1549 it is a good idea to use it before doing many large text insertions in
1550 a row into a wxTextCtrl under wxGTK) but is not implemented on all
1551 platforms nor for all controls so it is mostly just a hint to wxWidgets
1552 and not a mandatory directive.
1554 @see wxWindowUpdateLocker, Thaw(), IsFrozen()
1559 Re-enables window updating after a previous call to Freeze().
1561 To really thaw the control, it must be called exactly the same number
1562 of times as Freeze().
1564 If the window has any children, they are recursively thawed too.
1566 @see wxWindowUpdateLocker, Freeze(), IsFrozen()
1571 Returns @true if the window is currently frozen by a call to Freeze().
1573 @see Freeze(), Thaw()
1575 bool IsFrozen() const;
1578 Returns the background colour of the window.
1580 @see SetBackgroundColour(), SetForegroundColour(), GetForegroundColour()
1582 wxColour
GetBackgroundColour() const;
1585 Returns the background style of the window.
1587 @see SetBackgroundColour(), GetForegroundColour(),
1588 SetBackgroundStyle(), SetTransparent()
1590 virtual wxBackgroundStyle
GetBackgroundStyle() const;
1593 Returns the character height for this window.
1595 virtual int GetCharHeight() const;
1598 Returns the average character width for this window.
1600 virtual int GetCharWidth() const;
1603 Currently this is the same as calling
1604 wxWindow::GetClassDefaultAttributes(wxWindow::GetWindowVariant()).
1606 One advantage of using this function compared to the static version is that
1607 the call is automatically dispatched to the correct class (as usual with
1608 virtual functions) and you don't have to specify the class name explicitly.
1610 The other one is that in the future this function could return different
1611 results, for example it might return a different font for an "Ok" button
1612 than for a generic button if the users GUI is configured to show such buttons
1613 in bold font. Of course, the down side is that it is impossible to call this
1614 function without actually having an object to apply it to whereas the static
1615 version can be used without having to create an object first.
1617 virtual wxVisualAttributes
GetDefaultAttributes() const;
1620 Returns the font for this window.
1624 wxFont
GetFont() const;
1627 Returns the foreground colour of the window.
1629 @remarks The meaning of foreground colour varies according to the window class;
1630 it may be the text colour or other colour, or it may not be used at all.
1632 @see SetForegroundColour(), SetBackgroundColour(),
1633 GetBackgroundColour()
1635 wxColour
GetForegroundColour() const;
1638 Gets the dimensions of the string as it would be drawn on the
1639 window with the currently selected font.
1641 The text extent is returned in the @a w and @a h pointers.
1644 String whose extent is to be measured.
1646 Return value for width.
1648 Return value for height.
1650 Return value for descent (optional).
1651 @param externalLeading
1652 Return value for external leading (optional).
1654 Font to use instead of the current window font (optional).
1657 In wxPerl this method takes only the @a string and optionally
1658 @a font parameters, and returns a 4-element list
1659 (x, y, descent, externalLeading).
1662 void GetTextExtent(const wxString
& string
,
1664 int* descent
= NULL
,
1665 int* externalLeading
= NULL
,
1666 const wxFont
* font
= NULL
) const;
1669 Gets the dimensions of the string as it would be drawn on the
1670 window with the currently selected font.
1672 wxSize
GetTextExtent(const wxString
& string
) const;
1675 Returns the region specifying which parts of the window have been damaged.
1676 Should only be called within an wxPaintEvent handler.
1678 @see wxRegion, wxRegionIterator
1680 const wxRegion
& GetUpdateRegion() const;
1683 Get the update rectangle bounding box in client coords
1685 wxRect
GetUpdateClientRect() const;
1688 Returns @true if this window background is transparent (as, for example,
1689 for wxStaticText) and should show the parent window background.
1691 This method is mostly used internally by the library itself and you normally
1692 shouldn't have to call it. You may, however, have to override it in your
1693 wxWindow-derived class to ensure that background is painted correctly.
1695 virtual bool HasTransparentBackground();
1698 Causes this window, and all of its children recursively (except under wxGTK1
1699 where this is not implemented), to be repainted. Note that repainting doesn't
1700 happen immediately but only during the next event loop iteration, if you need
1701 to update the window immediately you should use Update() instead.
1703 @param eraseBackground
1704 If @true, the background will be erased.
1706 If non-@NULL, only the given rectangle will be treated as damaged.
1710 virtual void Refresh(bool eraseBackground
= true,
1711 const wxRect
* rect
= NULL
);
1714 Redraws the contents of the given rectangle: only the area inside it will be
1717 This is the same as Refresh() but has a nicer syntax as it can be called
1718 with a temporary wxRect object as argument like this @c RefreshRect(wxRect(x, y, w, h)).
1720 void RefreshRect(const wxRect
& rect
, bool eraseBackground
= true);
1723 Calling this method immediately repaints the invalidated area of the window and
1724 all of its children recursively (this normally only happens when the
1725 flow of control returns to the event loop).
1727 Notice that this function doesn't invalidate any area of the window so
1728 nothing happens if nothing has been invalidated (i.e. marked as requiring
1729 a redraw). Use Refresh() first if you want to immediately redraw the
1730 window unconditionally.
1732 virtual void Update();
1735 Sets the background colour of the window.
1737 Notice that as with SetForegroundColour(), setting the background
1738 colour of a native control may not affect the entire control and could
1739 be not supported at all depending on the control and platform.
1741 Please see InheritAttributes() for explanation of the difference between
1742 this method and SetOwnBackgroundColour().
1745 The colour to be used as the background colour; pass
1746 wxNullColour to reset to the default colour.
1747 Note that you may want to use wxSystemSettings::GetColour() to retrieve
1748 a suitable colour to use rather than setting an hard-coded one.
1750 @remarks The background colour is usually painted by the default
1751 wxEraseEvent event handler function under Windows and
1752 automatically under GTK.
1753 Note that setting the background colour does not cause an
1754 immediate refresh, so you may wish to call wxWindow::ClearBackground
1755 or wxWindow::Refresh after calling this function.
1756 Using this function will disable attempts to use themes for
1757 this window, if the system supports them. Use with care since
1758 usually the themes represent the appearance chosen by the user
1759 to be used for all applications on the system.
1761 @return @true if the colour was really changed, @false if it was already set
1762 to this colour and nothing was done.
1764 @see GetBackgroundColour(), SetForegroundColour(),
1765 GetForegroundColour(), ClearBackground(),
1766 Refresh(), wxEraseEvent, wxSystemSettings
1768 virtual bool SetBackgroundColour(const wxColour
& colour
);
1771 Sets the background style of the window.
1773 The default background style is @c wxBG_STYLE_ERASE which indicates that
1774 the window background may be erased in @c EVT_ERASE_BACKGROUND handler.
1775 This is a safe, compatibility default; however you may want to change it
1776 to @c wxBG_STYLE_SYSTEM if you don't define any erase background event
1777 handlers at all, to avoid unnecessary generation of erase background
1778 events and always let system erase the background. And you should
1779 change the background style to @c wxBG_STYLE_PAINT if you define an
1780 @c EVT_PAINT handler which completely overwrites the window background as
1781 in this case erasing it previously, either in @c EVT_ERASE_BACKGROUND
1782 handler or in the system default handler, would result in flicker as
1783 the background pixels will be repainted twice every time the window is
1784 redrawn. Do ensure that the background is entirely erased by your
1785 @c EVT_PAINT handler in this case however as otherwise garbage may be left
1788 Notice that in previous versions of wxWidgets a common way to work
1789 around the above mentioned flickering problem was to define an empty
1790 @c EVT_ERASE_BACKGROUND handler. Setting background style to
1791 @c wxBG_STYLE_PAINT is a simpler and more efficient solution to the same
1795 Under wxGTK and wxOSX, you can use ::wxBG_STYLE_TRANSPARENT to obtain
1796 full transparency of the window background. Note that wxGTK supports
1797 this only since GTK 2.12 with a compositing manager enabled, call
1798 IsTransparentBackgroundSupported() to check whether this is the case.
1800 Also, on order for @c SetBackgroundStyle(wxBG_STYLE_TRANSPARENT) to
1801 work, it must be called before Create(). If you're using your own
1802 wxWindow-derived class you should write your code in the following way:
1804 class MyWidget : public wxWindow
1807 MyWidget(wxWindow* parent, ...)
1808 : wxWindow() // Use default ctor here!
1811 SetBackgroundStyle(wxBG_STYLE_TRANSPARENT);
1813 // And really create the window afterwards:
1814 Create(parent, ...);
1819 @see SetBackgroundColour(), GetForegroundColour(),
1820 SetTransparent(), IsTransparentBackgroundSupported()
1822 virtual bool SetBackgroundStyle(wxBackgroundStyle style
);
1825 Checks whether using transparent background might work.
1827 If this function returns @false, calling SetBackgroundStyle() with
1828 ::wxBG_STYLE_TRANSPARENT is not going to work. If it returns @true,
1829 setting transparent style should normally succeed.
1831 Notice that this function would typically be called on the parent of a
1832 window you want to set transparent background style for as the window
1833 for which this method is called must be fully created.
1836 If not @NULL, a reason message is provided if transparency is not
1839 @return @true if background transparency is supported.
1843 virtual bool IsTransparentBackgroundSupported(wxString
*reason
= NULL
) const;
1846 Sets the font for this window. This function should not be called for the
1847 parent window if you don't want its font to be inherited by its children,
1848 use SetOwnFont() instead in this case and see InheritAttributes() for more
1851 Please notice that the given font is not automatically used for
1852 wxPaintDC objects associated with this window, you need to
1853 call wxDC::SetFont too. However this font is used by
1854 any standard controls for drawing their text as well as by
1858 Font to associate with this window, pass
1859 wxNullFont to reset to the default font.
1861 @return @true if the font was really changed, @false if it was already set
1862 to this font and nothing was done.
1864 @see GetFont(), InheritAttributes()
1866 virtual bool SetFont(const wxFont
& font
);
1869 Sets the foreground colour of the window.
1871 The meaning of foreground colour varies according to the window class;
1872 it may be the text colour or other colour, or it may not be used at
1873 all. Additionally, not all native controls support changing their
1874 foreground colour so this method may change their colour only partially
1877 Please see InheritAttributes() for explanation of the difference between
1878 this method and SetOwnForegroundColour().
1881 The colour to be used as the foreground colour; pass
1882 wxNullColour to reset to the default colour.
1884 @return @true if the colour was really changed, @false if it was already set
1885 to this colour and nothing was done.
1887 @see GetForegroundColour(), SetBackgroundColour(),
1888 GetBackgroundColour(), ShouldInheritColours()
1890 virtual bool SetForegroundColour(const wxColour
& colour
);
1893 Sets the background colour of the window but prevents it from being inherited
1894 by the children of this window.
1896 @see SetBackgroundColour(), InheritAttributes()
1898 void SetOwnBackgroundColour(const wxColour
& colour
);
1901 Sets the font of the window but prevents it from being inherited by the
1902 children of this window.
1904 @see SetFont(), InheritAttributes()
1906 void SetOwnFont(const wxFont
& font
);
1909 Sets the foreground colour of the window but prevents it from being inherited
1910 by the children of this window.
1912 @see SetForegroundColour(), InheritAttributes()
1914 void SetOwnForegroundColour(const wxColour
& colour
);
1917 @deprecated use wxDC::SetPalette instead.
1919 void SetPalette(const wxPalette
& pal
);
1922 Return @true from here to allow the colours of this window to be changed by
1923 InheritAttributes(). Returning @false forbids inheriting them from the parent window.
1925 The base class version returns @false, but this method is overridden in
1926 wxControl where it returns @true.
1928 virtual bool ShouldInheritColours() const;
1931 This function tells a window if it should use the system's "theme" code
1932 to draw the windows' background instead of its own background drawing
1933 code. This does not always have any effect since the underlying platform
1934 obviously needs to support the notion of themes in user defined windows.
1935 One such platform is GTK+ where windows can have (very colourful) backgrounds
1936 defined by a user's selected theme.
1938 Dialogs, notebook pages and the status bar have this flag set to @true
1939 by default so that the default look and feel is simulated best.
1941 virtual void SetThemeEnabled(bool enable
);
1945 virtual bool GetThemeEnabled() const;
1948 Returns @true if the system supports transparent windows and calling
1949 SetTransparent() may succeed. If this function returns @false, transparent
1950 windows are definitely not supported by the current system.
1952 virtual bool CanSetTransparent();
1955 Set the transparency of the window. If the system supports transparent windows,
1956 returns @true, otherwise returns @false and the window remains fully opaque.
1957 See also CanSetTransparent().
1959 The parameter @a alpha is in the range 0..255 where 0 corresponds to a
1960 fully transparent window and 255 to the fully opaque one. The constants
1961 @c wxIMAGE_ALPHA_TRANSPARENT and @c wxIMAGE_ALPHA_OPAQUE can be used.
1963 virtual bool SetTransparent(wxByte alpha
);
1969 @name Event-handling functions
1971 wxWindow allows you to build a (sort of) stack of event handlers which
1972 can be used to override the window's own event handling.
1977 Returns the event handler for this window.
1978 By default, the window is its own event handler.
1980 @see SetEventHandler(), PushEventHandler(),
1981 PopEventHandler(), wxEvtHandler::ProcessEvent, wxEvtHandler
1983 wxEvtHandler
* GetEventHandler() const;
1986 This function will generate the appropriate call to Navigate() if the key
1987 event is one normally used for keyboard navigation and return @true in this case.
1989 @return Returns @true if the key pressed was for navigation and was
1990 handled, @false otherwise.
1994 bool HandleAsNavigationKey(const wxKeyEvent
& event
);
1999 GetEventHandler()->SafelyProcessEvent(event);
2002 @see ProcessWindowEvent()
2004 bool HandleWindowEvent(wxEvent
& event
) const;
2007 Convenient wrapper for ProcessEvent().
2009 This is the same as writing @code GetEventHandler()->ProcessEvent(event);
2010 @endcode but more convenient. Notice that ProcessEvent() itself can't
2011 be called for wxWindow objects as it ignores the event handlers
2012 associated with the window; use this function instead.
2014 bool ProcessWindowEvent(wxEvent
& event
);
2017 Wrapper for wxEvtHandler::ProcessEventLocally().
2019 This method is similar to ProcessWindowEvent() but can be used to
2020 search for the event handler only in this window and any event handlers
2021 pushed on top of it. Unlike ProcessWindowEvent() it won't propagate the
2022 event upwards. But it will use the validator and event handlers
2023 associated with this window, if any.
2027 bool ProcessWindowEventLocally(wxEvent
& event
);
2030 Removes and returns the top-most event handler on the event handler stack.
2032 E.g. in the case of:
2033 @image html overview_events_winstack.png
2034 when calling @c W->PopEventHandler(), the event handler @c A will be
2035 removed and @c B will be the first handler of the stack.
2037 Note that it's an error to call this function when no event handlers
2038 were pushed on this window (i.e. when the window itself is its only
2041 @param deleteHandler
2042 If this is @true, the handler will be deleted after it is removed
2043 (and the returned value will be @NULL).
2045 @see @ref overview_events_processing
2047 wxEvtHandler
* PopEventHandler(bool deleteHandler
= false);
2050 Pushes this event handler onto the event stack for the window.
2052 An event handler is an object that is capable of processing the events sent
2053 to a window. By default, the window is its own event handler, but an application
2054 may wish to substitute another, for example to allow central implementation
2055 of event-handling for a variety of different window classes.
2057 wxWindow::PushEventHandler allows an application to set up a @e stack
2058 of event handlers, where an event not handled by one event handler is
2059 handed to the next one in the chain.
2061 E.g. if you have two event handlers @c A and @c B and a wxWindow instance
2064 W->PushEventHandler(A);
2065 W->PushEventHandler(B);
2067 you will end up with the following situation:
2068 @image html overview_events_winstack.png
2070 Note that you can use wxWindow::PopEventHandler to remove the event handler.
2073 Specifies the handler to be pushed.
2074 It must not be part of a wxEvtHandler chain; an assert will fail
2075 if it's not unlinked (see wxEvtHandler::IsUnlinked).
2077 @see @ref overview_events_processing
2079 void PushEventHandler(wxEvtHandler
* handler
);
2082 Find the given @a handler in the windows event handler stack and
2083 removes (but does not delete) it from the stack.
2085 See wxEvtHandler::Unlink() for more info.
2088 The event handler to remove, must be non-@NULL and
2089 must be present in this windows event handlers stack.
2091 @return Returns @true if it was found and @false otherwise (this also
2092 results in an assert failure so this function should
2093 only be called when the handler is supposed to be there).
2095 @see PushEventHandler(), PopEventHandler()
2097 bool RemoveEventHandler(wxEvtHandler
* handler
);
2100 Sets the event handler for this window.
2102 Note that if you use this function you may want to use as the "next" handler
2103 of @a handler the window itself; in this way when @a handler doesn't process
2104 an event, the window itself will have a chance to do it.
2107 Specifies the handler to be set. Cannot be @NULL.
2109 @see @ref overview_events_processing
2111 void SetEventHandler(wxEvtHandler
* handler
);
2114 wxWindows cannot be used to form event handler chains; this function
2115 thus will assert when called.
2117 Note that instead you can use PushEventHandler() or SetEventHandler() to
2118 implement a stack of event handlers to override wxWindow's own
2119 event handling mechanism.
2121 virtual void SetNextHandler(wxEvtHandler
* handler
);
2124 wxWindows cannot be used to form event handler chains; this function
2125 thus will assert when called.
2127 Note that instead you can use PushEventHandler() or SetEventHandler() to
2128 implement a stack of event handlers to override wxWindow's own
2129 event handling mechanism.
2131 virtual void SetPreviousHandler(wxEvtHandler
* handler
);
2138 @name Window styles functions
2143 Returns the extra style bits for the window.
2145 long GetExtraStyle() const;
2148 Gets the window style that was passed to the constructor or Create()
2149 method. GetWindowStyle() is another name for the same function.
2151 virtual long GetWindowStyleFlag() const;
2154 See GetWindowStyleFlag() for more info.
2156 long GetWindowStyle() const;
2159 Returns @true if the window has the given @a exFlag bit set in its
2162 @see SetExtraStyle()
2164 bool HasExtraStyle(int exFlag
) const;
2167 Returns @true if the window has the given @a flag bit set.
2169 bool HasFlag(int flag
) const;
2172 Sets the extra style bits for the window.
2173 The currently defined extra style bits are reported in the class
2176 virtual void SetExtraStyle(long exStyle
);
2179 Sets the style of the window. Please note that some styles cannot be changed
2180 after the window creation and that Refresh() might need to be called
2181 after changing the others for the change to take place immediately.
2183 See @ref overview_windowstyles "Window styles" for more information about flags.
2185 @see GetWindowStyleFlag()
2187 virtual void SetWindowStyleFlag(long style
);
2190 See SetWindowStyleFlag() for more info.
2192 void SetWindowStyle(long style
);
2195 Turns the given @a flag on if it's currently turned off and vice versa.
2196 This function cannot be used if the value of the flag is 0 (which is often
2197 the case for default flags).
2199 Also, please notice that not all styles can be changed after the control
2202 @return Returns @true if the style was turned on by this function, @false
2203 if it was switched off.
2205 @see SetWindowStyleFlag(), HasFlag()
2207 bool ToggleWindowStyle(int flag
);
2213 @name Tab order functions
2218 Moves this window in the tab navigation order after the specified @e win.
2219 This means that when the user presses @c TAB key on that other window,
2220 the focus switches to this window.
2222 Default tab order is the same as creation order, this function and
2223 MoveBeforeInTabOrder() allow to change
2224 it after creating all the windows.
2227 A sibling of this window which should precede it in tab order,
2230 void MoveAfterInTabOrder(wxWindow
* win
);
2233 Same as MoveAfterInTabOrder() except that it inserts this window just
2234 before @a win instead of putting it right after it.
2236 void MoveBeforeInTabOrder(wxWindow
* win
);
2239 Performs a keyboard navigation action starting from this window.
2240 This method is equivalent to calling NavigateIn() method on the
2244 A combination of wxNavigationKeyEvent::IsForward and
2245 wxNavigationKeyEvent::WinChange.
2247 @return Returns @true if the focus was moved to another window or @false
2250 @remarks You may wish to call this from a text control custom keypress
2251 handler to do the default navigation behaviour for the
2252 tab key, since the standard default behaviour for a
2253 multiline text control with the wxTE_PROCESS_TAB style
2254 is to insert a tab and not navigate to the next
2255 control. See also wxNavigationKeyEvent and
2256 HandleAsNavigationKey.
2258 bool Navigate(int flags
= wxNavigationKeyEvent::IsForward
);
2261 Performs a keyboard navigation action inside this window.
2262 See Navigate() for more information.
2264 bool NavigateIn(int flags
= wxNavigationKeyEvent::IsForward
);
2271 @name Z order functions
2276 Lowers the window to the bottom of the window hierarchy (Z-order).
2279 This function only works for wxTopLevelWindow-derived classes.
2283 virtual void Lower();
2286 Raises the window to the top of the window hierarchy (Z-order).
2288 Notice that this function only requests the window manager to raise
2289 this window to the top of Z-order. Depending on its configuration, the
2290 window manager may raise the window, not do it at all or indicate that
2291 a window requested to be raised in some other way, e.g. by flashing its
2292 icon if it is minimized.
2295 This function only works for wxTopLevelWindow-derived classes.
2299 virtual void Raise();
2305 @name Window status functions
2311 Equivalent to calling wxWindow::Show(@false).
2316 This function hides a window, like Hide(), but using a special visual
2319 The parameters of this function are the same as for ShowWithEffect(),
2320 please see their description there.
2324 virtual bool HideWithEffect(wxShowEffect effect
,
2325 unsigned int timeout
= 0);
2327 Returns @true if the window is enabled, i.e. if it accepts user input,
2330 Notice that this method can return @false even if this window itself hadn't
2331 been explicitly disabled when one of its parent windows is disabled.
2332 To get the intrinsic status of this window, use IsThisEnabled()
2336 bool IsEnabled() const;
2339 Returns @true if the given point or rectangle area has been exposed since the
2340 last repaint. Call this in an paint event handler to optimize redrawing by
2341 only redrawing those areas, which have been exposed.
2343 bool IsExposed(int x
, int y
) const;
2348 bool IsExposed(wxPoint
& pt
) const;
2353 bool IsExposed(int x
, int y
, int w
, int h
) const;
2358 bool IsExposed(wxRect
& rect
) const;
2360 Returns @true if the window is shown, @false if it has been hidden.
2362 @see IsShownOnScreen()
2364 virtual bool IsShown() const;
2367 Returns @true if the window is physically visible on the screen, i.e. it
2368 is shown and all its parents up to the toplevel window are shown as well.
2372 virtual bool IsShownOnScreen() const;
2375 Disables the window. Same as @ref Enable() Enable(@false).
2377 @return Returns @true if the window has been disabled, @false if it had
2378 been already disabled before the call to this function.
2383 Enable or disable the window for user input. Note that when a parent window is
2384 disabled, all of its children are disabled as well and they are reenabled again
2388 If @true, enables the window for input. If @false, disables the window.
2390 @return Returns @true if the window has been enabled or disabled, @false
2391 if nothing was done, i.e. if the window had already
2392 been in the specified state.
2394 @see IsEnabled(), Disable(), wxRadioBox::Enable
2396 virtual bool Enable(bool enable
= true);
2399 Shows or hides the window. You may need to call Raise()
2400 for a top level window if you want to bring it to top, although this is not
2401 needed if Show() is called immediately after the frame creation.
2403 Notice that the default state of newly created top level windows is hidden
2404 (to allow you to create their contents without flicker) unlike for
2405 all the other, not derived from wxTopLevelWindow, windows that
2406 are by default created in the shown state.
2409 If @true displays the window. Otherwise, hides it.
2411 @return @true if the window has been shown or hidden or @false if nothing
2412 was done because it already was in the requested state.
2414 @see IsShown(), Hide(), wxRadioBox::Show, wxShowEvent.
2416 virtual bool Show(bool show
= true);
2419 This function shows a window, like Show(), but using a special visual
2426 The @a timeout parameter specifies the time of the animation, in
2427 milliseconds. If the default value of 0 is used, the default
2428 animation time for the current platform is used.
2430 @note Currently this function is only implemented in wxMSW and wxOSX
2431 (for wxTopLevelWindows only in Carbon version and for any kind of
2432 windows in Cocoa) and does the same thing as Show() in the other
2437 @see HideWithEffect()
2439 virtual bool ShowWithEffect(wxShowEffect effect
,
2440 unsigned int timeout
= 0);
2446 @name Context-sensitive help functions
2451 Gets the help text to be used as context-sensitive help for this window.
2452 Note that the text is actually stored by the current wxHelpProvider
2453 implementation, and not in the window object itself.
2455 @see SetHelpText(), GetHelpTextAtPoint(), wxHelpProvider
2457 wxString
GetHelpText() const;
2460 Sets the help text to be used as context-sensitive help for this window.
2461 Note that the text is actually stored by the current wxHelpProvider
2462 implementation, and not in the window object itself.
2464 @see GetHelpText(), wxHelpProvider::AddHelp()
2466 void SetHelpText(const wxString
& helpText
);
2469 Gets the help text to be used as context-sensitive help for this window.
2470 This method should be overridden if the help message depends on the position
2471 inside the window, otherwise GetHelpText() can be used.
2474 Coordinates of the mouse at the moment of help event emission.
2476 Help event origin, see also wxHelpEvent::GetOrigin.
2478 virtual wxString
GetHelpTextAtPoint(const wxPoint
& point
,
2479 wxHelpEvent::Origin origin
) const;
2482 Get the associated tooltip or @NULL if none.
2484 wxToolTip
* GetToolTip() const;
2487 Get the text of the associated tooltip or empty string if none.
2489 wxString
GetToolTipText() const;
2492 Attach a tooltip to the window.
2494 wxToolTip pointer can be @NULL in the overload taking the pointer,
2495 meaning to unset any existing tooltips; however UnsetToolTip() provides
2496 a more readable alternative to this operation.
2498 Notice that these methods are always available, even if wxWidgets was
2499 compiled with @c wxUSE_TOOLTIPS set to 0, but don't do anything in this
2502 @see GetToolTip(), wxToolTip
2504 void SetToolTip(const wxString
& tipString
);
2509 void SetToolTip(wxToolTip
* tip
);
2512 Unset any existing tooltip.
2518 void UnsetToolTip();
2524 @name Popup/context menu functions
2529 This function shows a popup menu at the given position in this window and
2530 returns the selected id.
2532 It can be more convenient than the general purpose PopupMenu() function
2533 for simple menus proposing a choice in a list of strings to the user.
2535 Notice that to avoid unexpected conflicts between the (usually
2536 consecutive range of) ids used by the menu passed to this function and
2537 the existing EVT_UPDATE_UI() handlers, this function temporarily
2538 disables UI updates for the window, so you need to manually disable
2539 (or toggle or ...) any items which should be disabled in the menu
2542 The parameter @a menu is the menu to show.
2543 The parameter @a pos (or the parameters @a x and @a y) is the
2544 position at which to show the menu in client coordinates.
2545 It is recommended to not explicitly specify coordinates when
2546 calling this method in response to mouse click, because some of
2547 the ports (namely, wxGTK) can do a better job of positioning
2548 the menu in that case.
2551 The selected menu item id or @c wxID_NONE if none selected or an
2556 int GetPopupMenuSelectionFromUser(wxMenu
& menu
,
2557 const wxPoint
& pos
= wxDefaultPosition
);
2562 int GetPopupMenuSelectionFromUser(wxMenu
& menu
, int x
, int y
);
2565 Pops up the given menu at the specified coordinates, relative to this
2566 window, and returns control when the user has dismissed the menu.
2568 If a menu item is selected, the corresponding menu event is generated and will be
2569 processed as usual. If coordinates are not specified, the current mouse
2570 cursor position is used.
2572 @a menu is the menu to pop up.
2574 The position where the menu will appear can be specified either as a
2575 wxPoint @a pos or by two integers (@a x and @a y).
2577 @remarks Just before the menu is popped up, wxMenu::UpdateUI is called to
2578 ensure that the menu items are in the correct state.
2579 The menu does not get deleted by the window.
2580 It is recommended to not explicitly specify coordinates when
2581 calling PopupMenu in response to mouse click, because some of
2582 the ports (namely, wxGTK) can do a better job of positioning
2583 the menu in that case.
2587 bool PopupMenu(wxMenu
* menu
,
2588 const wxPoint
& pos
= wxDefaultPosition
);
2593 bool PopupMenu(wxMenu
* menu
, int x
, int y
);
2604 Returns a pointer to the current validator for the window, or @NULL if
2607 virtual wxValidator
* GetValidator();
2610 Deletes the current validator (if any) and sets the window validator, having
2611 called wxValidator::Clone to create a new validator of this type.
2613 virtual void SetValidator(const wxValidator
& validator
);
2616 Transfers values from child controls to data areas specified by their
2617 validators. Returns @false if a transfer failed.
2619 If the window has @c wxWS_EX_VALIDATE_RECURSIVELY extra style flag set,
2620 the method will also call TransferDataFromWindow() of all child windows.
2622 @see TransferDataToWindow(), wxValidator, Validate()
2624 virtual bool TransferDataFromWindow();
2627 Transfers values to child controls from data areas specified by their
2630 If the window has @c wxWS_EX_VALIDATE_RECURSIVELY extra style flag set,
2631 the method will also call TransferDataToWindow() of all child windows.
2633 @return Returns @false if a transfer failed.
2635 @see TransferDataFromWindow(), wxValidator, Validate()
2637 virtual bool TransferDataToWindow();
2640 Validates the current values of the child controls using their validators.
2641 If the window has @c wxWS_EX_VALIDATE_RECURSIVELY extra style flag set,
2642 the method will also call Validate() of all child windows.
2644 @return Returns @false if any of the validations failed.
2646 @see TransferDataFromWindow(), TransferDataToWindow(),
2649 virtual bool Validate();
2655 @name wxWindow properties functions
2660 Returns the identifier of the window.
2662 @remarks Each window has an integer identifier. If the application
2663 has not provided one (or the default wxID_ANY) a unique
2664 identifier with a negative value will be generated.
2666 @see SetId(), @ref overview_windowids
2668 wxWindowID
GetId() const;
2671 Generic way of getting a label from any window, for
2672 identification purposes.
2674 @remarks The interpretation of this function differs from class to class.
2675 For frames and dialogs, the value returned is the
2676 title. For buttons or static text controls, it is the
2677 button text. This function can be useful for
2678 meta-programs (such as testing tools or special-needs
2679 access programs) which need to identify windows by name.
2681 virtual wxString
GetLabel() const;
2684 Returns the layout direction for this window,
2685 Note that @c wxLayout_Default is returned if layout direction is not supported.
2687 virtual wxLayoutDirection
GetLayoutDirection() const;
2690 Returns the window's name.
2692 @remarks This name is not guaranteed to be unique; it is up to the
2693 programmer to supply an appropriate name in the window
2694 constructor or via SetName().
2698 virtual wxString
GetName() const;
2701 Returns the value previously passed to SetWindowVariant().
2703 wxWindowVariant
GetWindowVariant() const;
2706 Sets the identifier of the window.
2708 @remarks Each window has an integer identifier. If the application has
2709 not provided one, an identifier will be generated.
2710 Normally, the identifier should be provided on creation
2711 and should not be modified subsequently.
2713 @see GetId(), @ref overview_windowids
2715 void SetId(wxWindowID winid
);
2718 Sets the window's label.
2725 virtual void SetLabel(const wxString
& label
);
2728 Sets the layout direction for this window.
2730 virtual void SetLayoutDirection(wxLayoutDirection dir
);
2733 Sets the window's name.
2736 A name to set for the window.
2740 virtual void SetName(const wxString
& name
);
2743 This function can be called under all platforms but only does anything under
2744 Mac OS X 10.3+ currently. Under this system, each of the standard control can
2745 exist in several sizes which correspond to the elements of wxWindowVariant enum.
2747 By default the controls use the normal size, of course, but this function can
2748 be used to change this.
2750 void SetWindowVariant(wxWindowVariant variant
);
2753 Gets the accelerator table for this window. See wxAcceleratorTable.
2755 wxAcceleratorTable
* GetAcceleratorTable();
2758 Returns the accessible object for this window, if any.
2759 See also wxAccessible.
2761 wxAccessible
* GetAccessible();
2764 Sets the accelerator table for this window. See wxAcceleratorTable.
2766 virtual void SetAcceleratorTable(const wxAcceleratorTable
& accel
);
2769 Sets the accessible for this window. Any existing accessible for this window
2770 will be deleted first, if not identical to @e accessible.
2771 See also wxAccessible.
2773 void SetAccessible(wxAccessible
* accessible
);
2779 @name Window deletion functions
2784 This function simply generates a wxCloseEvent whose handler usually tries
2785 to close the window. It doesn't close the window itself, however.
2788 @false if the window's close handler should be able to veto the destruction
2789 of this window, @true if it cannot.
2791 @return @true if the event was handled and not vetoed, @false otherwise.
2793 @remarks Close calls the close handler for the window, providing an
2794 opportunity for the window to choose whether to destroy
2795 the window. Usually it is only used with the top level
2796 windows (wxFrame and wxDialog classes) as the others
2797 are not supposed to have any special OnClose() logic.
2798 The close handler should check whether the window is being deleted
2799 forcibly, using wxCloseEvent::CanVeto, in which case it should
2800 destroy the window using wxWindow::Destroy.
2801 Note that calling Close does not guarantee that the window will
2802 be destroyed; but it provides a way to simulate a manual close
2803 of a window, which may or may not be implemented by destroying
2804 the window. The default implementation of wxDialog::OnCloseWindow
2805 does not necessarily delete the dialog, since it will simply
2806 simulate an wxID_CANCEL event which is handled by the appropriate
2807 button event handler and may do anything at all.
2808 To guarantee that the window will be destroyed, call
2809 wxWindow::Destroy instead
2811 @see @ref overview_windowdeletion "Window Deletion Overview",
2812 Destroy(), wxCloseEvent
2814 bool Close(bool force
= false);
2817 Destroys the window safely. Use this function instead of the delete operator,
2818 since different window classes can be destroyed differently. Frames and dialogs
2819 are not destroyed immediately when this function is called -- they are added
2820 to a list of windows to be deleted on idle time, when all the window's events
2821 have been processed. This prevents problems with events being sent to
2822 non-existent windows.
2824 @return @true if the window has either been successfully deleted, or it
2825 has been added to the list of windows pending real deletion.
2827 virtual bool Destroy();
2830 Returns true if this window is in process of being destroyed.
2832 Top level windows are not deleted immediately but are rather
2833 scheduled for later destruction to give them time to process any
2834 pending messages; see Destroy() description.
2836 This function returns @true if this window, or one of its parent
2837 windows, is scheduled for destruction and can be useful to avoid
2838 manipulating it as it's usually useless to do something with a window
2839 which is on the point of disappearing anyhow.
2841 bool IsBeingDeleted() const;
2848 @name Drag and drop functions
2853 Returns the associated drop target, which may be @NULL.
2855 @see SetDropTarget(), @ref overview_dnd
2857 virtual wxDropTarget
* GetDropTarget() const;
2860 Associates a drop target with this window.
2861 If the window already has a drop target, it is deleted.
2863 @see GetDropTarget(), @ref overview_dnd
2865 virtual void SetDropTarget(wxDropTarget
* target
);
2868 Enables or disables eligibility for drop file events (OnDropFiles).
2871 If @true, the window is eligible for drop file events.
2872 If @false, the window will not accept drop file events.
2874 @remarks Windows only until version 2.8.9, available on all platforms
2875 since 2.8.10. Cannot be used together with SetDropTarget() on
2876 non-Windows platforms.
2878 @see SetDropTarget()
2880 virtual void DragAcceptFiles(bool accept
);
2886 @name Constraints, sizers and window layout functions
2891 Returns the sizer of which this window is a member, if any, otherwise @NULL.
2893 wxSizer
* GetContainingSizer() const;
2896 Returns the sizer associated with the window by a previous call to
2897 SetSizer(), or @NULL.
2899 wxSizer
* GetSizer() const;
2902 Sets the window to have the given layout sizer.
2904 The window will then own the object, and will take care of its deletion.
2905 If an existing layout constraints object is already owned by the
2906 window, it will be deleted if the @a deleteOld parameter is @true.
2908 Note that this function will also call SetAutoLayout() implicitly with @true
2909 parameter if the @a sizer is non-@NULL and @false otherwise so that the
2910 sizer will be effectively used to layout the window children whenever
2914 The sizer to set. Pass @NULL to disassociate and conditionally delete
2915 the window's sizer. See below.
2917 If @true (the default), this will delete any pre-existing sizer.
2918 Pass @false if you wish to handle deleting the old sizer yourself
2919 but remember to do it yourself in this case to avoid memory leaks.
2921 @remarks SetSizer enables and disables Layout automatically.
2923 void SetSizer(wxSizer
* sizer
, bool deleteOld
= true);
2926 This method calls SetSizer() and then wxSizer::SetSizeHints which sets the initial
2927 window size to the size needed to accommodate all sizer elements and sets the
2928 size hints which, if this window is a top level one, prevent the user from
2929 resizing it to be less than this minimal size.
2931 void SetSizerAndFit(wxSizer
* sizer
, bool deleteOld
= true);
2934 Returns a pointer to the window's layout constraints, or @NULL if there are none.
2936 wxLayoutConstraints
* GetConstraints() const;
2939 Sets the window to have the given layout constraints. The window
2940 will then own the object, and will take care of its deletion.
2941 If an existing layout constraints object is already owned by the
2942 window, it will be deleted.
2945 The constraints to set. Pass @NULL to disassociate and delete the window's
2948 @remarks You must call SetAutoLayout() to tell a window to use
2949 the constraints automatically in OnSize; otherwise, you
2950 must override OnSize and call Layout() explicitly. When
2951 setting both a wxLayoutConstraints and a wxSizer, only
2952 the sizer will have effect.
2954 void SetConstraints(wxLayoutConstraints
* constraints
);
2957 Invokes the constraint-based layout algorithm or the sizer-based algorithm
2960 This function does not get called automatically when the window is resized
2961 because lots of windows deriving from wxWindow does not need this functionality.
2962 If you want to have Layout() called automatically, you should derive
2963 from wxPanel (see wxPanel::Layout).
2965 @see @ref overview_windowsizing
2967 virtual bool Layout();
2970 Determines whether the Layout() function will be called automatically
2971 when the window is resized.
2973 This method is called implicitly by SetSizer() but if you use SetConstraints()
2974 you should call it manually or otherwise the window layout won't be correctly
2975 updated when its size changes.
2978 Set this to @true if you wish the Layout() function to be called
2979 automatically when the window is resized.
2981 @see SetSizer(), SetConstraints()
2983 void SetAutoLayout(bool autoLayout
);
2985 bool GetAutoLayout() const;
2992 @name Mouse functions
2997 Directs all mouse input to this window.
2998 Call ReleaseMouse() to release the capture.
3000 Note that wxWidgets maintains the stack of windows having captured the mouse
3001 and when the mouse is released the capture returns to the window which had had
3002 captured it previously and it is only really released if there were no previous
3003 window. In particular, this means that you must release the mouse as many times
3004 as you capture it, unless the window receives the wxMouseCaptureLostEvent event.
3006 Any application which captures the mouse in the beginning of some operation
3007 must handle wxMouseCaptureLostEvent and cancel this operation when it receives
3008 the event. The event handler must not recapture mouse.
3010 @see ReleaseMouse(), wxMouseCaptureLostEvent
3012 void CaptureMouse();
3015 Returns the caret() associated with the window.
3017 wxCaret
* GetCaret() const;
3020 Return the cursor associated with this window.
3024 const wxCursor
& GetCursor() const;
3027 Returns @true if this window has the current mouse capture.
3029 @see CaptureMouse(), ReleaseMouse(), wxMouseCaptureLostEvent,
3030 wxMouseCaptureChangedEvent
3032 virtual bool HasCapture() const;
3035 Releases mouse input captured with CaptureMouse().
3037 @see CaptureMouse(), HasCapture(), ReleaseMouse(),
3038 wxMouseCaptureLostEvent, wxMouseCaptureChangedEvent
3040 void ReleaseMouse();
3043 Sets the caret() associated with the window.
3045 void SetCaret(wxCaret
* caret
);
3048 Sets the window's cursor. Notice that the window cursor also sets it for the
3049 children of the window implicitly.
3051 The @a cursor may be @c wxNullCursor in which case the window cursor will
3052 be reset back to default.
3055 Specifies the cursor that the window should normally display.
3057 @see ::wxSetCursor, wxCursor
3059 virtual bool SetCursor(const wxCursor
& cursor
);
3062 Moves the pointer to the given position on the window.
3064 @note Apple Human Interface Guidelines forbid moving the mouse cursor
3065 programmatically so you should avoid using this function in Mac
3066 applications (and probably avoid using it under the other
3067 platforms without good reason as well).
3070 The new x position for the cursor.
3072 The new y position for the cursor.
3074 virtual void WarpPointer(int x
, int y
);
3082 @name Miscellaneous functions
3086 wxHitTest
HitTest(wxCoord x
, wxCoord y
) const;
3087 wxHitTest
HitTest(const wxPoint
& pt
) const;
3090 Get the window border style from the given flags: this is different from
3091 simply doing flags & wxBORDER_MASK because it uses GetDefaultBorder() to
3092 translate wxBORDER_DEFAULT to something reasonable
3094 wxBorder
GetBorder(long flags
) const;
3097 Get border for the flags of this window
3099 wxBorder
GetBorder() const;
3103 Does the window-specific updating after processing the update event.
3104 This function is called by UpdateWindowUI() in order to check return
3105 values in the wxUpdateUIEvent and act appropriately.
3106 For example, to allow frame and dialog title updating, wxWidgets
3107 implements this function as follows:
3110 // do the window-specific processing after processing the update event
3111 void wxTopLevelWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
3113 if ( event.GetSetEnabled() )
3114 Enable(event.GetEnabled());
3116 if ( event.GetSetText() )
3118 if ( event.GetText() != GetTitle() )
3119 SetTitle(event.GetText());
3124 virtual void DoUpdateWindowUI(wxUpdateUIEvent
& event
);
3127 Returns the platform-specific handle of the physical window.
3128 Cast it to an appropriate handle, such as @b HWND for Windows,
3129 @b Widget for Motif or @b GtkWidget for GTK.
3132 This method will return an integer in wxPerl.
3135 virtual WXWidget
GetHandle() const;
3138 This method should be overridden to return @true if this window has
3139 multiple pages. All standard class with multiple pages such as
3140 wxNotebook, wxListbook and wxTreebook already override it to return @true
3141 and user-defined classes with similar behaviour should also do so, to
3142 allow the library to handle such windows appropriately.
3144 virtual bool HasMultiplePages() const;
3147 This function is (or should be, in case of custom controls) called during
3148 window creation to intelligently set up the window visual attributes, that is
3149 the font and the foreground and background colours.
3151 By "intelligently" the following is meant: by default, all windows use their
3152 own @ref GetClassDefaultAttributes() default attributes.
3153 However if some of the parents attributes are explicitly (that is, using
3154 SetFont() and not wxWindow::SetOwnFont) changed and if the corresponding
3155 attribute hadn't been explicitly set for this window itself, then this
3156 window takes the same value as used by the parent.
3157 In addition, if the window overrides ShouldInheritColours() to return @false,
3158 the colours will not be changed no matter what and only the font might.
3160 This rather complicated logic is necessary in order to accommodate the
3161 different usage scenarios. The most common one is when all default attributes
3162 are used and in this case, nothing should be inherited as in modern GUIs
3163 different controls use different fonts (and colours) than their siblings so
3164 they can't inherit the same value from the parent. However it was also deemed
3165 desirable to allow to simply change the attributes of all children at once by
3166 just changing the font or colour of their common parent, hence in this case we
3167 do inherit the parents attributes.
3169 virtual void InheritAttributes();
3172 Sends an @c wxEVT_INIT_DIALOG event, whose handler usually transfers data
3173 to the dialog via validators.
3175 virtual void InitDialog();
3178 Returns @true if the window contents is double-buffered by the system, i.e. if
3179 any drawing done on the window is really done on a temporary backing surface
3180 and transferred to the screen all at once later.
3184 virtual bool IsDoubleBuffered() const;
3187 Turn on or off double buffering of the window if the system supports it.
3189 void SetDoubleBuffered(bool on
);
3192 Returns @true if the window is retained, @false otherwise.
3194 @remarks Retained windows are only available on X platforms.
3196 virtual bool IsRetained() const;
3199 Returns @true if this window is intrinsically enabled, @false otherwise,
3200 i.e. if @ref Enable() Enable(@false) had been called. This method is
3201 mostly used for wxWidgets itself, user code should normally use
3202 IsEnabled() instead.
3204 bool IsThisEnabled() const;
3207 Returns @true if the given window is a top-level one. Currently all frames and
3208 dialogs are considered to be top-level windows (even if they have a parent
3211 virtual bool IsTopLevel() const;
3215 This virtual function is normally only used internally, but
3216 sometimes an application may need it to implement functionality
3217 that should not be disabled by an application defining an OnIdle
3218 handler in a derived class.
3220 This function may be used to do delayed painting, for example,
3221 and most implementations call UpdateWindowUI()
3222 in order to send update events to the window in idle time.
3224 virtual void OnInternalIdle();
3227 Registers a system wide hotkey. Every time the user presses the hotkey
3228 registered here, this window will receive a hotkey event.
3230 It will receive the event even if the application is in the background
3231 and does not have the input focus because the user is working with some
3235 Numeric identifier of the hotkey. For applications this must be between 0
3236 and 0xBFFF. If this function is called from a shared DLL, it must be a
3237 system wide unique identifier between 0xC000 and 0xFFFF.
3238 This is a MSW specific detail.
3240 A bitwise combination of wxMOD_SHIFT, wxMOD_CONTROL, wxMOD_ALT
3241 or wxMOD_WIN specifying the modifier keys that have to be pressed along
3243 @param virtualKeyCode
3244 The virtual key code of the hotkey.
3246 @return @true if the hotkey was registered successfully. @false if some
3247 other application already registered a hotkey with this
3248 modifier/virtualKeyCode combination.
3250 @remarks Use EVT_HOTKEY(hotkeyId, fnc) in the event table to capture the
3251 event. This function is currently only implemented
3252 under Windows. It is used in the Windows CE port for
3253 detecting hardware button presses.
3255 @see UnregisterHotKey()
3257 virtual bool RegisterHotKey(int hotkeyId
, int modifiers
,
3258 int virtualKeyCode
);
3261 Unregisters a system wide hotkey.
3264 Numeric identifier of the hotkey. Must be the same id that was passed to
3267 @return @true if the hotkey was unregistered successfully, @false if the
3270 @remarks This function is currently only implemented under MSW.
3272 @see RegisterHotKey()
3274 virtual bool UnregisterHotKey(int hotkeyId
);
3277 This function sends one or more wxUpdateUIEvent to the window.
3278 The particular implementation depends on the window; for example a
3279 wxToolBar will send an update UI event for each toolbar button,
3280 and a wxFrame will send an update UI event for each menubar menu item.
3282 You can call this function from your application to ensure that your
3283 UI is up-to-date at this point (as far as your wxUpdateUIEvent handlers
3284 are concerned). This may be necessary if you have called
3285 wxUpdateUIEvent::SetMode() or wxUpdateUIEvent::SetUpdateInterval() to limit
3286 the overhead that wxWidgets incurs by sending update UI events in idle time.
3287 @a flags should be a bitlist of one or more of the ::wxUpdateUI enumeration.
3289 If you are calling this function from an OnInternalIdle or OnIdle
3290 function, make sure you pass the wxUPDATE_UI_FROMIDLE flag, since
3291 this tells the window to only update the UI elements that need
3292 to be updated in idle time. Some windows update their elements
3293 only when necessary, for example when a menu is about to be shown.
3294 The following is an example of how to call UpdateWindowUI from
3298 void MyWindow::OnInternalIdle()
3300 if (wxUpdateUIEvent::CanUpdate(this))
3301 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
3305 @see wxUpdateUIEvent, DoUpdateWindowUI(), OnInternalIdle()
3307 virtual void UpdateWindowUI(long flags
= wxUPDATE_UI_NONE
);
3312 // NOTE: static functions must have their own group or Doxygen will screw
3313 // up the ordering of the member groups
3316 @name Miscellaneous static functions
3321 Returns the default font and colours which are used by the control.
3323 This is useful if you want to use the same font or colour in your own control
3324 as in a standard control -- which is a much better idea than hard coding specific
3325 colours or fonts which might look completely out of place on the users
3326 system, especially if it uses themes.
3328 The @a variant parameter is only relevant under Mac currently and is
3329 ignore under other platforms. Under Mac, it will change the size of the
3330 returned font. See SetWindowVariant() for more about this.
3332 This static method is "overridden" in many derived classes and so calling,
3333 for example, wxButton::GetClassDefaultAttributes() will typically
3334 return the values appropriate for a button which will be normally different
3335 from those returned by, say, wxListCtrl::GetClassDefaultAttributes().
3337 The @c wxVisualAttributes structure has at least the fields
3338 @c font, @c colFg and @c colBg. All of them may be invalid
3339 if it was not possible to determine the default control appearance or,
3340 especially for the background colour, if the field doesn't make sense as is
3341 the case for @c colBg for the controls with themed background.
3343 @see InheritAttributes()
3345 static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant
= wxWINDOW_VARIANT_NORMAL
);
3348 Finds the window or control which currently has the keyboard focus.
3350 @remarks Note that this is a static function, so it can be called without
3351 needing a wxWindow pointer.
3353 @see SetFocus(), HasFocus()
3355 static wxWindow
* FindFocus();
3358 Find the first window with the given @e id.
3360 If @a parent is @NULL, the search will start from all top-level frames
3361 and dialog boxes; if non-@NULL, the search will be limited to the given
3363 The search is recursive in both cases.
3367 @return Window with the given @a id or @NULL if not found.
3369 static wxWindow
* FindWindowById(long id
, const wxWindow
* parent
= 0);
3372 Find a window by its label.
3374 Depending on the type of window, the label may be a window title
3375 or panel item label. If @a parent is @NULL, the search will start from all
3376 top-level frames and dialog boxes; if non-@NULL, the search will be
3377 limited to the given window hierarchy.
3378 The search is recursive in both cases.
3382 @return Window with the given @a label or @NULL if not found.
3384 static wxWindow
* FindWindowByLabel(const wxString
& label
,
3385 const wxWindow
* parent
= 0);
3388 Find a window by its name (as given in a window constructor or Create()
3391 If @a parent is @NULL, the search will start from all top-level frames
3392 and dialog boxes; if non-@NULL, the search will be limited to the given
3395 The search is recursive in both cases. If no window with such name is found,
3396 FindWindowByLabel() is called.
3400 @return Window with the given @a name or @NULL if not found.
3402 static wxWindow
* FindWindowByName(const wxString
& name
,
3403 const wxWindow
* parent
= 0);
3406 Returns the currently captured window.
3408 @see HasCapture(), CaptureMouse(), ReleaseMouse(),
3409 wxMouseCaptureLostEvent, wxMouseCaptureChangedEvent
3411 static wxWindow
* GetCapture();
3414 Create a new ID or range of IDs that are not currently in use.
3415 The IDs will be reserved until assigned to a wxWindow ID
3416 or unreserved with UnreserveControlId().
3418 See @ref overview_windowids for more information.
3421 The number of sequential IDs to reserve.
3423 @return Returns the ID or the first ID of the range (i.e. the most negative),
3424 or wxID_NONE if the specified number of identifiers couldn't be allocated.
3426 @see UnreserveControlId(), wxIdManager,
3427 @ref overview_windowids
3429 static wxWindowID
NewControlId(int count
= 1);
3432 Unreserve an ID or range of IDs that was reserved by NewControlId().
3433 See @ref overview_windowids for more information.
3436 The starting ID of the range of IDs to unreserve.
3438 The number of sequential IDs to unreserve.
3440 @see NewControlId(), wxIdManager, @ref overview_windowids
3442 static void UnreserveControlId(wxWindowID id
, int count
= 1);
3454 Specifies the direction for the centring. May be wxHORIZONTAL,
3455 wxVERTICAL or wxBOTH. It may also include the wxCENTRE_ON_SCREEN
3458 @remarks This function is not meant to be called directly by user code,
3459 but via Centre, Center, CentreOnParent, or CenterOnParent.
3460 This function can be overridden to fine-tune centring behaviour.
3462 virtual void DoCentre(int direction
);
3465 Implementation of GetBestSize() that can be overridden.
3467 Notice that it is usually more convenient to override
3468 DoGetBestClientSize() rather than this method itself as you need to
3469 explicitly account for the window borders size if you do the latter.
3471 The default implementation of this function is designed for use in container
3472 windows, such as wxPanel, and works something like this:
3473 -# If the window has a sizer then it is used to calculate the best size.
3474 -# Otherwise if the window has layout constraints then those are used to
3475 calculate the best size.
3476 -# Otherwise if the window has children then the best size is set to be large
3477 enough to show all the children.
3478 -# Otherwise if there are no children then the window's minimal size will be
3479 used as its best size.
3480 -# Otherwise if there is no minimal size set, then the current size is used
3483 @see @ref overview_windowsizing
3485 virtual wxSize
DoGetBestSize() const;
3488 Override this method to return the best size for a custom control.
3490 A typical implementation of this method should compute the minimal size
3491 needed to fully display the control contents taking into account the
3494 The default implementation simply returns ::wxDefaultSize and
3495 GetBestSize() returns an arbitrary hardcoded size for the window, so
3496 you must override it when implementing a custom window class.
3498 @see @ref overview_windowsizing
3502 virtual wxSize
DoGetBestClientSize() const;
3505 Override this method to implement height-for-width best size
3508 Return the height needed to fully display the control contents if its
3509 width is fixed to the given value. Custom classes implementing
3510 wrapping should override this method and return the height
3511 corresponding to the number of lines needed to lay out the control
3512 contents at this width.
3514 Currently this method is not used by wxWidgets yet, however it is
3515 planned that it will be used by the new sizer classes implementing
3516 height-for-width layout strategy in the future.
3518 Notice that implementing this method or even implementing both it and
3519 DoGetBestClientWidth() doesn't replace overriding DoGetBestClientSize(),
3520 i.e. you still need to implement the latter as well in order to provide
3521 the best size when neither width nor height are constrained.
3523 By default returns ::wxDefaultCoord meaning that the vertical component
3524 of DoGetBestClientSize() return value should be used.
3528 virtual int DoGetBestClientHeight(int width
) const;
3531 Override this method to implement width-for-height best size
3534 This method is exactly the same as DoGetBestClientHeight() except that
3535 it determines the width assuming the height is fixed instead of vice
3540 virtual int DoGetBestClientWidth(int height
) const;
3543 Sets the initial window size if none is given (i.e. at least one of the
3544 components of the size passed to ctor/Create() is wxDefaultCoord).
3545 @deprecated Use SetInitialSize() instead.
3547 virtual void SetInitialBestSize(const wxSize
& size
);
3550 Generate wxWindowDestroyEvent for this window.
3552 This is called by the window itself when it is being destroyed and
3553 usually there is no need to call it but see wxWindowDestroyEvent for
3554 explanations of when you might want to do it.
3556 void SendDestroyEvent();
3559 This function is public in wxEvtHandler but protected in wxWindow
3560 because for wxWindows you should always call ProcessEvent() on the
3561 pointer returned by GetEventHandler() and not on the wxWindow object
3564 For convenience, a ProcessWindowEvent() method is provided as a synonym
3565 for @code GetEventHandler()->ProcessEvent() @endcode
3567 Note that it's still possible to call these functions directly on the
3568 wxWindow object (e.g. casting it to wxEvtHandler) but doing that will
3569 create subtle bugs when windows with event handlers pushed on them are
3572 This holds also for all other wxEvtHandler functions.
3574 virtual bool ProcessEvent(wxEvent
& event
);
3578 See ProcessEvent() for more info about why you shouldn't use this function
3579 and the reason for making this function protected in wxWindow.
3581 bool SafelyProcessEvent(wxEvent
& event
);
3582 virtual void QueueEvent(wxEvent
*event
);
3583 virtual void AddPendingEvent(const wxEvent
& event
);
3584 void ProcessPendingEvents();
3585 bool ProcessThreadEvent(const wxEvent
& event
);
3591 // ============================================================================
3592 // Global functions/macros
3593 // ============================================================================
3595 /** @addtogroup group_funcmacro_misc */
3599 Find the deepest window at the mouse pointer position, returning the window
3600 and current pointer position in screen coordinates.
3602 @header{wx/window.h}
3604 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
);
3607 Gets the currently active window (implemented for MSW and GTK only
3608 currently, always returns @NULL in the other ports).
3610 @header{wx/window.h}
3612 wxWindow
* wxGetActiveWindow();
3615 Returns the first top level parent of the given window, or in other words,
3616 the frame or dialog containing it, or @NULL.
3618 @header{wx/window.h}
3620 wxWindow
* wxGetTopLevelParent(wxWindow
* window
);