+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Name: window.tex
+%% Purpose: wxWindow documentation
+%% Author: wxWidgets Team
+%% Modified by:
+%% Created:
+%% RCS-ID: $Id$
+%% Copyright: (c) wxWidgets Team
+%% License: wxWindows license
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
\section{\class{wxWindow}}\label{wxwindow}
-wxWindow is the base class for all windows. Any
-children of the window will be deleted automatically by the destructor
-before the window itself is deleted.
+wxWindow is the base class for all windows and represents any visible object on
+screen. All controls, top level windows and so on are windows. Sizers and
+device contexts are not, however, as they don't appear on screen themselves.
+
+Please note that all children of the window will be deleted automatically by
+the destructor before the window itself is deleted which means that you don't
+have to worry about deleting them manually. Please see the \helpref{window
+deletion overview}{windowdeletionoverview} for more information.
+
+Also note that in this, and many others, wxWidgets classes some
+\texttt{GetXXX()} methods may be overloaded (as, for example,
+\helpref{GetSize}{wxwindowgetsize} or
+\helpref{GetClientSize}{wxwindowgetclientsize}). In this case, the overloads
+are non-virtual because having multiple virtual functions with the same name
+results in a virtual function name hiding at the derived class level (in
+English, this means that the derived class has to override all overloaded
+variants if it overrides any of them). To allow overriding them in the derived
+class, wxWidgets uses a unique protected virtual \texttt{DoGetXXX()} method
+and all \texttt{GetXXX()} ones are forwarded to it, so overriding the former
+changes the behaviour of the latter.
\wxheading{Derived from}
<wx/window.h>
+\wxheading{Library}
+
+\helpref{wxCore}{librarieslist}
+
\wxheading{Window styles}
The following styles can apply to all windows, although they will not always make sense for a particular
-window class.
+window class or on all platforms.
\twocolwidtha{5cm}%
\begin{twocollist}\itemsep=0pt
-\twocolitem{\windowstyle{wxSIMPLE\_BORDER}}{Displays a thin border around the window. wxBORDER is the old name
-for this style.}
-\twocolitem{\windowstyle{wxDOUBLE\_BORDER}}{Displays a double border. Windows only.}
-\twocolitem{\windowstyle{wxSUNKEN\_BORDER}}{Displays a sunken border.}
-\twocolitem{\windowstyle{wxRAISED\_BORDER}}{Displays a raised border.}
-\twocolitem{\windowstyle{wxSTATIC\_BORDER}}{Displays a border suitable for a static control.}
+\twocolitem{\windowstyle{wxBORDER\_DEFAULT}}{The window class will decide the kind of border to show, if any.}
+\twocolitem{\windowstyle{wxBORDER\_SIMPLE}}{Displays a thin border around the window. wxSIMPLE\_BORDER is the old name
+for this style. }
+\twocolitem{\windowstyle{wxBORDER\_SUNKEN}}{Displays a sunken border. wxSUNKEN\_BORDER is the old name for this style.}
+\twocolitem{\windowstyle{wxBORDER\_RAISED}}{Displays a raised border. wxRAISED\_BORDER is the old name for this style. }
+\twocolitem{\windowstyle{wxBORDER\_STATIC}}{Displays a border suitable for a static control. wxSTATIC\_BORDER is the old name for this style. Windows only. }
+\twocolitem{\windowstyle{wxBORDER\_THEME}}{Displays a native border suitable for a control, on the current platform. On Windows XP or Vista, this will be a themed border; on most other platforms
+a sunken border will be used. For more information for themed borders on Windows, please see \helpref{Themed borders on Windows}{wxmswthemedborders}.}
+\twocolitem{\windowstyle{wxBORDER\_NONE}}{Displays no border, overriding the default border style for the window. wxNO\_BORDER is the old name for this style.}
+\twocolitem{\windowstyle{wxBORDER\_DOUBLE}}{This style is obsolete and should not be used.}
\twocolitem{\windowstyle{wxTRANSPARENT\_WINDOW}}{The window is transparent, that is, it will not receive paint
events. Windows only.}
-\twocolitem{\windowstyle{wxNO\_3D}}{Prevents the children of this window taking on 3D styles, even though
-the application-wide policy is for 3D controls. Windows only.}
\twocolitem{\windowstyle{wxTAB\_TRAVERSAL}}{Use this to enable tab traversal for non-dialog windows.}
-\twocolitem{\windowstyle{wxVSCROLL}}{Use this style to enable a vertical scrollbar.}
-\twocolitem{\windowstyle{wxHSCROLL}}{Use this style to enable a horizontal scrollbar.}
+\twocolitem{\windowstyle{wxWANTS\_CHARS}}{Use this to indicate that
+the window wants to get all char/key events for all keys - even for
+keys like TAB or ENTER which are usually used for dialog navigation
+and which wouldn't be generated without this style. If you need to
+use this style in order to get the arrows or etc., but would still like
+to have normal keyboard navigation take place, you should call
+\helpref{Navigate}{wxwindownavigate} in response to the key events for
+Tab and Shift-Tab.}
+\twocolitem{\windowstyle{wxNO\_FULL\_REPAINT\_ON\_RESIZE}}{On Windows, this style used to disable repainting
+the window completely when its size is changed. Since this behaviour is now the default, the style is now obsolete
+and no longer has an effect.}
+\twocolitem{\windowstyle{wxVSCROLL}}{Use this style to enable a vertical
+scrollbar. Notice that this style cannot be used with native controls
+which don't support scrollbars nor with top-level windows in most ports.}
+\twocolitem{\windowstyle{wxHSCROLL}}{Use this style to enable a horizontal
+scrollbar. The same limitations as for wxVSCROLL apply to this style.}
+\twocolitem{\windowstyle{wxALWAYS\_SHOW\_SB}}{If a window has scrollbars,
+disable them instead of hiding them when they are not needed (i.e. when the
+size of the window is big enough to not require the scrollbars to navigate it).
+This style is currently implemented for wxMSW, wxGTK and wxUniversal and does
+nothing on the other platforms.}
\twocolitem{\windowstyle{wxCLIP\_CHILDREN}}{Use this style to eliminate flicker caused by the background being
-repainted, then children being painted over them. Windows-only.}
+repainted, then children being painted over them. Windows only.}
+\twocolitem{\windowstyle{wxFULL\_REPAINT\_ON\_RESIZE}}{Use this style to force
+a complete redraw of the window whenever it is resized instead of redrawing
+just the part of the window affected by resizing. Note that this was the
+behaviour by default before 2.5.1 release and that if you experience redraw
+problems with code which previously used to work you may want to try this.
+Currently this style applies on GTK+ 2 and Windows only, and full repainting is always
+done on other platforms.}
\end{twocollist}
See also \helpref{window styles overview}{windowstyles}.
+\wxheading{Extra window styles}
+
+The following are extra styles, set using \helpref{wxWindow::SetExtraStyle}{wxwindowsetextrastyle}.
+
+\twocolwidtha{5cm}%
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\windowstyle{wxWS\_EX\_VALIDATE\_RECURSIVELY}}{By default, Validate/TransferDataTo/FromWindow()
+only work on direct children of the window (compatible behaviour). Set this flag to make them recursively
+descend into all subwindows.}
+\twocolitem{\windowstyle{wxWS\_EX\_BLOCK\_EVENTS}}{wxCommandEvents and the objects of the derived classes are forwarded to the
+parent window and so on recursively by default. Using this flag for the
+given window allows to block this propagation at this window, i.e. prevent
+the events from being propagated further upwards. Dialogs have this
+flag on by default.}
+\twocolitem{\windowstyle{wxWS\_EX\_TRANSIENT}}{Don't use this window as an implicit parent for the other windows: this must
+be used with transient windows as otherwise there is the risk of creating a
+dialog/frame with this window as a parent which would lead to a crash if the
+parent is destroyed before the child.}
+\twocolitem{\windowstyle{wxWS\_EX\_PROCESS\_IDLE}}{This window should always process idle events, even
+if the mode set by \helpref{wxIdleEvent::SetMode}{wxidleeventsetmode} is wxIDLE\_PROCESS\_SPECIFIED.}
+\twocolitem{\windowstyle{wxWS\_EX\_PROCESS\_UI\_UPDATES}}{This window should always process UI update events,
+even if the mode set by \helpref{wxUpdateUIEvent::SetMode}{wxupdateuieventsetmode} is wxUPDATE\_UI\_PROCESS\_SPECIFIED.}
+\end{twocollist}
+
\wxheading{See also}
-\helpref{Event handling overview}{eventhandlingoverview}
+\helpref{Event handling overview}{eventhandlingoverview}\\
+\helpref{Window sizing overview}{windowsizingoverview}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxWindow::wxWindow}
+
+\membersection{wxWindow::wxWindow}\label{wxwindowctor}
\func{}{wxWindow}{\void}
\docparam{parent}{Pointer to a parent window.}
-\docparam{id}{Window identifier. If -1, will automatically create an identifier.}
+\docparam{id}{Window identifier. If wxID\_ANY, will automatically create an identifier.}
-\docparam{pos}{Window position. wxDefaultPosition is (-1, -1) which indicates that wxWindows
+\docparam{pos}{Window position. wxDefaultPosition indicates that wxWidgets
should generate a default position for the window. If using the wxWindow class directly, supply
an actual position.}
-\docparam{size}{Window size. wxDefaultSize is (-1, -1) which indicates that wxWindows
-should generate a default size for the window.}
+\docparam{size}{Window size. wxDefaultSize indicates that wxWidgets
+should generate a default size for the window. If no suitable size can be found, the
+window will be sized to 20x20 pixels so that the window is visible but obviously not
+correctly sized. }
\docparam{style}{Window style. For generic window styles, please see \helpref{wxWindow}{wxwindow}.}
\docparam{name}{Window name.}
-\membersection{wxWindow::\destruct{wxWindow}}
+
+\membersection{wxWindow::\destruct{wxWindow}}\label{wxwindowdtor}
\func{}{\destruct{wxWindow}}{\void}
Destructor. Deletes all subwindows, then deletes itself. Instead of using
the {\bf delete} operator explicitly, you should normally
-use \helpref{wxWindow::Destroy}{wxwindowdestroy} so that wxWindows
+use \helpref{wxWindow::Destroy}{wxwindowdestroy} so that wxWidgets
can delete a window only when it is safe to do so, in idle time.
\wxheading{See also}
\helpref{Window deletion overview}{windowdeletionoverview},\rtfsp
-\helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow},\rtfsp
\helpref{wxWindow::Destroy}{wxwindowdestroy},\rtfsp
\helpref{wxCloseEvent}{wxcloseevent}
-\membersection{wxWindow::AddChild}
+
+\membersection{wxWindow::AcceptsFocus}\label{wxwindowacceptsfocus}
+
+\constfunc{bool}{AcceptsFocus}{\void}
+
+This method may be overridden in the derived classes to return \false to
+indicate that this control doesn't accept input at all (i.e. behaves like e.g.
+\helpref{wxStaticText}{wxstatictext}) and so doesn't need focus.
+
+\wxheading{See also}
+
+\helpref{AcceptsFocusFromKeyboard}{wxwindowacceptsfocusfromkeyboard}
+
+
+\membersection{wxWindow::AcceptsFocusFromKeyboard}\label{wxwindowacceptsfocusfromkeyboard}
+
+\constfunc{bool}{AcceptsFocusFromKeyboard}{\void}
+
+This method may be overridden in the derived classes to return \false to
+indicate that while this control can, in principle, have focus if the user
+clicks it with the mouse, it shouldn't be included in the TAB traversal chain
+when using the keyboard.
+
+
+\membersection{wxWindow::AddChild}\label{wxwindowaddchild}
\func{virtual void}{AddChild}{\param{wxWindow* }{child}}
Adds a child window. This is called automatically by window creation
functions so should not be required by the application programmer.
+Notice that this function is mostly internal to wxWidgets and shouldn't be
+called by the user code.
+
\wxheading{Parameters}
\docparam{child}{Child window to add.}
+
+\membersection{wxWindow::CacheBestSize}\label{wxwindowcachebestsize}
+
+\constfunc{void}{CacheBestSize}{\param{const wxSize\& }{size}}
+
+Sets the cached best size value.
+
+
\membersection{wxWindow::CaptureMouse}\label{wxwindowcapturemouse}
\func{virtual void}{CaptureMouse}{\void}
Directs all mouse input to this window. Call \helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse} to
release the capture.
+Note that wxWidgets maintains the stack of windows having captured the mouse
+and when the mouse is released the capture returns to the window which had had
+captured it previously and it is only really released if there were no previous
+window. In particular, this means that you must release the mouse as many times
+as you capture it, unless the window receives
+the \helpref{wxMouseCaptureLostEvent}{wxmousecapturelostevent} event.
+
+Any application which captures the mouse in the beginning of some operation
+{\em must} handle \helpref{wxMouseCaptureLostEvent}{wxmousecapturelostevent}
+and cancel this operation when it receives the event. The event handler must
+not recapture mouse.
+
\wxheading{See also}
\helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse}
+\helpref{wxMouseCaptureLostEvent}{wxmousecapturelostevent}
+
\membersection{wxWindow::Center}\label{wxwindowcenter}
A synonym for \helpref{Centre}{wxwindowcentre}.
+
+\membersection{wxWindow::CenterOnParent}\label{wxwindowcenteronparent}
+
+\func{void}{CenterOnParent}{\param{int}{ direction}}
+
+A synonym for \helpref{CentreOnParent}{wxwindowcentreonparent}.
+
+
+\membersection{wxWindow::CenterOnScreen}\label{wxwindowcenteronscreen}
+
+\func{void}{CenterOnScreen}{\param{int}{ direction}}
+
+A synonym for \helpref{CentreOnScreen}{wxwindowcentreonscreen}.
+
+
\membersection{wxWindow::Centre}\label{wxwindowcentre}
-\func{virtual void}{Centre}{\param{int}{ direction = wxHORIZONTAL}}
+\func{void}{Centre}{\param{int}{ direction = wxBOTH}}
Centres the window.
\wxheading{Parameters}
\docparam{direction}{Specifies the direction for the centering. May be {\tt wxHORIZONTAL}, {\tt wxVERTICAL}\rtfsp
-or {\tt wxBOTH}.}
+or {\tt wxBOTH}. It may also include {\tt wxCENTRE\_ON\_SCREEN} flag
+if you want to center the window on the entire screen and not on its
+parent window.}
+
+The flag {\tt wxCENTRE\_FRAME} is obsolete and should not be used any longer
+(it has no effect).
\wxheading{Remarks}
-The actual behaviour depends on the derived window. For a frame or dialog box,
-centring is relative to the whole display. For a panel item, centring is
-relative to the panel.
+If the window is a top level one (i.e. doesn't have a parent), it will be
+centered relative to the screen anyhow.
\wxheading{See also}
\helpref{wxWindow::Center}{wxwindowcenter}
-\membersection{wxWindow::Clear}\label{wxwindowclear}
-\func{void}{Clear}{\void}
+\membersection{wxWindow::CentreOnParent}\label{wxwindowcentreonparent}
+
+\func{void}{CentreOnParent}{\param{int}{ direction = wxBOTH}}
+
+Centres the window on its parent. This is a more readable synonym for
+\helpref{Centre}{wxwindowcentre}.
+
+\wxheading{Parameters}
+
+\docparam{direction}{Specifies the direction for the centering. May be {\tt wxHORIZONTAL}, {\tt wxVERTICAL}\rtfsp
+or {\tt wxBOTH}.}
+
+\wxheading{Remarks}
+
+This methods provides for a way to center top level windows over their
+parents instead of the entire screen. If there is no parent or if the
+window is not a top level window, then behaviour is the same as
+\helpref{wxWindow::Centre}{wxwindowcentre}.
+
+\wxheading{See also}
+
+\helpref{wxWindow::CentreOnScreen}{wxwindowcenteronscreen}
+
+
+\membersection{wxWindow::CentreOnScreen}\label{wxwindowcentreonscreen}
+
+\func{void}{CentreOnScreen}{\param{int}{ direction = wxBOTH}}
+
+Centres the window on screen. This only works for top level windows -
+otherwise, the window will still be centered on its parent.
+
+\wxheading{Parameters}
+
+\docparam{direction}{Specifies the direction for the centering. May be {\tt wxHORIZONTAL}, {\tt wxVERTICAL}\rtfsp
+or {\tt wxBOTH}.}
+
+\wxheading{See also}
+
+\helpref{wxWindow::CentreOnParent}{wxwindowcenteronparent}
+
+
+\membersection{wxWindow::ClearBackground}\label{wxwindowclearbackground}
+
+\func{void}{ClearBackground}{\void}
Clears the window by filling it with the current background colour. Does not
cause an erase background event to be generated.
-\membersection{wxWindow::ClientToScreen}
+
+\membersection{wxWindow::ClientToScreen}\label{wxwindowclienttoscreen}
\constfunc{virtual void}{ClientToScreen}{\param{int* }{x}, \param{int* }{y}}
+\perlnote{In wxPerl this method returns a 2-element list instead of
+modifying its parameters.}
+
\constfunc{virtual wxPoint}{ClientToScreen}{\param{const wxPoint\&}{ pt}}
Converts to screen coordinates from coordinates relative to this window.
\pythonnote{In place of a single overloaded method name, wxPython
implements the following methods:\par
\indented{2cm}{\begin{twocollist}
-\twocolitem{\bf{ClientToScreen(point)}}{Accepts and returns a wxPoint}
-\twocolitem{\bf{ClientToScreenXY(x, y)}}{Returns a 2-tuple, (x, y)}
+\twocolitem{{\bf ClientToScreen(point)}}{Accepts and returns a wxPoint}
+\twocolitem{{\bf ClientToScreenXY(x, y)}}{Returns a 2-tuple, (x, y)}
\end{twocollist}}
}
\membersection{wxWindow::Close}\label{wxwindowclose}
-\func{virtual bool}{Close}{\param{const bool}{ force = FALSE}}
+\func{bool}{Close}{\param{bool}{ force = {\tt false}}}
-The purpose of this call is to provide a safer way of destroying a window than using
-the {\it delete} operator.
+This function simply generates a \helpref{wxCloseEvent}{wxcloseevent} whose
+handler usually tries to close the window. It doesn't close the window itself,
+however.
\wxheading{Parameters}
-\docparam{force}{FALSE if the window's close handler should be able to veto the destruction
-of this window, TRUE if it cannot.}
+\docparam{force}{{\tt false} if the window's close handler should be able to veto the destruction
+of this window, {\tt true} if it cannot.}
\wxheading{Remarks}
-Close calls the \helpref{close handler}{wxcloseevent} for the window, providing an opportunity for the window to
-choose whether to destroy the window.
+Close calls the \helpref{close handler}{wxcloseevent} for the window, providing
+an opportunity for the window to choose whether to destroy the window.
+Usually it is only used with the top level windows (wxFrame and wxDialog
+classes) as the others are not supposed to have any special OnClose() logic.
The close handler should check whether the window is being deleted forcibly,
-using \helpref{wxCloseEvent::GetForce}{wxcloseeventgetforce}, in which case it should
-destroy the window using \helpref{wxWindow::Destroy}{wxwindowdestroy}.
+using \helpref{wxCloseEvent::CanVeto}{wxcloseeventcanveto}, in which case it
+should destroy the window using \helpref{wxWindow::Destroy}{wxwindowdestroy}.
+
+{\it Note} that calling Close does not guarantee that the window will be
+destroyed; but it provides a way to simulate a manual close of a window, which
+may or may not be implemented by destroying the window. The default
+implementation of wxDialog::OnCloseWindow does not necessarily delete the
+dialog, since it will simply simulate an wxID\_CANCEL event which is handled by
+the appropriate button event handler and may do anything at all.
-Applies to managed windows (wxFrame and wxDialog classes) only.
+To guarantee that the window will be destroyed, call
+\helpref{wxWindow::Destroy}{wxwindowdestroy} instead
\wxheading{See also}
\helpref{Window deletion overview}{windowdeletionoverview},\rtfsp
-\helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow},\rtfsp
\helpref{wxWindow::Destroy}{wxwindowdestroy},\rtfsp
\helpref{wxCloseEvent}{wxcloseevent}
+
\membersection{wxWindow::ConvertDialogToPixels}\label{wxwindowconvertdialogtopixels}
\func{wxPoint}{ConvertDialogToPixels}{\param{const wxPoint\&}{ pt}}
\wxheading{Remarks}
Dialog units are used for maintaining a dialog's proportions even if the font changes.
-Dialogs created using Dialog Editor optionally use dialog units.
You can also use these functions programmatically. A convenience macro is defined:
\pythonnote{In place of a single overloaded method name, wxPython
implements the following methods:\par
\indented{2cm}{\begin{twocollist}
-\twocolitem{\bf{ConvertDialogPointToPixels(point)}}{Accepts and returns a wxPoint}
-\twocolitem{\bf{ConvertDialogSizeToPixels(size)}}{Accepts and returns a wxSize}
+\twocolitem{{\bf ConvertDialogPointToPixels(point)}}{Accepts and returns a wxPoint}
+\twocolitem{{\bf ConvertDialogSizeToPixels(size)}}{Accepts and returns a wxSize}
\end{twocollist}}
Additionally, the following helper functions are defined:\par
\indented{2cm}{\begin{twocollist}
-\twocolitem{\bf{wxDLG_PNT(win, point)}}{Converts a wxPoint from dialog
+\twocolitem{{\bf wxDLG\_PNT(win, point)}}{Converts a wxPoint from dialog
units to pixels}
-\twocolitem{\bf{wxDLG_SZE(win, size)}}{Converts a wxSize from dialog
+\twocolitem{{\bf wxDLG\_SZE(win, size)}}{Converts a wxSize from dialog
units to pixels}
\end{twocollist}}
}
+
\membersection{wxWindow::ConvertPixelsToDialog}\label{wxwindowconvertpixelstodialog}
\func{wxPoint}{ConvertPixelsToDialog}{\param{const wxPoint\&}{ pt}}
For the x dimension, the pixels are multiplied by 4 and then divided by the average
character width.
-For the y dimension, the pixels are multipled by 8 and then divided by the average
+For the y dimension, the pixels are multiplied by 8 and then divided by the average
character height.
\wxheading{Remarks}
Dialog units are used for maintaining a dialog's proportions even if the font changes.
-Dialogs created using Dialog Editor optionally use dialog units.
\wxheading{See also}
\helpref{wxWindow::ConvertDialogToPixels}{wxwindowconvertdialogtopixels}
-
-\pythonnote{In place of a single overloaded method name, wxPython
-implements the following methods:\par
+\pythonnote{In place of a single overloaded method name, wxPython implements the following methods:\par
\indented{2cm}{\begin{twocollist}
-\twocolitem{\bf{ConvertDialogPointToPixels(point)}}{Accepts and returns a wxPoint}
-\twocolitem{\bf{ConvertDialogSizeToPixels(size)}}{Accepts and returns a wxSize}
+\twocolitem{{\bf ConvertDialogPointToPixels(point)}}{Accepts and returns a wxPoint}
+\twocolitem{{\bf ConvertDialogSizeToPixels(size)}}{Accepts and returns a wxSize}
\end{twocollist}}
}
+
\membersection{wxWindow::Destroy}\label{wxwindowdestroy}
\func{virtual bool}{Destroy}{\void}
Destroys the window safely. Use this function instead of the delete operator, since
different window classes can be destroyed differently. Frames and dialogs
-are not destroyed immediately when this function is called - they are added
+are not destroyed immediately when this function is called -- they are added
to a list of windows to be deleted on idle time, when all the window's events
-have been processed. This prevents problems with events being sent to non-existant
+have been processed. This prevents problems with events being sent to non-existent
windows.
\wxheading{Return value}
-TRUE if the window has either been successfully deleted, or it has been added
+{\tt true} if the window has either been successfully deleted, or it has been added
to the list of windows pending real deletion.
-\membersection{wxWindow::DestroyChildren}
+
+\membersection{wxWindow::DestroyChildren}\label{wxwindowdestroychildren}
\func{virtual void}{DestroyChildren}{\void}
Destroys all children of a window. Called automatically by the destructor.
+
+\membersection{wxWindow::Disable}\label{wxwindowdisable}
+
+\func{bool}{Disable}{\void}
+
+Disables the window, same as \helpref{Enable({\tt false})}{wxwindowenable}.
+
+\wxheading{Return value}
+
+Returns {\tt true} if the window has been disabled, {\tt false} if it had been
+already disabled before the call to this function.
+
+
+\membersection{wxWindow::DoGetBestSize}\label{wxwindowdogetbestsize}
+
+\constfunc{virtual wxSize}{DoGetBestSize}{\void}
+
+Gets the size which best suits the window: for a control, it would be
+the minimal size which doesn't truncate the control, for a panel - the
+same size as it would have after a call to \helpref{Fit()}{wxwindowfit}.
+
+
+\membersection{wxWindow::DoUpdateWindowUI}\label{wxwindowdoupdatewindowui}
+
+\func{virtual void}{DoUpdateWindowUI}{\param{wxUpdateUIEvent\&}{ event}}
+
+Does the window-specific updating after processing the update event.
+This function is called by \helpref{wxWindow::UpdateWindowUI}{wxwindowupdatewindowui}
+in order to check return values in the \helpref{wxUpdateUIEvent}{wxupdateuievent} and
+act appropriately. For example, to allow frame and dialog title updating, wxWidgets
+implements this function as follows:
+
+\begin{verbatim}
+// do the window-specific processing after processing the update event
+void wxTopLevelWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
+{
+ if ( event.GetSetEnabled() )
+ Enable(event.GetEnabled());
+
+ if ( event.GetSetText() )
+ {
+ if ( event.GetText() != GetTitle() )
+ SetTitle(event.GetText());
+ }
+}
+\end{verbatim}
+
+
+
\membersection{wxWindow::DragAcceptFiles}\label{wxwindowdragacceptfiles}
-\func{virtual void}{DragAcceptFiles}{\param{const bool}{ accept}}
+\func{virtual void}{DragAcceptFiles}{\param{bool}{ accept}}
-Enables or disables elibility for drop file events (OnDropFiles).
+Enables or disables eligibility for drop file events (OnDropFiles).
\wxheading{Parameters}
-\docparam{accept}{If TRUE, the window is eligible for drop file events. If FALSE, the window
+\docparam{accept}{If {\tt true}, the window is eligible for drop file events. If {\tt false}, the window
will not accept drop file events.}
\wxheading{Remarks}
Windows only.
-\wxheading{See also}
-
-\helpref{wxWindow::OnDropFiles}{wxwindowondropfiles}
\membersection{wxWindow::Enable}\label{wxwindowenable}
-\func{virtual void}{Enable}{\param{const bool}{ enable}}
+\func{virtual bool}{Enable}{\param{bool}{ enable = {\tt true}}}
-Enable or disable the window for user input.
+Enable or disable the window for user input. Note that when a parent window is
+disabled, all of its children are disabled as well and they are reenabled again
+when the parent is.
\wxheading{Parameters}
-\docparam{enable}{If TRUE, enables the window for input. If FALSE, disables the window.}
+\docparam{enable}{If {\tt true}, enables the window for input. If {\tt false}, disables the window.}
+
+\wxheading{Return value}
+
+Returns {\tt true} if the window has been enabled or disabled, {\tt false} if
+nothing was done, i.e. if the window had already been in the specified state.
\wxheading{See also}
-\helpref{wxWindow::IsEnabled}{wxwindowisenabled}
+\helpref{wxWindow::IsEnabled}{wxwindowisenabled},\rtfsp
+\helpref{wxWindow::Disable}{wxwindowdisable},\rtfsp
+\helpref{wxRadioBox::Enable}{wxradioboxenable}
+
\membersection{wxWindow::FindFocus}\label{wxwindowfindfocus}
\helpref{wxWindow::SetFocus}{wxwindowsetfocus}
+
+
\membersection{wxWindow::FindWindow}\label{wxwindowfindwindow}
-\func{wxWindow*}{FindWindow}{\param{long}{ id}}
+\constfunc{wxWindow*}{FindWindow}{\param{long}{ id}}
Find a child of this window, by identifier.
-\func{wxWindow*}{FindWindow}{\param{const wxString\&}{ name}}
+\constfunc{wxWindow*}{FindWindow}{\param{const wxString\&}{ name}}
Find a child of this window, by name.
\pythonnote{In place of a single overloaded method name, wxPython
implements the following methods:\par
\indented{2cm}{\begin{twocollist}
-\twocolitem{\bf{FindWindowById(id)}}{Accepts an integer}
-\twocolitem{\bf{FindWindowByName(name)}}{Accepts a string}
+\twocolitem{{\bf FindWindowById(id)}}{Accepts an integer}
+\twocolitem{{\bf FindWindowByName(name)}}{Accepts a string}
\end{twocollist}}
}
+
+\membersection{wxWindow::FindWindowById}\label{wxwindowfindwindowbyid}
+
+\func{static wxWindow*}{FindWindowById}{\param{long}{ id}, \param{wxWindow*}{ parent = NULL}}
+
+Find the first window with the given {\it id}.
+
+If {\it parent} is NULL, the search will start from all top-level
+frames and dialog boxes; if non-NULL, the search will be limited to the given window hierarchy.
+The search is recursive in both cases.
+
+\wxheading{See also}
+
+\helpref{FindWindow}{wxwindowfindwindow}
+
+
+\membersection{wxWindow::FindWindowByLabel}\label{wxwindowfindwindowbylabel}
+
+\func{static wxWindow*}{FindWindowByLabel}{\param{const wxString\&}{ label}, \param{wxWindow*}{ parent = NULL}}
+
+Find a window by its label. Depending on the type of window, the label may be a window title
+or panel item label. If {\it parent} is NULL, the search will start from all top-level
+frames and dialog boxes; if non-NULL, the search will be limited to the given window hierarchy.
+The search is recursive in both cases.
+
+\wxheading{See also}
+
+\helpref{FindWindow}{wxwindowfindwindow}
+
+
+\membersection{wxWindow::FindWindowByName}\label{wxwindowfindwindowbyname}
+
+\func{static wxWindow*}{FindWindowByName}{\param{const wxString\&}{ name}, \param{wxWindow*}{ parent = NULL}}
+
+Find a window by its name (as given in a window constructor or {\bf Create} function call).
+If {\it parent} is NULL, the search will start from all top-level
+frames and dialog boxes; if non-NULL, the search will be limited to the given window hierarchy.
+The search is recursive in both cases.
+
+If no window with such name is found,
+\helpref{FindWindowByLabel}{wxwindowfindwindowbylabel} is called.
+
+\wxheading{See also}
+
+\helpref{FindWindow}{wxwindowfindwindow}
+
+
\membersection{wxWindow::Fit}\label{wxwindowfit}
\func{virtual void}{Fit}{\void}
-Sizes the window so that it fits around its subwindows.
+Sizes the window so that it fits around its subwindows. This function won't do
+anything if there are no subwindows and will only really work correctly if
+sizers are used for the subwindows layout. Also, if the window has exactly one
+subwindow it is better (faster and the result is more precise as Fit adds some
+margin to account for fuzziness of its calculations) to call
+
+\begin{verbatim}
+ window->SetClientSize(child->GetSize());
+\end{verbatim}
+
+instead of calling Fit.
+
+
+\membersection{wxWindow::FitInside}\label{wxwindowfitinside}
+
+\func{virtual void}{FitInside}{\void}
+
+Similar to \helpref{Fit}{wxwindowfit}, but sizes the interior (virtual) size
+of a window. Mainly useful with scrolled windows to reset scrollbars after
+sizing changes that do not trigger a size event, and/or scrolled windows without
+an interior sizer. This function similarly won't do anything if there are no
+subwindows.
+
+
+\membersection{wxWindow::Freeze}\label{wxwindowfreeze}
+
+\func{virtual void}{Freeze}{\void}
+
+Freezes the window or, in other words, prevents any updates from taking place
+on screen, the window is not redrawn at all. \helpref{Thaw}{wxwindowthaw} must
+be called to reenable window redrawing. Calls to these two functions may be
+nested.
+
+This method is useful for visual appearance optimization (for example, it
+is a good idea to use it before doing many large text insertions in a row into
+a wxTextCtrl under wxGTK) but is not implemented on all platforms nor for all
+controls so it is mostly just a hint to wxWidgets and not a mandatory
+directive.
+
+\wxheading{See also}
+
+\helpref{wxWindowUpdateLocker}{wxwindowupdatelocker}
+
+
+\membersection{wxWindow::GetAcceleratorTable}\label{wxwindowgetacceleratortable}
+
+\constfunc{wxAcceleratorTable*}{GetAcceleratorTable}{\void}
+
+Gets the accelerator table for this window. See \helpref{wxAcceleratorTable}{wxacceleratortable}.
+
+
+\membersection{wxWindow::GetAccessible}\label{wxwindowgetaccessible}
+
+\func{wxAccessible*}{GetAccessible}{\void}
+
+Returns the accessible object for this window, if any.
+
+See also \helpref{wxAccessible}{wxaccessible}.
+
+
+\membersection{wxWindow::GetAdjustedBestSize}\label{wxwindowgetadjustedbestsize}
+
+\constfunc{wxSize}{GetAdjustedBestSize}{\void}
+
+This method is deprecated, use \helpref{GetEffectiveMinSize}{wxwindowgeteffectiveminsize}
+instead.
+
\membersection{wxWindow::GetBackgroundColour}\label{wxwindowgetbackgroundcolour}
\helpref{wxWindow::SetBackgroundColour}{wxwindowsetbackgroundcolour},\rtfsp
\helpref{wxWindow::SetForegroundColour}{wxwindowsetforegroundcolour},\rtfsp
+\helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour}
+
+\membersection{wxWindow::GetBackgroundStyle}\label{wxwindowgetbackgroundstyle}
+
+\constfunc{virtual wxBackgroundStyle}{GetBackgroundStyle}{\void}
+
+Returns the background style of the window. The background style indicates
+whether background colour should be determined by the system (wxBG\_STYLE\_SYSTEM),
+be set to a specific colour (wxBG\_STYLE\_COLOUR), or should be left to the
+application to implement (wxBG\_STYLE\_CUSTOM).
+
+On GTK+, use of wxBG\_STYLE\_CUSTOM allows the flicker-free drawing of a custom
+background, such as a tiled bitmap. Currently the style has no effect on other platforms.
+
+\wxheading{See also}
+
+\helpref{wxWindow::SetBackgroundColour}{wxwindowsetbackgroundcolour},\rtfsp
\helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour},\rtfsp
-\helpref{wxWindow::OnEraseBackground}{wxwindowonerasebackground}
+\helpref{wxWindow::SetBackgroundStyle}{wxwindowsetbackgroundstyle}
+
+\membersection{wxWindow::GetEffectiveMinSize}\label{wxwindowgeteffectiveminsize}
+
+\constfunc{wxSize}{GetEffectiveMinSize}{\void}
+
+Merges the window's best size into the min size and returns the
+result. This is the value used by sizers to determine the appropriate
+ammount of sapce to allocate for the widget.
+
+\wxheading{See also}
+
+\helpref{wxWindow::GetBestSize}{wxwindowgetbestsize},\rtfsp
+\helpref{wxWindow::SetInitialSize}{wxwindowsetinitialsize}
+
+
+\membersection{wxWindow::GetBestSize}\label{wxwindowgetbestsize}
+
+\constfunc{wxSize}{GetBestSize}{\void}
+
+This functions returns the best acceptable minimal size for the window. For
+example, for a static control, it will be the minimal size such that the
+control label is not truncated. For windows containing subwindows (typically
+\helpref{wxPanel}{wxpanel}), the size returned by this function will be the
+same as the size the window would have had after calling
+\helpref{Fit}{wxwindowfit}.
+
+
+\membersection{wxWindow::GetCapture}\label{wxwindowgetcapture}
+
+\func{static wxWindow *}{GetCapture}{\void}
+
+Returns the currently captured window.
+
+\wxheading{See also}
+
+\helpref{wxWindow::HasCapture}{wxwindowhascapture},
+\helpref{wxWindow::CaptureMouse}{wxwindowcapturemouse},
+\helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse},
+\helpref{wxMouseCaptureLostEvent}{wxmousecapturelostevent}
+\helpref{wxMouseCaptureChangedEvent}{wxmousecapturechangedevent}
+
+
+\membersection{wxWindow::GetCaret}\label{wxwindowgetcaret}
-\membersection{wxWindow::GetCharHeight}
+\constfunc{wxCaret *}{GetCaret}{\void}
+
+Returns the \helpref{caret}{wxcaret} associated with the window.
+
+
+\membersection{wxWindow::GetCharHeight}\label{wxwindowgetcharheight}
\constfunc{virtual int}{GetCharHeight}{\void}
Returns the character height for this window.
-\membersection{wxWindow::GetCharWidth}
+
+\membersection{wxWindow::GetCharWidth}\label{wxwindowgetcharwidth}
\constfunc{virtual int}{GetCharWidth}{\void}
Returns the average character width for this window.
-\membersection{wxWindow::GetChildren}
-\func{wxList\&}{GetChildren}{\void}
+\membersection{wxWindow::GetChildren}\label{wxwindowgetchildren}
+
+\func{wxWindowList\&}{GetChildren}{\void}
+
+\constfunc{const wxWindowList\&}{GetChildren}{\void}
+
+Returns a reference to the list of the window's children. \texttt{wxWindowList}
+is a type-safe \helpref{wxList}{wxlist}-like class whose elements are of type
+\texttt{wxWindow *}.
+
+
+\membersection{wxWindow::GetClassDefaultAttributes}\label{wxwindowgetclassdefaultattributes}
+
+\func{static wxVisualAttributes}{GetClassDefaultAttributes}{\param{wxWindowVariant}{ variant = \texttt{wxWINDOW\_VARIANT\_NORMAL}}}
+
+Returns the default font and colours which are used by the control. This is
+useful if you want to use the same font or colour in your own control as in a
+standard control -- which is a much better idea than hard coding specific
+colours or fonts which might look completely out of place on the users
+system, especially if it uses themes.
+
+The \arg{variant} parameter is only relevant under Mac currently and is
+ignore under other platforms. Under Mac, it will change the size of the
+returned font. See \helpref{wxWindow::SetWindowVariant}{wxwindowsetwindowvariant}
+for more about this.
+
+This static method is ``overridden'' in many derived classes and so calling,
+for example, \helpref{wxButton}{wxbutton}::GetClassDefaultAttributes() will typically
+return the values appropriate for a button which will be normally different
+from those returned by, say, \helpref{wxListCtrl}{wxlistctrl}::GetClassDefaultAttributes().
+
+The \texttt{wxVisualAttributes} structure has at least the fields
+\texttt{font}, \texttt{colFg} and \texttt{colBg}. All of them may be invalid
+if it was not possible to determine the default control appearance or,
+especially for the background colour, if the field doesn't make sense as is
+the case for \texttt{colBg} for the controls with themed background.
+
+\wxheading{See also}
+
+\helpref{InheritAttributes}{wxwindowinheritattributes}
-Returns a reference to the list of the window's children.
\membersection{wxWindow::GetClientSize}\label{wxwindowgetclientsize}
-\constfunc{virtual void}{GetClientSize}{\param{int* }{width}, \param{int* }{height}}
+\constfunc{void}{GetClientSize}{\param{int* }{width}, \param{int* }{height}}
+
+\perlnote{In wxPerl this method takes no parameter and returns
+a 2-element list {\tt (width, height)}.}
-\constfunc{virtual wxSize}{GetClientSize}{\void}
+\constfunc{wxSize}{GetClientSize}{\void}
-This gets the size of the window `client area' in pixels. The client area is the
-area which may be drawn on by the programmer, excluding title bar, border etc.
+Returns the size of the window `client area' in pixels. The client area is the
+area which may be drawn on by the programmer, excluding title bar, border,
+scrollbars, etc.
+
+Note that if this window is a top-level one and it is currently minimized, the
+return size is empty (both width and height are $0$).
\wxheading{Parameters}
\pythonnote{In place of a single overloaded method name, wxPython
implements the following methods:\par
\indented{2cm}{\begin{twocollist}
-\twocolitem{\bf{wxGetClientSizeTuple()}}{Returns a 2-tuple of (width, height)}
-\twocolitem{\bf{wxGetClientSize()}}{Returns a wxSize object}
+\twocolitem{{\bf GetClientSizeTuple()}}{Returns a 2-tuple of (width, height)}
+\twocolitem{{\bf GetClientSize()}}{Returns a wxSize object}
\end{twocollist}}
}
+\wxheading{See also}
+
+\helpref{GetSize}{wxwindowgetsize},\rtfsp
+\helpref{GetVirtualSize}{wxwindowgetvirtualsize}
+
+
+
\membersection{wxWindow::GetConstraints}\label{wxwindowgetconstraints}
\constfunc{wxLayoutConstraints*}{GetConstraints}{\void}
Returns a pointer to the window's layout constraints, or NULL if there are none.
-\membersection{wxWindow::GetDefaultItem}\label{wxwindowgetdefaultitem}
-\constfunc{wxButton*}{GetDefaultItem}{\void}
+\membersection{wxWindow::GetContainingSizer}\label{wxwindowgetcontainingsizer}
+
+\constfunc{const wxSizer *}{GetContainingSizer}{\void}
+
+Return the sizer that this window is a member of, if any, otherwise
+{\tt NULL}.
+
+
+\membersection{wxWindow::GetCursor}\label{wxwindowgetcursor}
+
+\constfunc{const wxCursor\&}{GetCursor}{\void}
+
+Return the cursor associated with this window.
+
+\wxheading{See also}
+
+\helpref{wxWindow::SetCursor}{wxwindowsetcursor}
+
+
+\membersection{wxWindow::GetDefaultAttributes}\label{wxwindowgetdefaultattributes}
+
+\constfunc{virtual wxVisualAttributes}{GetDefaultAttributes}{\void}
+
+Currently this is the same as calling
+\helpref{GetClassDefaultAttributes}{wxwindowgetclassdefaultattributes}(\helpref{GetWindowVariant}{wxwindowgetwindowvariant}()).
+
+One advantage of using this function compared to the static version is that
+the call is automatically dispatched to the correct class (as usual with
+virtual functions) and you don't have to specify the class name explicitly.
+
+The other one is that in the future this function could return different
+results, for example it might return a different font for an ``Ok'' button
+than for a generic button if the users GUI is configured to show such buttons
+in bold font. Of course, the down side is that it is impossible to call this
+function without actually having an object to apply it to whereas the static
+version can be used without having to create an object first.
-Returns a pointer to the button which is the default for this window, or NULL.
\membersection{wxWindow::GetDropTarget}\label{wxwindowgetdroptarget}
\helpref{wxWindow::SetDropTarget}{wxwindowsetdroptarget},
\helpref{Drag and drop overview}{wxdndoverview}
+
\membersection{wxWindow::GetEventHandler}\label{wxwindowgeteventhandler}
\constfunc{wxEvtHandler*}{GetEventHandler}{\void}
\helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
\helpref{wxEvtHandler}{wxevthandler}\rtfsp
+
+\membersection{wxWindow::GetExtraStyle}\label{wxwindowgetextrastyle}
+
+\constfunc{long}{GetExtraStyle}{\void}
+
+Returns the extra style bits for the window.
+
+
\membersection{wxWindow::GetFont}\label{wxwindowgetfont}
-\constfunc{wxFont\&}{GetFont}{\void}
+\constfunc{wxFont}{GetFont}{\void}
-Returns a reference to the font for this window.
+Returns the font for this window.
\wxheading{See also}
\helpref{wxWindow::SetFont}{wxwindowsetfont}
+
\membersection{wxWindow::GetForegroundColour}\label{wxwindowgetforegroundcolour}
\func{virtual wxColour}{GetForegroundColour}{\void}
\helpref{wxWindow::SetBackgroundColour}{wxwindowsetbackgroundcolour},\rtfsp
\helpref{wxWindow::GetBackgroundColour}{wxwindowgetbackgroundcolour}
-\membersection{wxWindow::GetGrandParent}
+
+\membersection{wxWindow::GetGrandParent}\label{wxwindowgetgrandparent}
\constfunc{wxWindow*}{GetGrandParent}{\void}
Returns the grandparent of a window, or NULL if there isn't one.
-\membersection{wxWindow::GetHandle}
+
+\membersection{wxWindow::GetHandle}\label{wxwindowgethandle}
\constfunc{void*}{GetHandle}{\void}
Returns the platform-specific handle of the physical window. Cast it to an appropriate
-handle, such as {\bf HWND} for Windows or {\bf Widget} for Motif.
+handle, such as {\bf HWND} for Windows, {\bf Widget} for Motif, {\bf GtkWidget} for GTK or {\bf WinHandle} for PalmOS.
-\membersection{wxWindow::GetId}\label{wxwindowgetid}
+\pythonnote{This method will return an integer in wxPython.}
-\constfunc{int}{GetId}{\void}
+\perlnote{This method will return an integer in wxPerl.}
-Returns the identifier of the window.
-\wxheading{Remarks}
+\membersection{wxWindow::GetHelpTextAtPoint}\label{wxwindowgethelptextatpoint}
-Each window has an integer identifier. If the application has not provided one,
-an identifier will be generated.
+\constfunc{virtual wxString}{GetHelpTextAtPoint}{\param{const wxPoint &}{point}, \param{wxHelpEvent::Origin }{origin}}
-\wxheading{See also}
+Gets the help text to be used as context-sensitive help for this window. This
+method should be overridden if the help message depends on the position inside
+the window, otherwise \helpref{GetHelpText}{wxwindowgethelptext} can be used.
-\helpref{wxWindow::SetId}{wxwindowsetid}\rtfsp
-\helpref{Window identifiers}{windowids}
+\wxheading{Parameters}
-\membersection{wxWindow::GetPosition}
+\docparam{point}{Coordinates of the mouse at the moment of help event emission.}
-\constfunc{virtual void}{GetPosition}{\param{int* }{x}, \param{int* }{y}}
+\docparam{origin}{Help event origin, see also \helpref{wxHelpEvent::GetOrigin}{wxhelpeventgetorigin}.}
-This gets the position of the window in pixels, relative to the parent window or
-if no parent, relative to the whole display.
+\newsince{2.7.0}
-\wxheading{Parameters}
-\docparam{x}{Receives the x position of the window.}
+\membersection{wxWindow::GetHelpText}\label{wxwindowgethelptext}
-\docparam{y}{Receives the y position of the window.}
+\constfunc{virtual wxString}{GetHelpText}{\void}
-\pythonnote{In place of a single overloaded method name, wxPython
-implements the following methods:\par
-\indented{2cm}{\begin{twocollist}
-\twocolitem{\bf{GetPosition()}}{Returns a wxPoint}
-\twocolitem{\bf{GetPositionTuple()}}{Returns a tuple (x, y)}
-\end{twocollist}}
-}
+Gets the help text to be used as context-sensitive help for this window.
-\membersection{wxWindow::GetLabel}
+Note that the text is actually stored by the current \helpref{wxHelpProvider}{wxhelpprovider} implementation,
+and not in the window object itself.
-\constfunc{virtual wxString\& }{GetLabel}{\void}
+\wxheading{See also}
-Generic way of getting a label from any window, for
-identification purposes.
+\helpref{SetHelpText}{wxwindowsethelptext}, \helpref{GetHelpTextAtPoint}{wxwindowgethelptextatpoint}, \helpref{wxHelpProvider}{wxhelpprovider}
-\wxheading{Remarks}
-The interpretation of this function differs from class to class.
-For frames and dialogs, the value returned is the title. For buttons or static text controls, it is
-the button text. This function can be useful for meta-programs (such as testing
-tools or special-needs access programs) which need to identify windows
-by name.
-
-\membersection{wxWindow::GetName}\label{wxwindowgetname}
+\membersection{wxWindow::GetId}\label{wxwindowgetid}
-\constfunc{virtual wxString\& }{GetName}{\void}
+\constfunc{int}{GetId}{\void}
-Returns the window's name.
+Returns the identifier of the window.
\wxheading{Remarks}
-This name is not guaranteed to be unique; it is up to the programmer to supply an appropriate
-name in the window constructor or via \helpref{wxWindow::SetName}{wxwindowsetname}.
+Each window has an integer identifier. If the application has not provided one
+(or the default wxID\_ANY) an unique identifier with a negative value will be generated.
\wxheading{See also}
-\helpref{wxWindow::SetName}{wxwindowsetname}
-
-\membersection{wxWindow::GetParent}
-
-\constfunc{virtual wxWindow*}{GetParent}{\void}
-
-Returns the parent of the window, or NULL if there is no parent.
-
-\membersection{wxWindow::GetRect}\label{wxwindowgetrect}
-
-\constfunc{virtual wxRect}{GetRect}{\void}
+\helpref{wxWindow::SetId}{wxwindowsetid},\rtfsp
+\helpref{Window identifiers}{windowids}
-Returns the size and position of the window as a \helpref{wxRect}{wxrect} object.
-\membersection{wxWindow::GetReturnCode}\label{wxwindowgetreturncode}
+\membersection{wxWindow::GetLabel}\label{wxwindowgetlabel}
-\func{int}{GetReturnCode}{\void}
+\constfunc{virtual wxString }{GetLabel}{\void}
-Gets the return code for this window.
+Generic way of getting a label from any window, for
+identification purposes.
\wxheading{Remarks}
-A return code is normally associated with a modal dialog, where \helpref{wxDialog::ShowModal}{wxdialogshowmodal} returns
-a code to the application.
+The interpretation of this function differs from class to class.
+For frames and dialogs, the value returned is the title. For buttons or static text controls, it is
+the button text. This function can be useful for meta-programs (such as testing
+tools or special-needs access programs) which need to identify windows
+by name.
+
+\membersection{wxWindow::GetMaxSize}\label{wxwindowgetmaxsize}
-\wxheading{See also}
+\constfunc{wxSize}{GetMaxSize}{\void}
-\helpref{wxWindow::SetReturnCode}{wxwindowsetreturncode}, \helpref{wxDialog::ShowModal}{wxdialogshowmodal},\rtfsp
-\helpref{wxDialog::EndModal}{wxdialogendmodal}
+Returns the maximum size of the window, an indication to the sizer layout mechanism
+that this is the maximum possible size.
-\membersection{wxWindow::GetScrollThumb}\label{wxwindowgetscrollthumb}
+\membersection{wxWindow::GetMinSize}\label{wxwindowgetminsize}
-\func{virtual int}{GetScrollThumb}{\param{int }{orientation}}
+\constfunc{virtual wxSize}{GetMinSize}{\void}
-Returns the built-in scrollbar thumb size.
+Returns the minimum size of the window, an indication to the sizer layout mechanism
+that this is the minimum required size. It normally just returns the value set
+by \helpref{SetMinSize}{wxwindowsetminsize}, but it can be overridden to do the
+calculation on demand.
-\wxheading{See also}
+\membersection{wxWindow::GetName}\label{wxwindowgetname}
-\helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar}
+\constfunc{virtual wxString }{GetName}{\void}
-\membersection{wxWindow::GetScrollPos}\label{wxwindowgetscrollpos}
+Returns the window's name.
-\func{virtual int}{GetScrollPos}{\param{int }{orientation}}
+\wxheading{Remarks}
-Returns the built-in scrollbar position.
+This name is not guaranteed to be unique; it is up to the programmer to supply an appropriate
+name in the window constructor or via \helpref{wxWindow::SetName}{wxwindowsetname}.
\wxheading{See also}
-See \helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar}
+\helpref{wxWindow::SetName}{wxwindowsetname}
-\membersection{wxWindow::GetScrollRange}\label{wxwindowgetscrollrange}
-\func{virtual int}{GetScrollRange}{\param{int }{orientation}}
+\membersection{wxWindow::GetParent}\label{wxwindowgetparent}
-Returns the built-in scrollbar range.
+\constfunc{virtual wxWindow*}{GetParent}{\void}
-\wxheading{See also}
+Returns the parent of the window, or NULL if there is no parent.
-\helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar}
-\membersection{wxWindow::GetSize}\label{wxwindowgetsize}
+\membersection{wxWindow::GetPopupMenuSelectionFromUser}\label{wxwindowgetpopupmenuselectionfromuser}
-\constfunc{virtual void}{GetSize}{\param{int* }{width}, \param{int* }{height}}
+\func{int}{GetPopupMenuSelectionFromUser}{\param{wxMenu\&}{ menu}, \param{const wxPoint\&}{ pos}}
-\constfunc{virtual wxSize}{GetSize}{\void}
+\func{int}{GetPopupMenuSelectionFromUser}{\param{wxMenu\&}{ menu}, \param{int}{ x}, \param{int}{ y}}
-This gets the size of the entire window in pixels.
+This function shows a popup menu at the given position in this window and
+returns the selected id. It can be more convenient than the general purpose
+\helpref{PopupMenu}{wxwindowpopupmenu} function for simple menus proposing a
+choice in a list of strings to the user.
\wxheading{Parameters}
-\docparam{width}{Receives the window width.}
+\docparam{menu}{The menu to show}
-\docparam{height}{Receives the window height.}
-
-\pythonnote{In place of a single overloaded method name, wxPython
-implements the following methods:\par
-\indented{2cm}{\begin{twocollist}
-\twocolitem{\bf{GetSize()}}{Returns a wxSize}
-\twocolitem{\bf{GetSizeTuple()}}{Returns a 2-tuple (width, height)}
-\end{twocollist}}
-}
+\docparam{pos}{The position at which to show the menu in client coordinates}
-\membersection{wxWindow::GetTextExtent}
+\docparam{x}{The horizontal position of the menu}
-\constfunc{virtual void}{GetTextExtent}{\param{const wxString\& }{string}, \param{int* }{x}, \param{int* }{y},
- \param{int* }{descent = NULL}, \param{int* }{externalLeading = NULL},
- \param{const wxFont* }{font = NULL}, \param{const bool}{ use16 = FALSE}}
+\docparam{y}{The vertical position of the menu}
-Gets the dimensions of the string as it would be drawn on the
-window with the currently selected font.
+\wxheading{Return value}
-\wxheading{Parameters}
+The selected menu item id or \texttt{wxID\_NONE} if none selected or an error
+occurred.
-\docparam{string}{String whose extent is to be measured.}
-\docparam{x}{Return value for width.}
+\membersection{wxWindow::GetPosition}\label{wxwindowgetposition}
-\docparam{y}{Return value for height.}
+\constfunc{virtual void}{GetPosition}{\param{int* }{x}, \param{int* }{y}}
-\docparam{descent}{Return value for descent (optional).}
+\constfunc{wxPoint}{GetPosition}{\void}
-\docparam{externalLeading}{Return value for external leading (optional).}
+This gets the position of the window in pixels, relative to the parent window
+for the child windows or relative to the display origin for the top level
+windows.
-\docparam{font}{Font to use instead of the current window font (optional).}
+\wxheading{Parameters}
-\docparam{use16}{If TRUE, {\it string} contains 16-bit characters. The default is FALSE.}
+\docparam{x}{Receives the x position of the window if non-\NULL.}
+\docparam{y}{Receives the y position of the window if non-\NULL.}
\pythonnote{In place of a single overloaded method name, wxPython
implements the following methods:\par
\indented{2cm}{\begin{twocollist}
-\twocolitem{\bf{GetTextExtent(string)}}{Returns a 2-tuple, (width, height)}
-\twocolitem{\bf{GetFullTextExtent(string, font=NULL)}}{Returns a
-4-tuple, (width, height, descent, externalLeading) }
+\twocolitem{{\bf GetPosition()}}{Returns a wxPoint}
+\twocolitem{{\bf GetPositionTuple()}}{Returns a tuple (x, y)}
\end{twocollist}}
}
+\perlnote{In wxPerl there are two methods instead of a single overloaded
+method:\par
+\indented{2cm}{\begin{twocollist}
+\twocolitem{{\bf GetPosition()}}{Returns a Wx::Point}
+\twocolitem{{\bf GetPositionXY()}}{Returns a 2-element list
+ {\tt ( x, y )}}
+\end{twocollist}
+}}
-\membersection{wxWindow::GetTitle}\label{wxwindowgettitle}
-
-\func{virtual wxString}{GetTitle}{\void}
-
-Gets the window's title. Applicable only to frames and dialogs.
\wxheading{See also}
-\helpref{wxWindow::SetTitle}{wxwindowsettitle}
-
-\membersection{wxWindow::GetUpdateRegion}\label{wxwindowgetupdateregion}
+\helpref{GetScreenPosition}{wxwindowgetscreenposition}
-\constfunc{virtual wxRegion}{GetUpdateRegion}{\void}
-Returns the region specifying which parts of the window have been damaged. Should
-only be called within an \helpref{OnPaint}{wxwindowonpaint} event handler.
-
-\wxheading{See also}
+\membersection{wxWindow::GetRect}\label{wxwindowgetrect}
-\helpref{wxRegion}{wxregion}, \helpref{wxRegionIterator}{wxregioniterator}, \helpref{wxWindow::OnPaint}{wxwindowonpaint}
+\constfunc{virtual wxRect}{GetRect}{\void}
-\membersection{wxWindow::GetWindowStyleFlag}
+Returns the position and size of the window as a \helpref{wxRect}{wxrect} object.
-\constfunc{long}{GetWindowStyleFlag}{\void}
+\wxheading{See also}
-Gets the window style that was passed to the consructor or {\bf Create} member.
+\helpref{GetScreenRect}{wxwindowgetscreenrect}
-\membersection{wxWindow::InitDialog}\label{wxwindowinitdialog}
-\func{void}{InitDialog}{\void}
+\membersection{wxWindow::GetScreenPosition}\label{wxwindowgetscreenposition}
-Sends an \helpref{wxWindow::OnInitDialog}{wxwindowoninitdialog} event, which
-in turn transfers data to the dialog via validators.
+\constfunc{virtual void}{GetScreenPosition}{\param{int* }{x}, \param{int* }{y}}
-\wxheading{See also}
+\constfunc{wxPoint}{GetScreenPosition}{\void}
-\helpref{wxWindow::OnInitDialog}{wxwindowoninitdialog}
+Returns the window position in screen coordinates, whether the window is a
+child window or a top level one.
-\membersection{wxWindow::IsEnabled}\label{wxwindowisenabled}
+\wxheading{Parameters}
-\constfunc{virtual bool}{IsEnabled}{\void}
+\docparam{x}{Receives the x position of the window on the screen if non-\NULL.}
-Returns TRUE if the window is enabled for input, FALSE otherwise.
+\docparam{y}{Receives the y position of the window on the screen if non-\NULL.}
\wxheading{See also}
-\helpref{wxWindow::Enable}{wxwindowenable}
+\helpref{GetPosition}{wxwindowgetposition}
-\membersection{wxWindow::IsRetained}\label{wxwindowisretained}
-\constfunc{virtual bool}{IsRetained}{\void}
+\membersection{wxWindow::GetScreenRect}\label{wxwindowgetscreenrect}
-Returns TRUE if the window is retained, FALSE otherwise.
+\constfunc{virtual wxRect}{GetScreenRect}{\void}
-\wxheading{Remarks}
+Returns the position and size of the window on the screen as a
+\helpref{wxRect}{wxrect} object.
-Retained windows are only available on X platforms.
-
-\membersection{wxWindow::IsShown}\label{wxwindowisshown}
-
-\constfunc{virtual bool}{IsShown}{\void}
+\wxheading{See also}
-Returns TRUE if the window is shown, FALSE if it has been hidden.
+\helpref{GetRect}{wxwindowgetrect}
-\membersection{wxWindow::Layout}\label{wxwindowlayout}
-\func{void}{Layout}{\void}
+\membersection{wxWindow::GetScrollPos}\label{wxwindowgetscrollpos}
-Invokes the constraint-based layout algorithm for this window. It is called
-automatically by the default {\bf wxWindow::OnSize} member.
+\func{virtual int}{GetScrollPos}{\param{int }{orientation}}
-\membersection{wxWindow::LoadFromResource}\label{wxwindowloadfromresource}
+Returns the built-in scrollbar position.
-\func{virtual bool}{LoadFromResource}{\param{wxWindow* }{parent},\rtfsp
-\param{const wxString\& }{resourceName}, \param{const wxResourceTable* }{resourceTable = NULL}}
+\wxheading{See also}
-Loads a panel or dialog from a resource file.
+See \helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar}
-\wxheading{Parameters}
-\docparam{parent}{Parent window.}
+\membersection{wxWindow::GetScrollRange}\label{wxwindowgetscrollrange}
-\docparam{resourceName}{The name of the resource to load.}
+\func{virtual int}{GetScrollRange}{\param{int }{orientation}}
-\docparam{resourceTable}{The resource table to load it from. If this is NULL, the
-default resource table will be used.}
+Returns the built-in scrollbar range.
-\wxheading{Return value}
+\wxheading{See also}
-TRUE if the operation succeeded, otherwise FALSE.
+\helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar}
-\membersection{wxWindow::Lower}\label{wxwindowlower}
-\func{void}{Lower}{\void}
+\membersection{wxWindow::GetScrollThumb}\label{wxwindowgetscrollthumb}
-Lowers the window to the bottom of the window hierarchy if it is a managed window (dialog
-or frame).
+\func{virtual int}{GetScrollThumb}{\param{int }{orientation}}
-\membersection{wxWindow::MakeModal}\label{wxwindowmakemodal}
+Returns the built-in scrollbar thumb size.
-\func{virtual void}{MakeModal}{\param{const bool }{flag}}
+\wxheading{See also}
-Disables all other windows in the application so that
-the user can only interact with this window.
+\helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar}
-\wxheading{Parameters}
-\docparam{flag}{If TRUE, this call disables all other windows in the application so that
-the user can only interact with this window. If FALSE, the effect is reversed.}
+\membersection{wxWindow::GetSize}\label{wxwindowgetsize}
-\membersection{wxWindow::Move}\label{wxwindowmove}
+\constfunc{void}{GetSize}{\param{int* }{width}, \param{int* }{height}}
-\func{void}{Move}{\param{int}{ x}, \param{int}{ y}}
+\constfunc{wxSize}{GetSize}{\void}
-\func{void}{Move}{\param{const wxPoint\&}{ pt}}
+Returns the size of the entire window in pixels, including title bar, border,
+scrollbars, etc.
-Moves the window to the given position.
+Note that if this window is a top-level one and it is currently minimized, the
+returned size is the restored window size, not the size of the window icon.
\wxheading{Parameters}
-\docparam{x}{Required x position.}
-
-\docparam{y}{Required y position.}
-
-\docparam{pt}{\helpref{wxPoint}{wxpoint} object representing the position.}
-
-\wxheading{Remarks}
-
-Implementations of SetSize can also implicitly implement the
-wxWindow::Move function, which is defined in the base wxWindow class
-as the call:
-
-\begin{verbatim}
- SetSize(x, y, -1, -1, wxSIZE_USE_EXISTING);
-\end{verbatim}
-
-\wxheading{See also}
+\docparam{width}{Receives the window width.}
-\helpref{wxWindow::SetSize}{wxwindowsetsize}
+\docparam{height}{Receives the window height.}
\pythonnote{In place of a single overloaded method name, wxPython
implements the following methods:\par
\indented{2cm}{\begin{twocollist}
-\twocolitem{\bf{Move(point)}}{Accepts a wxPoint}
-\twocolitem{\bf{MoveXY(x, y)}}{Accepts a pair of integers}
+\twocolitem{{\bf GetSize()}}{Returns a wxSize}
+\twocolitem{{\bf GetSizeTuple()}}{Returns a 2-tuple (width, height)}
\end{twocollist}}
}
-\membersection{wxWindow::OnActivate}\label{wxwindowonactivate}
+\perlnote{In wxPerl there are two methods instead of a single overloaded
+method:\par
+\indented{2cm}{\begin{twocollist}
+\twocolitem{{\bf GetSize()}}{Returns a Wx::Size}
+\twocolitem{{\bf GetSizeWH()}}{Returns a 2-element list
+ {\tt ( width, height )}}
+\end{twocollist}
+}}
-\func{void}{OnActivate}{\param{wxActivateEvent\&}{ event}}
+\wxheading{See also}
-Called when a window is activated or deactivated.
+\helpref{GetClientSize}{wxwindowgetclientsize},\rtfsp
+\helpref{GetVirtualSize}{wxwindowgetvirtualsize}
-\wxheading{Parameters}
-\docparam{event}{Object containing activation information.}
+\membersection{wxWindow::GetSizer}\label{wxwindowgetsizer}
-\wxheading{Remarks}
+\constfunc{wxSizer *}{GetSizer}{\void}
-If the window is being activated, \helpref{wxActivateEvent::GetActive}{wxactivateeventgetactive} returns TRUE,
-otherwise it returns FALSE (it is being deactivated).
+Return the sizer associated with the window by a previous call to
+\helpref{SetSizer()}{wxwindowsetsizer} or {\tt NULL}.
-\wxheading{See also}
-\helpref{wxActivateEvent}{wxactivateevent},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\membersection{wxWindow::GetTextExtent}\label{wxwindowgettextextent}
-\membersection{wxWindow::OnChar}\label{wxwindowonchar}
+\constfunc{virtual void}{GetTextExtent}{\param{const wxString\& }{string}, \param{int* }{w}, \param{int* }{h},
+ \param{int* }{descent = NULL}, \param{int* }{externalLeading = NULL},
+ \param{const wxFont* }{font = NULL}, \param{bool}{ use16 = {\tt false}}}
-\func{void}{OnChar}{\param{wxKeyEvent\&}{ event}}
+\constfunc{wxSize}{GetTextExtent}{\param{const wxString\& }{string}}
-Called when the user has pressed a key that is not a modifier (SHIFT, CONTROL or ALT).
+Gets the dimensions of the string as it would be drawn on the
+window with the currently selected font.
-\wxheading{Parameters}
+The text extent is returned in \arg{w} and \arg{h} pointers (first form) or as a
+\helpref{wxSize}{wxsize} object (second form).
-\docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
-details about this class.}
+\wxheading{Parameters}
-\wxheading{Remarks}
+\docparam{string}{String whose extent is to be measured.}
-This member function is called in response to a keypress. To intercept this event,
-use the EVT\_CHAR macro in an event table definition. Your {\bf OnChar} handler may call this
-default function to achieve default keypress functionality.
+\docparam{w}{Return value for width.}
-Note that the ASCII values do not have explicit key codes: they are passed as ASCII
-values.
+\docparam{h}{Return value for height.}
-Note that not all keypresses can be intercepted this way. If you wish to intercept modifier
-keypresses, then you will need to use \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown} or
-\helpref{wxWindow::OnKeyUp}{wxwindowonkeyup}.
+\docparam{descent}{Return value for descent (optional).}
-Most, but not all, windows allow keypresses to be intercepted.
+\docparam{externalLeading}{Return value for external leading (optional).}
-\wxheading{See also}
+\docparam{font}{Font to use instead of the current window font (optional).}
-\helpref{wxWindow::OnKeyDown}{wxwindowonkeydown}, \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup},\rtfsp
-\helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\docparam{use16}{If {\tt true}, {\it string} contains 16-bit characters. The default is {\tt false}.}
-\membersection{wxWindow::OnCharHook}\label{wxwindowoncharhook}
+\pythonnote{In place of a single overloaded method name, wxPython
+implements the following methods:\par
+\indented{2cm}{\begin{twocollist}
+\twocolitem{{\bf GetTextExtent(string)}}{Returns a 2-tuple, (width, height)}
+\twocolitem{{\bf GetFullTextExtent(string, font=NULL)}}{Returns a
+4-tuple, (width, height, descent, externalLeading) }
+\end{twocollist}}
+}
-\func{void}{OnCharHook}{\param{wxKeyEvent\&}{ event}}
+\perlnote{In wxPerl this method takes only the {\tt string} and optionally
+ {\tt font} parameters, and returns a 4-element list
+ {\tt ( x, y, descent, externalLeading )}.}
-This member is called to allow the window to intercept keyboard events
-before they are processed by child windows.
-\wxheading{Parameters}
+\membersection{wxWindow::GetToolTip}\label{wxwindowgettooltip}
-\docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
-details about this class.}
+\constfunc{wxToolTip*}{GetToolTip}{\void}
-\wxheading{Remarks}
+Get the associated tooltip or NULL if none.
-This member function is called in response to a keypress, if the window is active. To intercept this event,
-use the EVT\_CHAR\_HOOK macro in an event table definition. If you do not process a particular
-keypress, call \helpref{wxEvent::Skip}{wxeventskip} to allow default processing.
-An example of using this function is in the implementation of escape-character processing for wxDialog,
-where pressing ESC dismisses the dialog by {\bf OnCharHook} 'forging' a cancel button press event.
+\membersection{wxWindow::GetUpdateRegion}\label{wxwindowgetupdateregion}
-Note that the ASCII values do not have explicit key codes: they are passed as ASCII
-values.
+\constfunc{virtual wxRegion}{GetUpdateRegion}{\void}
-This function is only relevant to top-level windows (frames and dialogs), and under
-Windows only.
+Returns the region specifying which parts of the window have been damaged. Should
+only be called within an \helpref{wxPaintEvent}{wxpaintevent} handler.
\wxheading{See also}
-\helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
-\helpref{wxApp::OnCharHook}{wxapponcharhook},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\helpref{wxRegion}{wxregion},\rtfsp
+\helpref{wxRegionIterator}{wxregioniterator}
-\membersection{wxWindow::OnCommand}\label{wxwindowoncommand}
-\func{virtual void}{OnCommand}{\param{wxEvtHandler\& }{object}, \param{wxCommandEvent\& }{event}}
+\membersection{wxWindow::GetValidator}\label{wxwindowgetvalidator}
-This virtual member function is called if the control does not handle the command event.
-
-\wxheading{Parameters}
+\constfunc{wxValidator*}{GetValidator}{\void}
-\docparam{object}{Object receiving the command event.}
-
-\docparam{event}{Command event}
-
-\wxheading{Remarks}
+Returns a pointer to the current validator for the window, or NULL if there is none.
-This virtual function is provided mainly for backward compatibility. You can also intercept commands
-from child controls by using an event table, with identifiers or identifier ranges to identify
-the control(s) in question.
-\wxheading{See also}
+\membersection{wxWindow::GetVirtualSize}\label{wxwindowgetvirtualsize}
-\helpref{wxCommandEvent}{wxcommandevent},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\constfunc{void}{GetVirtualSize}{\param{int* }{width}, \param{int* }{height}}
-\membersection{wxWindow::OnClose}\label{wxwindowonclose}
+\constfunc{wxSize}{GetVirtualSize}{\void}
-\func{virtual bool}{OnClose}{\void}
+This gets the virtual size of the window in pixels. By default it
+returns the client size of the window, but after a call to
+\helpref{SetVirtualSize}{wxwindowsetvirtualsize} it will return
+that size.
-Called when the user has tried to close a a frame
-or dialog box using the window manager (X) or system menu (Windows).
+\wxheading{Parameters}
-{\bf Note:} This is an obsolete function.
-It is superceded by the \helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow} event
-handler.
+\docparam{width}{Receives the window virtual width.}
-\wxheading{Return value}
+\docparam{height}{Receives the window virtual height.}
-If TRUE is returned by OnClose, the window will be deleted by the system, otherwise the
-attempt will be ignored. Do not delete the window from within this handler, although
-you may delete other windows.
+\helpref{GetSize}{wxwindowgetsize},\rtfsp
+\helpref{GetClientSize}{wxwindowgetclientsize}
-\wxheading{See also}
-\helpref{Window deletion overview}{windowdeletionoverview},\rtfsp
-\helpref{wxWindow::Close}{wxwindowclose},\rtfsp
-\helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow},\rtfsp
-\helpref{wxCloseEvent}{wxcloseevent}
+\membersection{wxWindow::GetWindowBorderSize}\label{wxwindowgetwindowbordersize}
-\membersection{wxWindow::OnCloseWindow}\label{wxwindowonclosewindow}
+\constfunc{wxSize}{GetWindowBorderSize}{\void}
-\func{void}{OnCloseWindow}{\param{wxCloseEvent\& }{event}}
+Returns the size of the left/right and top/bottom borders of this window in x
+and y components of the result respectively.
-This is an event handler function called when the user has tried to close a a frame
-or dialog box using the window manager (X) or system menu (Windows). It is
-called via the \helpref{wxWindow::Close}{wxwindowclose} function, so
-that the application can also invoke the handler programmatically.
-Use the EVT\_CLOSE event table macro to handle close events.
+\membersection{wxWindow::GetWindowStyleFlag}\label{wxwindowgetwindowstyleflag}
-You should check whether the application is forcing the deletion of the window
-using \helpref{wxCloseEvent::GetForce}{wxcloseeventgetforce}. If this is TRUE,
-destroy the window using \helpref{wxWindow::Destroy}{wxwindowdestroy}.
-If not, it is up to you whether you respond by destroying the window.
+\constfunc{long}{GetWindowStyleFlag}{\void}
-(Note: GetForce is now superceded by CanVeto. So to test whether forced destruction of
-the window is required, test for the negative of CanVeto. If CanVeto returns FALSE,
-it is not possible to skip window deletion.)
+Gets the window style that was passed to the constructor or {\bf Create}
+method. {\bf GetWindowStyle()} is another name for the same function.
-If you don't destroy the window, you should call \helpref{wxCloseEvent::Veto}{wxcloseeventveto} to
-let the calling code know that you did not destroy the window. This allows the \helpref{wxWindow::Close}{wxwindowclose} function
-to return TRUE or FALSE depending on whether the close instruction was honoured or not.
-\wxheading{Remarks}
+\membersection{wxWindow::GetWindowVariant}\label{wxwindowgetwindowvariant}
-The \helpref{wxWindow::OnClose}{wxwindowonclose} virtual function remains
-for backward compatibility with earlier versions of wxWindows. The
-default {\bf OnCloseWindow} handler for wxFrame and wxDialog will call {\bf OnClose},
-destroying the window if it returns TRUE or if the close is being forced.
+\constfunc{wxWindowVariant}{GetWindowVariant}{\void}
-\wxheading{See also}
+Returns the value previously passed to
+\helpref{wxWindow::SetWindowVariant}{wxwindowsetwindowvariant}.
-\helpref{Window deletion overview}{windowdeletionoverview},\rtfsp
-\helpref{wxWindow::Close}{wxwindowclose},\rtfsp
-\helpref{wxWindow::OnClose}{wxwindowonclose},\rtfsp
-\helpref{wxWindow::Destroy}{wxwindowdestroy},\rtfsp
-\helpref{wxCloseEvent}{wxcloseevent},\rtfsp
-\helpref{wxApp::OnQueryEndSession}{wxapponqueryendsession},\rtfsp
-\helpref{wxApp::OnEndSession}{wxapponendsession}
-\membersection{wxWindow::OnDropFiles}\label{wxwindowondropfiles}
+\membersection{wxWindow::HasCapture}\label{wxwindowhascapture}
-\func{void}{OnDropFiles}{\param{wxDropFilesEvent\&}{ event}}
+\constfunc{virtual bool}{HasCapture}{\void}
-Called when files have been dragged from the file manager to the window.
+Returns {\tt true} if this window has the current mouse capture.
-\wxheading{Parameters}
+\wxheading{See also}
-\docparam{event}{Drop files event. For more information, see \helpref{wxDropFilesEvent}{wxdropfilesevent}.}
+\helpref{wxWindow::CaptureMouse}{wxwindowcapturemouse},
+\helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse},
+\helpref{wxMouseCaptureLostEvent}{wxmousecapturelostevent}
+\helpref{wxMouseCaptureChangedEvent}{wxmousecapturechangedevent}
-\wxheading{Remarks}
-The window must have previously been enabled for dropping by calling
-\rtfsp\helpref{wxWindow::DragAcceptFiles}{wxwindowdragacceptfiles}.
+\membersection{wxWindow::HasExtraStyle}\label{wxwindowhasextrastyle}
-This event is only generated under Windows.
+\constfunc{bool}{HasExtraStyle}{\param{int }{exFlag}}
-To intercept this event, use the EVT\_DROP\_FILES macro in an event table definition.
+Returns \texttt{true} if the window has the given \arg{exFlag} bit set in its
+extra styles.
\wxheading{See also}
-\helpref{wxDropFilesEvent}{wxdropfilesevent}, \helpref{wxWindow::DragAcceptFiles}{wxwindowdragacceptfiles},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\helpref{SetExtraStyle}{wxwindowsetextrastyle}
-\membersection{wxWindow::OnEraseBackground}\label{wxwindowonerasebackground}
-\func{void}{OnEraseBackground}{\param{wxEraseEvent\&}{ event}}
+\membersection{wxWindow::HasFlag}\label{wxwindowhasflag}
-Called when the background of the window needs to be erased.
+\constfunc{bool}{HasFlag}{\param{int }{flag}}
-\wxheading{Parameters}
+Returns \texttt{true} if the window has the given \arg{flag} bit set.
-\docparam{event}{Erase background event. For more information, see \helpref{wxEraseEvent}{wxeraseevent}.}
-\wxheading{Remarks}
-
-This event is only generated under Windows.
+\membersection{wxWindow::HasMultiplePages}\label{wxwindowhasmultiplepages}
-To intercept this event, use the EVT\_ERASE\_BACKGROUND macro in an event table definition.
+\constfunc{virtual bool}{HasMultiplePages}{\void}
-\wxheading{See also}
+This method should be overridden to return \texttt{true} if this window has
+multiple pages. All standard class with multiple pages such as
+\helpref{wxNotebook}{wxnotebook}, \helpref{wxListbook}{wxlistbook} and
+\helpref{wxTreebook}{wxtreebook} already override it to return \texttt{true}
+and user-defined classes with similar behaviour should do it as well to allow
+the library to handle such windows appropriately.
-\helpref{wxEraseEvent}{wxeraseevent}, \helpref{Event handling overview}{eventhandlingoverview}
-\membersection{wxWindow::OnKeyDown}\label{wxwindowonkeydown}
+\membersection{wxWindow::HasScrollbar}\label{wxwindowhasscrollbar}
-\func{void}{OnKeyDown}{\param{wxKeyEvent\&}{ event}}
+\constfunc{virtual bool}{HasScrollbar}{\param{int }{orient}}
-Called when the user has pressed a key, before it is translated into an ASCII value using other
-modifier keys that might be pressed at the same time.
+Returns {\tt true} if this window has a scroll bar for this orientation.
\wxheading{Parameters}
-\docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
-details about this class.}
+\docparam{orient}{Orientation to check, either {\tt wxHORIZONTAL} or {\tt wxVERTICAL}.}
-\wxheading{Remarks}
-This member function is called in response to a key down event. To intercept this event,
-use the EVT\_KEY\_DOWN macro in an event table definition. Your {\bf OnKeyDown} handler may call this
-default function to achieve default keypress functionality.
+\membersection{wxWindow::HasTransparentBackground}\label{wxwindowhastransparentbackground}
-Note that not all keypresses can be intercepted this way. If you wish to intercept special
-keys, such as shift, control, and function keys, then you will need to use \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown} or
-\helpref{wxWindow::OnKeyUp}{wxwindowonkeyup}.
+\constfunc{virtual bool}{HasTransparentBackground}{\void}
-Most, but not all, windows allow keypresses to be intercepted.
+Returns \true if this window background is transparent (as, for example, for
+wxStaticText) and should show the parent window background.
-\wxheading{See also}
+This method is mostly used internally by the library itself and you normally
+shouldn't have to call it. You may, however, have to override it in your
+wxWindow-derived class to ensure that background is painted correctly.
-\helpref{wxWindow::OnChar}{wxwindowonchar}, \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup},\rtfsp
-\helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
-\membersection{wxWindow::OnKeyUp}\label{wxwindowonkeyup}
+\membersection{wxWindow::Hide}\label{wxwindowhide}
-\func{void}{OnKeyUp}{\param{wxKeyEvent\&}{ event}}
+\func{bool}{Hide}{\void}
-Called when the user has released a key.
+Equivalent to calling \helpref{Show}{wxwindowshow}({\tt false}).
-\wxheading{Parameters}
-\docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
-details about this class.}
+\membersection{wxWindow::InheritAttributes}\label{wxwindowinheritattributes}
-\wxheading{Remarks}
+\func{void}{InheritAttributes}{\void}
-This member function is called in response to a key up event. To intercept this event,
-use the EVT\_KEY\_UP macro in an event table definition. Your {\bf OnKeyUp} handler may call this
-default function to achieve default keypress functionality.
+This function is (or should be, in case of custom controls) called during
+window creation to intelligently set up the window visual attributes, that is
+the font and the foreground and background colours.
-Note that not all keypresses can be intercepted this way. If you wish to intercept special
-keys, such as shift, control, and function keys, then you will need to use \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown} or
-\helpref{wxWindow::OnKeyUp}{wxwindowonkeyup}.
+By ``intelligently'' the following is meant: by default, all windows use their
+own \helpref{default}{wxwindowgetclassdefaultattributes} attributes. However
+if some of the parents attributes are explicitly (that is, using
+\helpref{SetFont}{wxwindowsetfont} and not
+\helpref{SetOwnFont}{wxwindowsetownfont}) changed \emph{and} if the
+corresponding attribute hadn't been explicitly set for this window itself,
+then this window takes the same value as used by the parent. In addition, if
+the window overrides \helpref{ShouldInheritColours}{wxwindowshouldinheritcolours}
+to return \false, the colours will not be changed no matter what and only the
+font might.
-Most, but not all, windows allow key up events to be intercepted.
+This rather complicated logic is necessary in order to accommodate the
+different usage scenarios. The most common one is when all default attributes
+are used and in this case, nothing should be inherited as in modern GUIs
+different controls use different fonts (and colours) than their siblings so
+they can't inherit the same value from the parent. However it was also deemed
+desirable to allow to simply change the attributes of all children at once by
+just changing the font or colour of their common parent, hence in this case we
+do inherit the parents attributes.
-\wxheading{See also}
-\helpref{wxWindow::OnChar}{wxwindowonchar}, \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown},\rtfsp
-\helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\membersection{wxWindow::InitDialog}\label{wxwindowinitdialog}
-\membersection{wxWindow::OnKillFocus}\label{wxwindowonkillfocus}
+\func{void}{InitDialog}{\void}
-\func{void}{OnKillFocus}{\param{wxFocusEvent\& }{event}}
+Sends an {\tt wxEVT\_INIT\_DIALOG} event, whose handler usually transfers data
+to the dialog via validators.
-Called when a window's focus is being killed.
-\wxheading{Parameters}
+\membersection{wxWindow::InvalidateBestSize}\label{wxwindowinvalidatebestsize}
-\docparam{event}{The focus event. For more information, see \helpref{wxFocusEvent}{wxfocusevent}.}
+\func{void}{InvalidateBestSize}{\void}
-\wxheading{Remarks}
+Resets the cached best size value so it will be recalculated the next time it is needed.
-To intercept this event, use the macro EVT\_KILL\_FOCUS in an event table definition.
-Most, but not all, windows respond to this event.
+\membersection{wxWindow::IsDoubleBuffered}\label{wxwindowisdoublebuffered}
-\wxheading{See also}
+\constfunc{virtual bool}{IsDoubleBuffered}{\void}
-\helpref{wxFocusEvent}{wxfocusevent}, \helpref{wxWindow::OnSetFocus}{wxwindowonsetfocus},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+Returns \true if the window contents is double-buffered by the system, i.e. if
+any drawing done on the window is really done on a temporary backing surface
+and transferred to the screen all at once later.
-\membersection{wxWindow::OnIdle}\label{wxwindowonidle}
+\wxheading{See also}
-\func{void}{OnIdle}{\param{wxIdleEvent\& }{event}}
+\helpref{wxBufferedDC}{wxbuffereddc}
-Provide this member function for any processing which needs to be done
-when the application is idle.
-\wxheading{See also}
+\membersection{wxWindow::IsEnabled}\label{wxwindowisenabled}
-\helpref{wxApp::OnIdle}{wxapponidle}, \helpref{wxIdleEvent}{wxidleevent}
+\constfunc{virtual bool}{IsEnabled}{\void}
-\membersection{wxWindow::OnInitDialog}\label{wxwindowoninitdialog}
+Returns \true if the window is enabled, i.e. if it accepts user input, \false
+otherwise.
-\func{void}{OnInitDialog}{\param{wxInitDialogEvent\&}{ event}}
+Notice that this method can return \false even if this window itself hadn't
+been explicitly disabled when one of its parent windows is disabled. To get the
+intrinsic status of this window, use
+\helpref{IsThisEnabled}{wxwindowisthisenabled}
-Default handler for the wxEVT\_INIT\_DIALOG event. Calls \helpref{wxWindow::TransferDataToWindow}{wxwindowtransferdatatowindow}.
+\wxheading{See also}
-\wxheading{Parameters}
+\helpref{wxWindow::Enable}{wxwindowenable}
-\docparam{event}{Dialog initialisation event.}
-\wxheading{Remarks}
+\membersection{wxWindow::IsExposed}\label{wxwindowisexposed}
-Gives the window the default behaviour of transferring data to child controls via
-the validator that each control has.
+\constfunc{bool}{IsExposed}{\param{int }{x}, \param{int }{y}}
-\wxheading{See also}
+\constfunc{bool}{IsExposed}{\param{wxPoint }{\&pt}}
-\helpref{wxValidator}{wxvalidator}, \helpref{wxWindow::TransferDataToWindow}{wxwindowtransferdatatowindow}
+\constfunc{bool}{IsExposed}{\param{int }{x}, \param{int }{y}, \param{int }{w}, \param{int }{h}}
-\membersection{wxWindow::OnMenuCommand}\label{wxwindowonmenucommand}
+\constfunc{bool}{IsExposed}{\param{wxRect }{\&rect}}
-\func{void}{OnMenuCommand}{\param{wxCommandEvent\& }{event}}
+Returns {\tt true} if the given point or rectangle area has been exposed since the
+last repaint. Call this in an paint event handler to optimize redrawing by
+only redrawing those areas, which have been exposed.
-Called when a menu command is received from a menu bar.
+\pythonnote{In place of a single overloaded method name, wxPython
+implements the following methods:\par
+\indented{2cm}{\begin{twocollist}
+\twocolitem{{\bf IsExposed(x,y, w=0,h=0)}}{}
+\twocolitem{{\bf IsExposedPoint(pt)}}{}
+\twocolitem{{\bf IsExposedRect(rect)}}{}
+\end{twocollist}}}
-\wxheading{Parameters}
-\docparam{event}{The menu command event. For more information, see \helpref{wxCommandEvent}{wxcommandevent}.}
+\membersection{wxWindow::IsFrozen}\label{wxwindowisfrozen}
-\wxheading{Remarks}
+\constfunc{virtual bool}{IsFrozen}{\void}
-A function with this name doesn't actually exist; you can choose any member function to receive
-menu command events, using the EVT\_COMMAND macro for individual commands or EVT\_COMMAND\_RANGE for
-a range of commands.
+Returns \true if the window is currently frozen by a call to
+\helpref{Freeze()}{wxwindowfreeze}.
\wxheading{See also}
-\helpref{wxCommandEvent}{wxcommandevent},\rtfsp
-\helpref{wxWindow::OnMenuHighlight}{wxwindowonmenuhighlight},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
-
-\membersection{wxWindow::OnMenuHighlight}\label{wxwindowonmenuhighlight}
+\helpref{Thaw()}{wxwindowthaw}
-\func{void}{OnMenuHighlight}{\param{wxMenuEvent\& }{event}}
-Called when a menu select is received from a menu bar: that is, the
-mouse cursor is over a menu item, but the left mouse button has not been
-pressed.
+\membersection{wxWindow::IsRetained}\label{wxwindowisretained}
-\wxheading{Parameters}
+\constfunc{virtual bool}{IsRetained}{\void}
-\docparam{event}{The menu highlight event. For more information, see \helpref{wxMenuEvent}{wxmenuevent}.}
+Returns {\tt true} if the window is retained, {\tt false} otherwise.
\wxheading{Remarks}
-You can choose any member function to receive
-menu select events, using the EVT\_MENU\_HIGHLIGHT macro for individual menu items or EVT\_MENU\_HIGHLIGHT\_ALL macro
-for all menu items.
-
-The default implementation for \helpref{wxFrame::OnMenuHighlight}{wxframeonmenuhighlight} displays help
-text in the first field of the status bar.
-
-This function was known as {\bf OnMenuSelect} in earlier versions of wxWindows, but this was confusing
-since a selection is normally a left-click action.
-
-\wxheading{See also}
+Retained windows are only available on X platforms.
-\helpref{wxMenuEvent}{wxmenuevent},\rtfsp
-\helpref{wxWindow::OnMenuCommand}{wxwindowonmenucommand},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\membersection{wxWindow::IsShown}\label{wxwindowisshown}
-\membersection{wxWindow::OnMouseEvent}\label{wxwindowonmouseevent}
+\constfunc{virtual bool}{IsShown}{\void}
-\func{void}{OnMouseEvent}{\param{wxMouseEvent\&}{ event}}
+Returns {\tt true} if the window is shown, {\tt false} if it has been hidden.
-Called when the user has initiated an event with the
-mouse.
+\wxheading{See also}
-\wxheading{Parameters}
+\helpref{wxWindow::IsShownOnScreen}{wxwindowisshownonscreen}
-\docparam{event}{The mouse event. See \helpref{wxMouseEvent}{wxmouseevent} for
-more details.}
-\wxheading{Remarks}
+\membersection{wxWindow::IsShownOnScreen}\label{wxwindowisshownonscreen}
-Most, but not all, windows respond to this event.
+\constfunc{virtual bool}{IsShownOnScreen}{\void}
-To intercept this event, use the EVT\_MOUSE\_EVENTS macro in an event table definition, or individual
-mouse event macros such as EVT\_LEFT\_DOWN.
+Returns {\tt true} if the window is physically visible on the screen, i.e. it
+is shown and all its parents up to the toplevel window are shown as well.
\wxheading{See also}
-\helpref{wxMouseEvent}{wxmouseevent},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\helpref{wxWindow::IsShown}{wxwindowisshown}
-\membersection{wxWindow::OnMove}\label{wxwindowonmove}
-\func{void}{OnMove}{\param{wxMoveEvent\& }{event}}
+\membersection{wxWindow::IsThisEnabled}\label{wxwindowisthisenabled}
-Called when a window is moved.
+\constfunc{bool}{IsThisEnabled}{\void}
-\wxheading{Parameters}
+Returns \true if this window is intrinsically enabled, \false otherwise, i.e.
+if \helpref{Enable(false)}{wxwindowenable} had been called. This method is
+mostly used for wxWidgets itself, user code should normally use
+\helpref{IsEnabled}{wxwindowisenabled} instead.
-\docparam{event}{The move event. For more information, see \helpref{wxMoveEvent}{wxmoveevent}.}
-\wxheading{Remarks}
+\membersection{wxWindow::IsTopLevel}\label{wxwindowistoplevel}
-Use the EVT\_MOVE macro to intercept move events.
+\constfunc{bool}{IsTopLevel}{\void}
-\wxheading{Remarks}
+Returns {\tt true} if the given window is a top-level one. Currently all frames and
+dialogs are considered to be top-level windows (even if they have a parent
+window).
-Not currently implemented.
-\wxheading{See also}
+\membersection{wxWindow::Layout}\label{wxwindowlayout}
-\helpref{wxMoveEvent}{wxmoveevent},\rtfsp
-\helpref{wxFrame::OnSize}{wxframeonsize},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\func{void}{Layout}{\void}
-\membersection{wxWindow::OnPaint}\label{wxwindowonpaint}
+Invokes the constraint-based layout algorithm or the sizer-based algorithm
+for this window.
-\func{void}{OnPaint}{\param{wxPaintEvent\& }{event}}
+See \helpref{wxWindow::SetAutoLayout}{wxwindowsetautolayout}: when auto
+layout is on, this function gets called automatically when the window is resized.
-Sent to the event handler when the window must be refreshed.
-\wxheading{Parameters}
+\membersection{wxWindow::LineDown}\label{wxwindowlinedown}
-\docparam{event}{Paint event. For more information, see \helpref{wxPaintEvent}{wxpaintevent}.}
+This is just a wrapper for \helpref{ScrollLines}{wxwindowscrolllines}$(1)$.
-\wxheading{Remarks}
-Use the EVT\_PAINT macro in an event table definition to intercept paint events.
+\membersection{wxWindow::LineUp}\label{wxwindowlineup}
-In a paint event handler, the application should always create a \helpref{wxPaintDC}{wxpaintdc} object.
+This is just a wrapper for \helpref{ScrollLines}{wxwindowscrolllines}$(-1)$.
-For example:
-\small{%
-\begin{verbatim}
- void MyWindow::OnPaint(wxPaintEvent& event)
- {
- wxPaintDC dc(this);
+\membersection{wxWindow::Lower}\label{wxwindowlower}
- DrawMyDocument(dc);
- }
-\end{verbatim}
-}%
+\func{void}{Lower}{\void}
-You can optimize painting by retrieving the rectangles
-that have been damaged and only repainting these. The rectangles are in
-terms of the client area, and are unscrolled, so you will need to do
-some calculations using the current view position to obtain logical,
-scrolled units.
+Lowers the window to the bottom of the window hierarchy (z-order).
-Here is an example of using the \helpref{wxRegionIterator}{wxregioniterator} class:
+\wxheading{See also}
-{\small%
-\begin{verbatim}
-// Called when window needs to be repainted.
-void MyWindow::OnPaint(wxPaintEvent& event)
-{
- wxPaintDC dc(this);
+\helpref{Raise}{wxwindowraise}
- // Find Out where the window is scrolled to
- int vbX,vbY; // Top left corner of client
- ViewStart(&vbX,&vbY);
- int vX,vY,vW,vH; // Dimensions of client area in pixels
- wxRegionIterator upd(GetUpdateRegion()); // get the update rect list
+\membersection{wxWindow::MakeModal}\label{wxwindowmakemodal}
- while (upd)
- {
- vX = upd.GetX();
- vY = upd.GetY();
- vW = upd.GetW();
- vH = upd.GetH();
+\func{virtual void}{MakeModal}{\param{bool }{flag}}
- // Alternatively we can do this:
- // wxRect rect;
- // upd.GetRect(&rect);
+Disables all other windows in the application so that
+the user can only interact with this window.
- // Repaint this rectangle
- ...some code...
+\wxheading{Parameters}
- upd ++ ;
- }
-}
-\end{verbatim}
-}%
+\docparam{flag}{If {\tt true}, this call disables all other windows in the application so that
+the user can only interact with this window. If {\tt false}, the effect is reversed.}
-\wxheading{See also}
-\helpref{wxPaintEvent}{wxpaintevent},\rtfsp
-\helpref{wxPaintDC}{wxpaintdc},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\membersection{wxWindow::Move}\label{wxwindowmove}
-\membersection{wxWindow::OnScroll}\label{wxwindowonscroll}
+\func{void}{Move}{\param{int}{ x}, \param{int}{ y}}
-\func{void}{OnScroll}{\param{wxScrollEvent\& }{event}}
+\func{void}{Move}{\param{const wxPoint\&}{ pt}}
-Called when a scroll event is received from one of the window's built-in scrollbars.
+Moves the window to the given position.
\wxheading{Parameters}
-\docparam{event}{Command event. Retrieve the new scroll position by
-calling \helpref{wxScrollEvent::GetPosition}{wxscrolleventgetposition}, and the
-scrollbar orientation by calling \helpref{wxScrollEvent::GetOrientation}{wxscrolleventgetorientation}.}
+\docparam{x}{Required x position.}
-\wxheading{Remarks}
+\docparam{y}{Required y position.}
-Note that it is not possible to distinguish between horizontal and vertical scrollbars
-until the function is executing (you can't have one function for vertical, another
-for horizontal events).
+\docparam{pt}{\helpref{wxPoint}{wxpoint} object representing the position.}
-\wxheading{See also}
+\wxheading{Remarks}
-\helpref{wxScrollEvent}{wxscrollevent},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+Implementations of SetSize can also implicitly implement the
+wxWindow::Move function, which is defined in the base wxWindow class
+as the call:
-\membersection{wxWindow::OnSetFocus}\label{wxwindowonsetfocus}
+\begin{verbatim}
+ SetSize(x, y, wxDefaultCoord, wxDefaultCoord, wxSIZE_USE_EXISTING);
+\end{verbatim}
-\func{void}{OnSetFocus}{\param{wxFocusEvent\& }{event}}
+\wxheading{See also}
-Called when a window's focus is being set.
+\helpref{wxWindow::SetSize}{wxwindowsetsize}
-\wxheading{Parameters}
+\pythonnote{In place of a single overloaded method name, wxPython
+implements the following methods:\par
+\indented{2cm}{\begin{twocollist}
+\twocolitem{{\bf Move(point)}}{Accepts a wxPoint}
+\twocolitem{{\bf MoveXY(x, y)}}{Accepts a pair of integers}
+\end{twocollist}}
+}
-\docparam{event}{The focus event. For more information, see \helpref{wxFocusEvent}{wxfocusevent}.}
-\wxheading{Remarks}
+\membersection{wxWindow::MoveAfterInTabOrder}\label{wxwindowmoveafterintaborder}
-To intercept this event, use the macro EVT\_SET\_FOCUS in an event table definition.
+\func{void}{MoveAfterInTabOrder}{\param{wxWindow *}{win}}
-Most, but not all, windows respond to this event.
+Moves this window in the tab navigation order after the specified \arg{win}.
+This means that when the user presses \texttt{TAB} key on that other window,
+the focus switches to this window.
-\wxheading{See also}
+Default tab order is the same as creation order, this function and
+\helpref{MoveBeforeInTabOrder()}{wxwindowmovebeforeintaborder} allow to change
+it after creating all the windows.
-\helpref{wxFocusEvent}{wxfocusevent}, \helpref{wxWindow::OnKillFocus}{wxwindowonkillfocus},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\wxheading{Parameters}
-\membersection{wxWindow::OnSize}\label{wxwindowonsize}
+\docparam{win}{A sibling of this window which should precede it in tab order,
+must not be NULL}
-\func{void}{OnSize}{\param{wxSizeEvent\& }{event}}
-Called when the window has been resized.
+\membersection{wxWindow::MoveBeforeInTabOrder}\label{wxwindowmovebeforeintaborder}
-\wxheading{Parameters}
+\func{void}{MoveBeforeInTabOrder}{\param{wxWindow *}{win}}
-\docparam{event}{Size event. For more information, see \helpref{wxSizeEvent}{wxsizeevent}.}
+Same as \helpref{MoveAfterInTabOrder}{wxwindowmoveafterintaborder} except that
+it inserts this window just before \arg{win} instead of putting it right after
+it.
-\wxheading{Remarks}
-You may wish to use this for frames to resize their child windows as appropriate.
+\membersection{wxWindow::Navigate}\label{wxwindownavigate}
-Note that the size passed is of
-the whole window: call \helpref{wxWindow::GetClientSize}{wxwindowgetclientsize} for the area which may be
-used by the application.
+\func{bool}{Navigate}{\param{int}{ flags = wxNavigationKeyEvent::IsForward}}
-\wxheading{See also}
+Performs a keyboard navigation action starting from this window. This method is
+equivalent to calling \helpref{NavigateIn()}{wxwindownavigatein} method on the
+parent window.
-\helpref{wxSizeEvent}{wxsizeevent},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\wxheading{Parameters}
-\membersection{wxWindow::OnSysColourChanged}\label{wxwindowonsyscolourchanged}
+\docparam{flags}{A combination of wxNavigationKeyEvent::IsForward and wxNavigationKeyEvent::WinChange.}
-\func{void}{OnSysColourChanged}{\param{wxOnSysColourChangedEvent\& }{event}}
+\wxheading{Return value}
-Called when the user has changed the system colours.
+Returns \true if the focus was moved to another window or \false if nothing
+changed.
-\wxheading{Parameters}
-
-\docparam{event}{System colour change event. For more information, see \helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent}.}
+\wxheading{Remarks}
-\wxheading{See also}
+You may wish to call this from a text control custom keypress handler to do the default
+navigation behaviour for the tab key, since the standard default behaviour for
+a multiline text control with the wxTE\_PROCESS\_TAB style is to insert a tab
+and not navigate to the next control. See also \helpref{wxNavigationKeyEvent}{wxnavigationkeyevent}.
+
+
+\membersection{wxWindow::NavigateIn}\label{wxwindownavigatein}
+
+\func{bool}{NavigateIn}{\param{int}{ flags = wxNavigationKeyEvent::IsForward}}
+
+Performs a keyboard navigation action inside this window.
+
+See \helpref{Navigate}{wxwindownavigate} for more information.
+
+
+\membersection{wxWindow::NextControlId}\label{wxwindownextcontrolid}
+
+\func{static int}{NextControlId}{\param{int }{winid}}
+
+If two controls are created consecutively using \texttt{wxID\_ANY} id, this
+function allows to retrieve the effective id of the latter control from the id
+of the former. This is useful for example to find the control following its
+\helpref{wxStaticText}{wxstatictext} label if only the id of or pointer to the
+label is available to the caller but it is known that the two controls were
+created together.
+
+\wxheading{See also}
+
+\helpref{PrevControlId}{wxwindowprevcontrolid}
+
+
+%% VZ: wxWindow::OnXXX() functions should not be documented but I'm leaving
+%% the old docs here in case we want to move any still needed bits to
+%% the right location (i.e. probably the corresponding events docs)
+%%
+%% \membersection{wxWindow::OnActivate}\label{wxwindowonactivate}
+%%
+%% \func{void}{OnActivate}{\param{wxActivateEvent\&}{ event}}
+%%
+%% Called when a window is activated or deactivated.
+%%
+%% \wxheading{Parameters}
+%%
+%% \docparam{event}{Object containing activation information.}
+%%
+%% \wxheading{Remarks}
+%%
+%% If the window is being activated, \helpref{wxActivateEvent::GetActive}{wxactivateeventgetactive} returns {\tt true},
+%% otherwise it returns {\tt false} (it is being deactivated).
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{wxActivateEvent}{wxactivateevent},\rtfsp
+%% \helpref{Event handling overview}{eventhandlingoverview}
+%%
+%% \membersection{wxWindow::OnChar}\label{wxwindowonchar}
+%%
+%% \func{void}{OnChar}{\param{wxKeyEvent\&}{ event}}
+%%
+%% Called when the user has pressed a key that is not a modifier (SHIFT, CONTROL or ALT).
+%%
+%% \wxheading{Parameters}
+%%
+%% \docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
+%% details about this class.}
+%%
+%% \wxheading{Remarks}
+%%
+%% This member function is called in response to a keypress. To intercept this event,
+%% use the EVT\_CHAR macro in an event table definition. Your {\bf OnChar} handler may call this
+%% default function to achieve default keypress functionality.
+%%
+%% Note that the ASCII values do not have explicit key codes: they are passed as ASCII
+%% values.
+%%
+%% Note that not all keypresses can be intercepted this way. If you wish to intercept modifier
+%% keypresses, then you will need to use \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown} or
+%% \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup}.
+%%
+%% Most, but not all, windows allow keypresses to be intercepted.
+%%
+%% {\bf Tip:} be sure to call {\tt event.Skip()} for events that you don't process in this function,
+%% otherwise menu shortcuts may cease to work under Windows.
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown}, \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup},\rtfsp
+%% \helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
+%% \helpref{Event handling overview}{eventhandlingoverview}
+%%
+%% \membersection{wxWindow::OnCharHook}\label{wxwindowoncharhook}
+%%
+%% \func{void}{OnCharHook}{\param{wxKeyEvent\&}{ event}}
+%%
+%% This member is called to allow the window to intercept keyboard events
+%% before they are processed by child windows.
+%%
+%% \wxheading{Parameters}
+%%
+%% \docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
+%% details about this class.}
+%%
+%% \wxheading{Remarks}
+%%
+%% This member function is called in response to a keypress, if the window is active. To intercept this event,
+%% use the EVT\_CHAR\_HOOK macro in an event table definition. If you do not process a particular
+%% keypress, call \helpref{wxEvent::Skip}{wxeventskip} to allow default processing.
+%%
+%% An example of using this function is in the implementation of escape-character processing for wxDialog,
+%% where pressing ESC dismisses the dialog by {\bf OnCharHook} 'forging' a cancel button press event.
+%%
+%% Note that the ASCII values do not have explicit key codes: they are passed as ASCII
+%% values.
+%%
+%% This function is only relevant to top-level windows (frames and dialogs), and under
+%% Windows only. Under GTK the normal EVT\_CHAR\_ event has the functionality, i.e.
+%% you can intercept it, and if you don't call \helpref{wxEvent::Skip}{wxeventskip}
+%% the window won't get the event.
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{wxKeyEvent}{wxkeyevent},\rtfsp
+%% \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
+%% %% GD: OnXXX functions are not documented
+%% %%\helpref{wxApp::OnCharHook}{wxapponcharhook},\rtfsp
+%% \helpref{Event handling overview}{eventhandlingoverview}
+%%
+%% \membersection{wxWindow::OnCommand}\label{wxwindowoncommand}
+%%
+%% \func{virtual void}{OnCommand}{\param{wxEvtHandler\& }{object}, \param{wxCommandEvent\& }{event}}
+%%
+%% This virtual member function is called if the control does not handle the command event.
+%%
+%% \wxheading{Parameters}
+%%
+%% \docparam{object}{Object receiving the command event.}
+%%
+%% \docparam{event}{Command event}
+%%
+%% \wxheading{Remarks}
+%%
+%% This virtual function is provided mainly for backward compatibility. You can also intercept commands
+%% from child controls by using an event table, with identifiers or identifier ranges to identify
+%% the control(s) in question.
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{wxCommandEvent}{wxcommandevent},\rtfsp
+%% \helpref{Event handling overview}{eventhandlingoverview}
+%%
+%% \membersection{wxWindow::OnClose}\label{wxwindowonclose}
+%%
+%% \func{virtual bool}{OnClose}{\void}
+%%
+%% Called when the user has tried to close a a frame
+%% or dialog box using the window manager (X) or system menu (Windows).
+%%
+%% {\bf Note:} This is an obsolete function.
+%% It is superseded by the \helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow} event
+%% handler.
+%%
+%% \wxheading{Return value}
+%%
+%% If {\tt true} is returned by OnClose, the window will be deleted by the system, otherwise the
+%% attempt will be ignored. Do not delete the window from within this handler, although
+%% you may delete other windows.
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{Window deletion overview}{windowdeletionoverview},\rtfsp
+%% \helpref{wxWindow::Close}{wxwindowclose},\rtfsp
+%% \helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow},\rtfsp
+%% \helpref{wxCloseEvent}{wxcloseevent}
+%%
+%% \membersection{wxWindow::OnKeyDown}\label{wxwindowonkeydown}
+%%
+%% \func{void}{OnKeyDown}{\param{wxKeyEvent\&}{ event}}
+%%
+%% Called when the user has pressed a key, before it is translated into an ASCII value using other
+%% modifier keys that might be pressed at the same time.
+%%
+%% \wxheading{Parameters}
+%%
+%% \docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
+%% details about this class.}
+%%
+%% \wxheading{Remarks}
+%%
+%% This member function is called in response to a key down event. To intercept this event,
+%% use the EVT\_KEY\_DOWN macro in an event table definition. Your {\bf OnKeyDown} handler may call this
+%% default function to achieve default keypress functionality.
+%%
+%% Note that not all keypresses can be intercepted this way. If you wish to intercept special
+%% keys, such as shift, control, and function keys, then you will need to use \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown} or
+%% \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup}.
+%%
+%% Most, but not all, windows allow keypresses to be intercepted.
+%%
+%% {\bf Tip:} be sure to call {\tt event.Skip()} for events that you don't process in this function,
+%% otherwise menu shortcuts may cease to work under Windows.
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{wxWindow::OnChar}{wxwindowonchar}, \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup},\rtfsp
+%% \helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
+%% \helpref{Event handling overview}{eventhandlingoverview}
+%%
+%% \membersection{wxWindow::OnKeyUp}\label{wxwindowonkeyup}
+%%
+%% \func{void}{OnKeyUp}{\param{wxKeyEvent\&}{ event}}
+%%
+%% Called when the user has released a key.
+%%
+%% \wxheading{Parameters}
+%%
+%% \docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
+%% details about this class.}
+%%
+%% \wxheading{Remarks}
+%%
+%% This member function is called in response to a key up event. To intercept this event,
+%% use the EVT\_KEY\_UP macro in an event table definition. Your {\bf OnKeyUp} handler may call this
+%% default function to achieve default keypress functionality.
+%%
+%% Note that not all keypresses can be intercepted this way. If you wish to intercept special
+%% keys, such as shift, control, and function keys, then you will need to use \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown} or
+%% \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup}.
+%%
+%% Most, but not all, windows allow key up events to be intercepted.
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{wxWindow::OnChar}{wxwindowonchar}, \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown},\rtfsp
+%% \helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
+%% \helpref{Event handling overview}{eventhandlingoverview}
+%%
+%% \membersection{wxWindow::OnInitDialog}\label{wxwindowoninitdialog}
+%%
+%% \func{void}{OnInitDialog}{\param{wxInitDialogEvent\&}{ event}}
+%%
+%% Default handler for the wxEVT\_INIT\_DIALOG event. Calls \helpref{wxWindow::TransferDataToWindow}{wxwindowtransferdatatowindow}.
+%%
+%% \wxheading{Parameters}
+%%
+%% \docparam{event}{Dialog initialisation event.}
+%%
+%% \wxheading{Remarks}
+%%
+%% Gives the window the default behaviour of transferring data to child controls via
+%% the validator that each control has.
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{wxValidator}{wxvalidator}, \helpref{wxWindow::TransferDataToWindow}{wxwindowtransferdatatowindow}
+%%
+%% \membersection{wxWindow::OnMenuHighlight}\label{wxwindowonmenuhighlight}
+%%
+%% \func{void}{OnMenuHighlight}{\param{wxMenuEvent\& }{event}}
+%%
+%% Called when a menu select is received from a menu bar: that is, the
+%% mouse cursor is over a menu item, but the left mouse button has not been
+%% pressed.
+%%
+%% \wxheading{Parameters}
+%%
+%% \docparam{event}{The menu highlight event. For more information, see \helpref{wxMenuEvent}{wxmenuevent}.}
+%%
+%% \wxheading{Remarks}
+%%
+%% You can choose any member function to receive
+%% menu select events, using the EVT\_MENU\_HIGHLIGHT macro for individual menu items or EVT\_MENU\_HIGHLIGHT\_ALL macro
+%% for all menu items.
+%%
+%% The default implementation for \helpref{wxFrame::OnMenuHighlight}{wxframeonmenuhighlight} displays help
+%% text in the first field of the status bar.
+%%
+%% This function was known as {\bf OnMenuSelect} in earlier versions of wxWidgets, but this was confusing
+%% since a selection is normally a left-click action.
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{wxMenuEvent}{wxmenuevent},\rtfsp
+%% \helpref{Event handling overview}{eventhandlingoverview}
+%%
+%%
+%% \membersection{wxWindow::OnMouseEvent}\label{wxwindowonmouseevent}
+%%
+%% \func{void}{OnMouseEvent}{\param{wxMouseEvent\&}{ event}}
+%%
+%% Called when the user has initiated an event with the
+%% mouse.
+%%
+%% \wxheading{Parameters}
+%%
+%% \docparam{event}{The mouse event. See \helpref{wxMouseEvent}{wxmouseevent} for
+%% more details.}
+%%
+%% \wxheading{Remarks}
+%%
+%% Most, but not all, windows respond to this event.
+%%
+%% To intercept this event, use the EVT\_MOUSE\_EVENTS macro in an event table definition, or individual
+%% mouse event macros such as EVT\_LEFT\_DOWN.
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{wxMouseEvent}{wxmouseevent},\rtfsp
+%% \helpref{Event handling overview}{eventhandlingoverview}
+%%
+%% \membersection{wxWindow::OnMove}\label{wxwindowonmove}
+%%
+%% \func{void}{OnMove}{\param{wxMoveEvent\& }{event}}
+%%
+%% Called when a window is moved.
+%%
+%% \wxheading{Parameters}
+%%
+%% \docparam{event}{The move event. For more information, see \helpref{wxMoveEvent}{wxmoveevent}.}
+%%
+%% \wxheading{Remarks}
+%%
+%% Use the EVT\_MOVE macro to intercept move events.
+%%
+%% \wxheading{Remarks}
+%%
+%% Not currently implemented.
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{wxMoveEvent}{wxmoveevent},\rtfsp
+%% \helpref{wxFrame::OnSize}{wxframeonsize},\rtfsp
+%% \helpref{Event handling overview}{eventhandlingoverview}
+%%
+%% \membersection{wxWindow::OnPaint}\label{wxwindowonpaint}
+%%
+%% \func{void}{OnPaint}{\param{wxPaintEvent\& }{event}}
+%%
+%% Sent to the event handler when the window must be refreshed.
+%%
+%% \wxheading{Parameters}
+%%
+%% \docparam{event}{Paint event. For more information, see \helpref{wxPaintEvent}{wxpaintevent}.}
+%%
+%% \wxheading{Remarks}
+%%
+%% Use the EVT\_PAINT macro in an event table definition to intercept paint events.
+%%
+%% Note that In a paint event handler, the application must {\it always} create a \helpref{wxPaintDC}{wxpaintdc} object,
+%% even if you do not use it. Otherwise, under MS Windows, refreshing for this and other windows will go wrong.
+%%
+%% For example:
+%%
+%% \small{%
+%% \begin{verbatim}
+%% void MyWindow::OnPaint(wxPaintEvent\& event)
+%% {
+%% wxPaintDC dc(this);
+%%
+%% DrawMyDocument(dc);
+%% }
+%% \end{verbatim}
+%% }%
+%%
+%% You can optimize painting by retrieving the rectangles
+%% that have been damaged and only repainting these. The rectangles are in
+%% terms of the client area, and are unscrolled, so you will need to do
+%% some calculations using the current view position to obtain logical,
+%% scrolled units.
+%%
+%% Here is an example of using the \helpref{wxRegionIterator}{wxregioniterator} class:
+%%
+%% {\small%
+%% \begin{verbatim}
+%% // Called when window needs to be repainted.
+%% void MyWindow::OnPaint(wxPaintEvent\& event)
+%% {
+%% wxPaintDC dc(this);
+%%
+%% // Find Out where the window is scrolled to
+%% int vbX,vbY; // Top left corner of client
+%% GetViewStart(&vbX,&vbY);
+%%
+%% int vX,vY,vW,vH; // Dimensions of client area in pixels
+%% wxRegionIterator upd(GetUpdateRegion()); // get the update rect list
+%%
+%% while (upd)
+%% {
+%% vX = upd.GetX();
+%% vY = upd.GetY();
+%% vW = upd.GetW();
+%% vH = upd.GetH();
+%%
+%% // Alternatively we can do this:
+%% // wxRect rect;
+%% // upd.GetRect(&rect);
+%%
+%% // Repaint this rectangle
+%% ...some code...
+%%
+%% upd ++ ;
+%% }
+%% }
+%% \end{verbatim}
+%% }%
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{wxPaintEvent}{wxpaintevent},\rtfsp
+%% \helpref{wxPaintDC}{wxpaintdc},\rtfsp
+%% \helpref{Event handling overview}{eventhandlingoverview}
+%%
+%% \membersection{wxWindow::OnScroll}\label{wxwindowonscroll}
+%%
+%% \func{void}{OnScroll}{\param{wxScrollWinEvent\& }{event}}
+%%
+%% Called when a scroll window event is received from one of the window's built-in scrollbars.
+%%
+%% \wxheading{Parameters}
+%%
+%% \docparam{event}{Command event. Retrieve the new scroll position by
+%% calling \helpref{wxScrollEvent::GetPosition}{wxscrolleventgetposition}, and the
+%% scrollbar orientation by calling \helpref{wxScrollEvent::GetOrientation}{wxscrolleventgetorientation}.}
+%%
+%% \wxheading{Remarks}
+%%
+%% Note that it is not possible to distinguish between horizontal and vertical scrollbars
+%% until the function is executing (you can't have one function for vertical, another
+%% for horizontal events).
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{wxScrollWinEvent}{wxscrollwinevent},\rtfsp
+%% \helpref{Event handling overview}{eventhandlingoverview}
+%%
+%% \membersection{wxWindow::OnSetFocus}\label{wxwindowonsetfocus}
+%%
+%% \func{void}{OnSetFocus}{\param{wxFocusEvent\& }{event}}
+%%
+%% Called when a window's focus is being set.
+%%
+%% \wxheading{Parameters}
+%%
+%% \docparam{event}{The focus event. For more information, see \helpref{wxFocusEvent}{wxfocusevent}.}
+%%
+%% \wxheading{Remarks}
+%%
+%% To intercept this event, use the macro EVT\_SET\_FOCUS in an event table definition.
+%%
+%% Most, but not all, windows respond to this event.
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{wxFocusEvent}{wxfocusevent}, \helpref{wxWindow::OnKillFocus}{wxwindowonkillfocus},\rtfsp
+%% \helpref{Event handling overview}{eventhandlingoverview}
+%%
+%% \membersection{wxWindow::OnSize}\label{wxwindowonsize}
+%%
+%% \func{void}{OnSize}{\param{wxSizeEvent\& }{event}}
+%%
+%% Called when the window has been resized. This is not a virtual function; you should
+%% provide your own non-virtual OnSize function and direct size events to it using EVT\_SIZE
+%% in an event table definition.
+%%
+%% \wxheading{Parameters}
+%%
+%% \docparam{event}{Size event. For more information, see \helpref{wxSizeEvent}{wxsizeevent}.}
+%%
+%% \wxheading{Remarks}
+%%
+%% You may wish to use this for frames to resize their child windows as appropriate.
+%%
+%% Note that the size passed is of
+%% the whole window: call \helpref{wxWindow::GetClientSize}{wxwindowgetclientsize} for the area which may be
+%% used by the application.
+%%
+%% When a window is resized, usually only a small part of the window is damaged and you
+%% may only need to repaint that area. However, if your drawing depends on the size of the window,
+%% you may need to clear the DC explicitly and repaint the whole window. In which case, you
+%% may need to call \helpref{wxWindow::Refresh}{wxwindowrefresh} to invalidate the entire window.
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{wxSizeEvent}{wxsizeevent},\rtfsp
+%% \helpref{Event handling overview}{eventhandlingoverview}
+%%
+%% \membersection{wxWindow::OnSysColourChanged}\label{wxwindowonsyscolourchanged}
+%%
+%% \func{void}{OnSysColourChanged}{\param{wxOnSysColourChangedEvent\& }{event}}
+%%
+%% Called when the user has changed the system colours. Windows only.
+%%
+%% \wxheading{Parameters}
+%%
+%% \docparam{event}{System colour change event. For more information, see \helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent}.}
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent},\rtfsp
+%% \helpref{Event handling overview}{eventhandlingoverview}
+
+
+\membersection{wxWindow::OnInternalIdle}\label{wxwindowoninternalidle}
+
+\func{virtual void}{OnInternalIdle}{\void}
+
+This virtual function is normally only used internally, but
+sometimes an application may need it to implement functionality
+that should not be disabled by an application defining an OnIdle
+handler in a derived class.
+
+This function may be used to do delayed painting, for example,
+and most implementations call \helpref{wxWindow::UpdateWindowUI}{wxwindowupdatewindowui}
+in order to send update events to the window in idle time.
+
+
+\membersection{wxWindow::PageDown}\label{wxwindowpagedown}
+
+This is just a wrapper for \helpref{ScrollPages()}{wxwindowscrollpages}$(1)$.
+
+
+\membersection{wxWindow::PageUp}\label{wxwindowpageup}
+
+This is just a wrapper for \helpref{ScrollPages()}{wxwindowscrollpages}$(-1)$.
-\helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
\membersection{wxWindow::PopEventHandler}\label{wxwindowpopeventhandler}
-\constfunc{wxEvtHandler*}{PopEventHandler}{\param{bool }{deleteHandler = FALSE}}
+\constfunc{wxEvtHandler*}{PopEventHandler}{\param{bool }{deleteHandler = {\tt false}}}
Removes and returns the top-most event handler on the event handler stack.
\wxheading{Parameters}
-\docparam{deleteHandler}{If this is TRUE, the handler will be deleted after it is removed. The
-default value is FALSE.}
+\docparam{deleteHandler}{If this is {\tt true}, the handler will be deleted after it is removed. The
+default value is {\tt false}.}
\wxheading{See also}
\helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
\helpref{wxEvtHandler}{wxevthandler}\rtfsp
+
\membersection{wxWindow::PopupMenu}\label{wxwindowpopupmenu}
-\func{virtual bool}{PopupMenu}{\param{wxMenu* }{menu}, \param{int }{x}, \param{int }{y}}
+\func{bool}{PopupMenu}{\param{wxMenu* }{menu}, \param{const wxPoint\& }{pos = wxDefaultPosition}}
+
+\func{bool}{PopupMenu}{\param{wxMenu* }{menu}, \param{int }{x}, \param{int }{y}}
Pops up the given menu at the specified coordinates, relative to this
window, and returns control when the user has dismissed the menu. If a
-menu item is selected, the callback defined for the menu is called with
-wxMenu and wxCommandEvent reference arguments. The callback should access
-the commandInt member of the event to check the selected menu identifier.
+menu item is selected, the corresponding menu event is generated and will be
+processed as usually. If the coordinates are not specified, current mouse
+cursor position is used.
\wxheading{Parameters}
\docparam{menu}{Menu to pop up.}
+\docparam{pos}{The position where the menu will appear.}
+
\docparam{x}{Required x position for the menu to appear.}
\docparam{y}{Required y position for the menu to appear.}
\wxheading{Remarks}
-Just before the menu is popped up, \helpref{wxMenu::UpdateUI}{wxmenuupdateui} is called
-to ensure that the menu items are in the correct state.
+Just before the menu is popped up, \helpref{wxMenu::UpdateUI}{wxmenuupdateui}
+is called to ensure that the menu items are in the correct state. The menu does
+not get deleted by the window.
+
+It is recommended to not explicitly specify coordinates when calling PopupMenu
+in response to mouse click, because some of the ports (namely, wxGTK) can do
+a better job of positioning the menu in that case.
+
+\pythonnote{In place of a single overloaded method name, wxPython
+implements the following methods:\par
+\indented{2cm}{\begin{twocollist}
+\twocolitem{{\bf PopupMenu(menu, point)}}{Specifies position with a wxPoint}
+\twocolitem{{\bf PopupMenuXY(menu, x, y)}}{Specifies position with two integers (x, y)}
+\end{twocollist}}
+}
+
+
+\membersection{wxWindow::PrevControlId}\label{wxwindowprevcontrolid}
+
+\func{static int}{PrevControlId}{\param{int }{winid}}
+
+This is similar to \helpref{NextControlId}{wxwindownextcontrolid} but returns
+the id of the control created just before the one with the given \arg{winid}.
+
\membersection{wxWindow::PushEventHandler}\label{wxwindowpusheventhandler}
\helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
\helpref{wxEvtHandler}{wxevthandler}
+
\membersection{wxWindow::Raise}\label{wxwindowraise}
\func{void}{Raise}{\void}
-Raises the window to the top of the window hierarchy if it is a managed window (dialog
-or frame).
+Raises the window to the top of the window hierarchy (z-order).
+
+In current version of wxWidgets this works both for managed and child windows.
+
+\wxheading{See also}
+
+\helpref{Lower}{wxwindowlower}
+
\membersection{wxWindow::Refresh}\label{wxwindowrefresh}
-\func{virtual void}{Refresh}{\param{const bool}{ eraseBackground = TRUE}, \param{const wxRect* }{rect
-= NULL}}
+\func{virtual void}{Refresh}{\param{bool}{ eraseBackground = {\tt true}}, \param{const wxRect* }{rect = NULL}}
-Causes a message or event to be generated to repaint the
-window.
+Causes this window, and all of its children recursively (except under wxGTK1
+where this is not implemented), to be repainted. Note that repainting doesn't
+happen immediately but only during the next event loop iteration, if you need
+to update the window immediately you should use \helpref{Update}{wxwindowupdate}
+instead.
\wxheading{Parameters}
-\docparam{eraseBackground}{If TRUE, the background will be
+\docparam{eraseBackground}{If {\tt true}, the background will be
erased.}
\docparam{rect}{If non-NULL, only the given rectangle will
be treated as damaged.}
+\wxheading{See also}
+
+\helpref{wxWindow::RefreshRect}{wxwindowrefreshrect}
+
+
+\membersection{wxWindow::RefreshRect}\label{wxwindowrefreshrect}
+
+\func{void}{RefreshRect}{\param{const wxRect\& }{rect}, \param{bool }{eraseBackground = \true}}
+
+Redraws the contents of the given rectangle: only the area inside it will be
+repainted.
+
+This is the same as \helpref{Refresh}{wxwindowrefresh} but has a nicer syntax
+as it can be called with a temporary wxRect object as argument like this
+\texttt{RefreshRect(wxRect(x, y, w, h))}.
+
+
+\membersection{wxWindow::RegisterHotKey}\label{wxwindowregisterhotkey}
+
+\func{bool}{RegisterHotKey}{\param{int}{ hotkeyId}, \param{int}{ modifiers}, \param{int}{ virtualKeyCode}}
+
+Registers a system wide hotkey. Every time the user presses the hotkey registered here, this window
+will receive a hotkey event. It will receive the event even if the application is in the background
+and does not have the input focus because the user is working with some other application.
+
+\wxheading{Parameters}
+
+\docparam{hotkeyId}{Numeric identifier of the hotkey. For applications this must be between 0 and 0xBFFF. If
+this function is called from a shared DLL, it must be a system wide unique identifier between 0xC000 and 0xFFFF.
+This is a MSW specific detail.}
+
+\docparam{modifiers}{A bitwise combination of {\tt wxMOD\_SHIFT}, {\tt wxMOD\_CONTROL}, {\tt wxMOD\_ALT}
+or {\tt wxMOD\_WIN} specifying the modifier keys that have to be pressed along with the key.}
+
+\docparam{virtualKeyCode}{The virtual key code of the hotkey.}
+
+\wxheading{Return value}
+
+{\tt true} if the hotkey was registered successfully. {\tt false} if some other application already registered a
+hotkey with this modifier/virtualKeyCode combination.
+
+\wxheading{Remarks}
+
+Use EVT\_HOTKEY(hotkeyId, fnc) in the event table to capture the event.
+This function is currently only implemented under Windows. It is used
+in the \helpref{Windows CE port}{wxwince} for detecting hardware button presses.
+
+\wxheading{See also}
+
+\helpref{wxWindow::UnregisterHotKey}{wxwindowunregisterhotkey}
+
+
\membersection{wxWindow::ReleaseMouse}\label{wxwindowreleasemouse}
\func{virtual void}{ReleaseMouse}{\void}
\wxheading{See also}
-\helpref{wxWindow::CaptureMouse}{wxwindowcapturemouse}
+\helpref{wxWindow::CaptureMouse}{wxwindowcapturemouse},
+\helpref{wxWindow::HasCapture}{wxwindowhascapture},
+\helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse},
+\helpref{wxMouseCaptureLostEvent}{wxmousecapturelostevent}
+\helpref{wxMouseCaptureChangedEvent}{wxmousecapturechangedevent}
+
\membersection{wxWindow::RemoveChild}\label{wxwindowremovechild}
Removes a child window. This is called automatically by window deletion
functions so should not be required by the application programmer.
+Notice that this function is mostly internal to wxWidgets and shouldn't be
+called by the user code.
+
\wxheading{Parameters}
\docparam{child}{Child window to remove.}
+
+\membersection{wxWindow::RemoveEventHandler}\label{wxwindowremoveeventhandler}
+
+\func{bool}{RemoveEventHandler}{\param{wxEvtHandler *}{handler}}
+
+Find the given {\it handler} in the windows event handler chain and remove (but
+not delete) it from it.
+
+\wxheading{Parameters}
+
+\docparam{handler}{The event handler to remove, must be non-{\tt NULL} and
+must be present in this windows event handlers chain}
+
+\wxheading{Return value}
+
+Returns {\tt true} if it was found and {\tt false} otherwise (this also results
+in an assert failure so this function should only be called when the
+handler is supposed to be there).
+
+\wxheading{See also}
+
+\helpref{PushEventHandler}{wxwindowpusheventhandler},\rtfsp
+\helpref{PopEventHandler}{wxwindowpopeventhandler}
+
+
+\membersection{wxWindow::Reparent}\label{wxwindowreparent}
+
+\func{virtual bool}{Reparent}{\param{wxWindow* }{newParent}}
+
+Reparents the window, i.e the window will be removed from its
+current parent window (e.g. a non-standard toolbar in a wxFrame)
+and then re-inserted into another.
+
+\wxheading{Parameters}
+
+\docparam{newParent}{New parent.}
+
+
\membersection{wxWindow::ScreenToClient}\label{wxwindowscreentoclient}
\constfunc{virtual void}{ScreenToClient}{\param{int* }{x}, \param{int* }{y}}
\pythonnote{In place of a single overloaded method name, wxPython
implements the following methods:\par
\indented{2cm}{\begin{twocollist}
-\twocolitem{\bf{ScreenToClient(point)}}{Accepts and returns a wxPoint}
-\twocolitem{\bf{ScreenToClientXY(x, y)}}{Returns a 2-tuple, (x, y)}
+\twocolitem{{\bf ScreenToClient(point)}}{Accepts and returns a wxPoint}
+\twocolitem{{\bf ScreenToClientXY(x, y)}}{Returns a 2-tuple, (x, y)}
\end{twocollist}}
}
+\membersection{wxWindow::ScrollLines}\label{wxwindowscrolllines}
+
+\func{virtual bool}{ScrollLines}{\param{int }{lines}}
+
+Scrolls the window by the given number of lines down (if {\it lines} is
+positive) or up.
+
+\wxheading{Return value}
+
+Returns {\tt true} if the window was scrolled, {\tt false} if it was already
+on top/bottom and nothing was done.
+
+\wxheading{Remarks}
+
+This function is currently only implemented under MSW and wxTextCtrl under
+wxGTK (it also works for wxScrolledWindow derived classes under all
+platforms).
+
+\wxheading{See also}
+
+\helpref{ScrollPages}{wxwindowscrollpages}
+
+
+\membersection{wxWindow::ScrollPages}\label{wxwindowscrollpages}
+
+\func{virtual bool}{ScrollPages}{\param{int }{pages}}
+
+Scrolls the window by the given number of pages down (if {\it pages} is
+positive) or up.
+
+\wxheading{Return value}
+
+Returns {\tt true} if the window was scrolled, {\tt false} if it was already
+on top/bottom and nothing was done.
+
+\wxheading{Remarks}
+
+This function is currently only implemented under MSW and wxGTK.
+
+\wxheading{See also}
+
+\helpref{ScrollLines}{wxwindowscrolllines}
+
+
\membersection{wxWindow::ScrollWindow}\label{wxwindowscrollwindow}
\func{virtual void}{ScrollWindow}{\param{int }{dx}, \param{int }{dy}, \param{const wxRect*}{ rect = NULL}}
-Physically scrolls the pixels in the window.
+Physically scrolls the pixels in the window and move child windows accordingly.
\wxheading{Parameters}
\docparam{dy}{Amount to scroll vertically.}
-\docparam{rect}{Rectangle to invalidate. If this is NULL, the whole window is invalidated. If you
-pass a rectangle corresponding to the area of the window exposed by the scroll, your painting handler
-can optimise painting by checking for the invalidated region.}
+\docparam{rect}{Rectangle to scroll, if it is \NULL, the whole window is
+scrolled (this is always the case under wxGTK which doesn't support this
+parameter)}
\wxheading{Remarks}
-Available only under Windows.
+Note that you can often use \helpref{wxScrolledWindow}{wxscrolledwindow}
+instead of using this function directly.
-Use this function to optimise your scrolling implementations, to minimise the area that must be
-redrawn.
\membersection{wxWindow::SetAcceleratorTable}\label{wxwindowsetacceleratortable}
Sets the accelerator table for this window. See \helpref{wxAcceleratorTable}{wxacceleratortable}.
+
+\membersection{wxWindow::SetAccessible}\label{wxwindowsetaccessible}
+
+\func{void}{SetAccessible}{\param{wxAccessible*}{ accessible}}
+
+Sets the accessible for this window. Any existing accessible for this window
+will be deleted first, if not identical to {\it accessible}.
+
+See also \helpref{wxAccessible}{wxaccessible}.
+
+
\membersection{wxWindow::SetAutoLayout}\label{wxwindowsetautolayout}
-\func{void}{SetAutoLayout}{\param{const bool}{ autoLayout}}
+\func{void}{SetAutoLayout}{\param{bool}{ autoLayout}}
Determines whether the \helpref{wxWindow::Layout}{wxwindowlayout} function will
-be called automatically when the window is resized.
+be called automatically when the window is resized. Please note that this only
+happens for the windows usually used to contain children, namely
+\helpref{wxPanel}{wxpanel} and \helpref{wxTopLevelWindow}{wxtoplevelwindow}
+(and the classes deriving from them).
+
+This method is called implicitly by
+\helpref{wxWindow::SetSizer}{wxwindowsetsizer} but if you use
+\helpref{wxWindow::SetConstraints}{wxwindowsetconstraints} you should call it
+manually or otherwise the window layout won't be correctly updated when its
+size changes.
\wxheading{Parameters}
-\docparam{autoLayout}{Set this to TRUE if you wish the Layout function to be called
-from within wxWindow::OnSize functions.}
+\docparam{autoLayout}{Set this to \true if you wish the Layout function to be
+called automatically when the window is resized.}
\wxheading{See also}
\helpref{wxWindow::SetConstraints}{wxwindowsetconstraints}
+
\membersection{wxWindow::SetBackgroundColour}\label{wxwindowsetbackgroundcolour}
-\func{virtual void}{SetBackgroundColour}{\param{const wxColour\& }{colour}}
+\func{virtual bool}{SetBackgroundColour}{\param{const wxColour\& }{colour}}
Sets the background colour of the window.
+Please see \helpref{InheritAttributes}{wxwindowinheritattributes} for
+explanation of the difference between this method and
+\helpref{SetOwnBackgroundColour}{wxwindowsetownbackgroundcolour}.
+
\wxheading{Parameters}
-\docparam{colour}{The colour to be used as the background colour.}
+\docparam{colour}{The colour to be used as the background colour, pass
+ {\tt wxNullColour} to reset to the default colour.}
\wxheading{Remarks}
The background colour is usually painted by the default\rtfsp
-\helpref{wxWindow::OnEraseBackground}{wxwindowonerasebackground} event handler function.
+\helpref{wxEraseEvent}{wxeraseevent} event handler function
+under Windows and automatically under GTK.
Note that setting the background colour does not cause an immediate refresh, so you
-may wish to call \helpref{wxWindow::Clear}{wxwindowclear} or \helpref{wxWindow::Refresh}{wxwindowrefresh} after
+may wish to call \helpref{wxWindow::ClearBackground}{wxwindowclearbackground} or \helpref{wxWindow::Refresh}{wxwindowrefresh} after
calling this function.
+Using this function will disable attempts to use themes for this
+window, if the system supports them. Use with care since usually the
+themes represent the appearance chosen by the user to be used for all
+applications on the system.
+
+
\wxheading{See also}
\helpref{wxWindow::GetBackgroundColour}{wxwindowgetbackgroundcolour},\rtfsp
\helpref{wxWindow::SetForegroundColour}{wxwindowsetforegroundcolour},\rtfsp
\helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour},\rtfsp
-\helpref{wxWindow::Clear}{wxwindowclear},\rtfsp
+\helpref{wxWindow::ClearBackground}{wxwindowclearbackground},\rtfsp
\helpref{wxWindow::Refresh}{wxwindowrefresh},\rtfsp
-\helpref{wxWindow::OnEraseBackground}{wxwindowonerasebackground}
+\helpref{wxEraseEvent}{wxeraseevent}
+
+\membersection{wxWindow::SetBackgroundStyle}\label{wxwindowsetbackgroundstyle}
+
+\func{virtual void}{SetBackgroundStyle}{\param{wxBackgroundStyle}{ style}}
+
+Sets the background style of the window. The background style indicates
+whether background colour should be determined by the system (wxBG\_STYLE\_SYSTEM),
+be set to a specific colour (wxBG\_STYLE\_COLOUR), or should be left to the
+application to implement (wxBG\_STYLE\_CUSTOM).
+
+On GTK+, use of wxBG\_STYLE\_CUSTOM allows the flicker-free drawing of a custom
+background, such as a tiled bitmap. Currently the style has no effect on other platforms.
+
+\wxheading{See also}
+
+\helpref{wxWindow::SetBackgroundColour}{wxwindowsetbackgroundcolour},\rtfsp
+\helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour},\rtfsp
+\helpref{wxWindow::GetBackgroundStyle}{wxwindowgetbackgroundstyle}
+
+
+
+\membersection{wxWindow::SetCanFocus}\label{wxwindowsetcanfocus}
+
+\func{virtual void}{SetCanFocus}{\param{bool}{ canFocus}}
+
+This method is only implemented by ports which have support for
+native TAB traversal (such as GTK+ 2.0). It is called by wxWidgets'
+container control code to give the native system a hint when
+doing TAB traversal. A call to this does not disable or change
+the effect of programmatically calling
+\helpref{wxWindow::SetFocus}{wxwindowsetfocus}.
+
+\wxheading{See also}
+
+\helpref{wxFocusEvent}{wxfocusevent}
+\helpref{wxPanel::SetFocus}{wxpanelsetfocus}
+\helpref{wxPanel::SetFocusIgnoringChildren}{wxpanelsetfocusignoringchildren}
+
+
+\membersection{wxWindow::SetCaret}\label{wxwindowsetcaret}
+
+\constfunc{void}{SetCaret}{\param{wxCaret *}{caret}}
+
+Sets the \helpref{caret}{wxcaret} associated with the window.
+
\membersection{wxWindow::SetClientSize}\label{wxwindowsetclientsize}
\pythonnote{In place of a single overloaded method name, wxPython
implements the following methods:\par
\indented{2cm}{\begin{twocollist}
-\twocolitem{\bf{SetClientSize(size)}}{Accepts a wxSize}
-\twocolitem{\bf{SetClientSizeWH(width, height)}}{}
+\twocolitem{{\bf SetClientSize(size)}}{Accepts a wxSize}
+\twocolitem{{\bf SetClientSizeWH(width, height)}}{}
\end{twocollist}}
}
-\membersection{wxWindow::SetCursor}\label{wxwindowsetcursor}
-\func{virtual void}{SetCursor}{\param{const wxCursor\&}{cursor}}
+\membersection{wxWindow::SetConstraints}\label{wxwindowsetconstraints}
+
+\func{void}{SetConstraints}{\param{wxLayoutConstraints* }{constraints}}
+
+Sets the window to have the given layout constraints. The window
+will then own the object, and will take care of its deletion.
+If an existing layout constraints object is already owned by the
+window, it will be deleted.
+
+\wxheading{Parameters}
+
+\docparam{constraints}{The constraints to set. Pass NULL to disassociate and delete the window's
+constraints.}
+
+\wxheading{Remarks}
+
+You must call \helpref{wxWindow::SetAutoLayout}{wxwindowsetautolayout} to tell a window to use
+the constraints automatically in OnSize; otherwise, you must override OnSize and call Layout()
+explicitly. When setting both a wxLayoutConstraints and a \helpref{wxSizer}{wxsizer}, only the
+sizer will have effect.
+
+\membersection{wxWindow::SetContainingSizer}\label{wxwindowsetcontainingsizer}
+
+\func{void}{SetContainingSizer}{\param{wxSizer* }{sizer}}
+
+This normally does not need to be called by user code. It is called
+when a window is added to a sizer, and is used so the window can
+remove itself from the sizer when it is destroyed.
+
+
+\membersection{wxWindow::SetCursor}\label{wxwindowsetcursor}
+
+\func{virtual void}{SetCursor}{\param{const wxCursor\&}{cursor}}
+
+% VZ: the docs are correct, if the code doesn't behave like this, it must be
+% changed
+Sets the window's cursor. Notice that the window cursor also sets it for the
+children of the window implicitly.
+
+The {\it cursor} may be {\tt wxNullCursor} in which case the window cursor will
+be reset back to default.
+
+\wxheading{Parameters}
+
+\docparam{cursor}{Specifies the cursor that the window should normally display.}
+
+\wxheading{See also}
+
+\helpref{::wxSetCursor}{wxsetcursor}, \helpref{wxCursor}{wxcursor}
+
+
+\membersection{wxWindow::SetDropTarget}\label{wxwindowsetdroptarget}
-Sets the window's cursor.
+\func{void}{SetDropTarget}{\param{wxDropTarget*}{ target}}
-\wxheading{Parameters}
+Associates a drop target with this window.
-\docparam{cursor}{Specifies the cursor that the window should normally display.}
+If the window already has a drop target, it is deleted.
-%\wxheading{Remarks}
-%
-%Under Windows, you sometimes need to call ::wxSetCursor in addition to this
-%function if you want the cursor to change immediately, because under Windows,
-%wxWindows only sets the global cursor when it detects mouse movement.
-%
\wxheading{See also}
-\helpref{::wxSetCursor}{wxsetcursor}, \helpref{wxCursor}{wxcursor}
+\helpref{wxWindow::GetDropTarget}{wxwindowgetdroptarget},
+\helpref{Drag and drop overview}{wxdndoverview}
+
+
\membersection{wxWindow::SetEventHandler}\label{wxwindowseteventhandler}
central implementation of event-handling for a variety of different
window classes.
-It is usually better to use \helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler} since
-this sets up a chain of event handlers, where an event not handled by one event handler is
-handed to the next one in the chain.
+It is usually better to use \helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler}
+since this sets up a chain of event handlers, where an event not handled by
+one event handler is handed to the next one in the chain.
\wxheading{See also}
\helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
\helpref{wxEvtHandler}{wxevthandler}
-\membersection{wxWindow::SetConstraints}\label{wxwindowsetconstraints}
-\func{void}{SetConstraints}{\param{wxLayoutConstraints* }{constraints}}
+\membersection{wxWindow::SetExtraStyle}\label{wxwindowsetextrastyle}
-Sets the window to have the given layout constraints. The window
-will then own the object, and will take care of its deletion.
-If an existing layout constraints object is already owned by the
-window, it will be deleted.
+\func{void}{SetExtraStyle}{\param{long }{exStyle}}
-\wxheading{Parameters}
+Sets the extra style bits for the window. The currently defined extra style
+bits are:
-\docparam{constraints}{The constraints to set. Pass NULL to disassociate and delete the window's
-constraints.}
+\twocolwidtha{5cm}%
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\windowstyle{wxWS\_EX\_VALIDATE\_RECURSIVELY}}{TransferDataTo/FromWindow()
+and Validate() methods will recursively descend into all children of the
+window if it has this style flag set.}
+\twocolitem{\windowstyle{wxWS\_EX\_BLOCK\_EVENTS}}{Normally, the command
+events are propagated upwards to the window parent recursively until a handler
+for them is found. Using this style allows to prevent them from being
+propagated beyond this window. Notice that wxDialog has this style on by
+default for the reasons explained in the
+\helpref{event processing overview}{eventprocessing}.}
+\twocolitem{\windowstyle{wxWS\_EX\_TRANSIENT}}{This can be used to prevent a
+window from being used as an implicit parent for the dialogs which were
+created without a parent. It is useful for the windows which can disappear at
+any moment as creating children of such windows results in fatal problems.}
+\twocolitem{\windowstyle{wxWS\_EX\_CONTEXTHELP}}{Under Windows, puts a query
+button on the caption. When pressed, Windows will go into a context-sensitive
+help mode and wxWidgets will send a wxEVT\_HELP event if the user clicked on an
+application window.
+This style cannot be used together with wxMAXIMIZE\_BOX or wxMINIMIZE\_BOX, so
+these two styles are automatically turned of if this one is used.}
+\twocolitem{\windowstyle{wxWS\_EX\_PROCESS\_IDLE}}{This window should always process idle events, even
+if the mode set by \helpref{wxIdleEvent::SetMode}{wxidleeventsetmode} is wxIDLE\_PROCESS\_SPECIFIED.}
+\twocolitem{\windowstyle{wxWS\_EX\_PROCESS\_UI\_UPDATES}}{This window should always process UI update events,
+even if the mode set by \helpref{wxUpdateUIEvent::SetMode}{wxupdateuieventsetmode} is wxUPDATE\_UI\_PROCESS\_SPECIFIED.}
+\end{twocollist}
-\wxheading{Remarks}
-You must call \helpref{wxWindow::SetAutoLayout}{wxwindowsetautolayout} to tell a window to use
-the constraints automatically in OnSize; otherwise, you must
-override OnSize and call Layout explicitly.
+\membersection{wxWindow::SetFocus}\label{wxwindowsetfocus}
-\membersection{wxWindow::SetDropTarget}\label{wxwindowsetdroptarget}
+\func{virtual void}{SetFocus}{\void}
-\func{void}{SetDropTarget}{\param{wxDropTarget*}{ target}}
+This sets the window to receive keyboard input.
-Associates a drop target with this window.
+\wxheading{See also}
-If the window already has a drop target, it is deleted.
+\helpref{wxFocusEvent}{wxfocusevent}
+\helpref{wxPanel::SetFocus}{wxpanelsetfocus}
+\helpref{wxPanel::SetFocusIgnoringChildren}{wxpanelsetfocusignoringchildren}
-\wxheading{See also}
-\helpref{wxWindow::GetDropTarget}{wxwindowgetdroptarget},
-\helpref{Drag and drop overview}{wxdndoverview}
+\membersection{wxWindow::SetFocusFromKbd}\label{wxwindowsetfocusfromkbd}
-\membersection{wxWindow::SetFocus}\label{wxwindowsetfocus}
+\func{virtual void}{SetFocusFromKbd}{\void}
-\func{virtual void}{SetFocus}{\void}
+This function is called by wxWidgets keyboard navigation code when the user
+gives the focus to this window from keyboard (e.g. using {\tt TAB} key).
+By default this method simply calls \helpref{SetFocus}{wxwindowsetfocus} but
+can be overridden to do something in addition to this in the derived classes.
-This sets the window to receive keyboard input.
\membersection{wxWindow::SetFont}\label{wxwindowsetfont}
-\func{void}{SetFont}{\param{const wxFont\& }{font}}
+\func{bool}{SetFont}{\param{const wxFont\& }{font}}
-Sets the font for this window.
+Sets the font for this window. This function should not be called for the
+parent window if you don't want its font to be inherited by its children,
+use \helpref{SetOwnFont}{wxwindowsetownfont} instead in this case and
+see \helpref{InheritAttributes}{wxwindowinheritattributes} for more
+explanations.
+
+Please notice that the given font is \emph{not} automatically used for
+\helpref{wxPaintDC}{wxpaintdc} objects associated with this window, you need to
+call \helpref{wxDC::SetFont()}{wxdcsetfont} too. However this font is used by
+any standard controls for drawing their text as well as by
+\helpref{wxWindow::GetTextExtent()}{wxwindowgettextextent}.
\wxheading{Parameters}
-\docparam{font}{Font to associate with this window.}
+\docparam{font}{Font to associate with this window, pass
+{\tt wxNullFont} to reset to the default font.}
+
+\wxheading{Return value}
+
+\true if the want was really changed, \false if it was already set to this
+\arg{font} and so nothing was done.
\wxheading{See also}
-\helpref{wxWindow::GetFont}{wxwindowgetfont}
+\helpref{wxWindow::GetFont}{wxwindowgetfont},\\
+\helpref{InheritAttributes}{wxwindowinheritattributes}
+
\membersection{wxWindow::SetForegroundColour}\label{wxwindowsetforegroundcolour}
Sets the foreground colour of the window.
+Please see \helpref{InheritAttributes}{wxwindowinheritattributes} for
+explanation of the difference between this method and
+\helpref{SetOwnForegroundColour}{wxwindowsetownforegroundcolour}.
+
\wxheading{Parameters}
-\docparam{colour}{The colour to be used as the foreground colour.}
+\docparam{colour}{The colour to be used as the foreground colour, pass
+ {\tt wxNullColour} to reset to the default colour.}
\wxheading{Remarks}
to the window class; it may be the text colour or other colour, or it may not
be used at all.
+Using this function will disable attempts to use themes for this
+window, if the system supports them. Use with care since usually the
+themes represent the appearance chosen by the user to be used for all
+applications on the system.
+
\wxheading{See also}
\helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour},\rtfsp
\helpref{wxWindow::SetBackgroundColour}{wxwindowsetbackgroundcolour},\rtfsp
-\helpref{wxWindow::GetBackgroundColour}{wxwindowgetbackgroundcolour}
+\helpref{wxWindow::GetBackgroundColour}{wxwindowgetbackgroundcolour},\rtfsp
+\helpref{wxWindow::ShouldInheritColours}{wxwindowshouldinheritcolours}
+
+
+\membersection{wxWindow::SetHelpText}\label{wxwindowsethelptext}
+
+\func{virtual void}{SetHelpText}{\param{const wxString\& }{helpText}}
+
+Sets the help text to be used as context-sensitive help for this window.
+
+Note that the text is actually stored by the current \helpref{wxHelpProvider}{wxhelpprovider} implementation,
+and not in the window object itself.
+
+\wxheading{See also}
+
+\helpref{GetHelpText}{wxwindowgethelptext}, \helpref{wxHelpProvider}{wxhelpprovider}
+
\membersection{wxWindow::SetId}\label{wxwindowsetid}
\helpref{wxWindow::GetId}{wxwindowgetid},\rtfsp
\helpref{Window identifiers}{windowids}
+
+
+\membersection{wxWindow::SetInitialBestSize}\label{wxwindowsetinitialbestsize}
+
+\func{virtual void}{SetInitialBestSize}{\param{const wxSize\& }{size}}
+
+Sets the initial window size if none is given (i.e. at least one of the
+components of the size passed to ctor/Create() is wxDefaultCoord).
+
+
+\membersection{wxWindow::SetInitialSize}\label{wxwindowsetinitialsize}
+
+\func{void}{SetInitialSize}{\param{const wxSize\& }{size = wxDefaultSize}}
+
+A {\it smart} SetSize that will fill in default size components with the
+window's {\it best} size values. Also sets the window's minsize to
+the value passed in for use with sizers. This means that if a full or
+partial size is passed to this function then the sizers will use that
+size instead of the results of GetBestSize to determine the minimum
+needs of the window for layout.
+
+Most controls will use this to set their initial size, and their min
+size to the passed in value (if any.)
+
+
+\wxheading{See also}
+
+\helpref{wxWindow::SetSize}{wxwindowsetsize},\rtfsp
+\helpref{wxWindow::GetBestSize}{wxwindowgetbestsize},\rtfsp
+\helpref{wxWindow::GetEffectiveMinSize}{wxwindowgeteffectiveminsize}
+
+
+\membersection{wxWindow::SetLabel}\label{wxwindowsetlabel}
+
+\func{virtual void}{SetLabel}{\param{const wxString\& }{label}}
+
+Sets the window's label.
+
+\wxheading{Parameters}
+
+\docparam{label}{The window label.}
+
+\wxheading{See also}
+
+\helpref{wxWindow::GetLabel}{wxwindowgetlabel}
+
+
+\membersection{wxWindow::SetMaxSize}\label{wxwindowsetmaxsize}
+
+\func{void}{SetMaxSize}{\param{const wxSize\& }{size}}
+
+Sets the maximum size of the window, to indicate to the sizer layout mechanism
+that this is the maximum possible size.
+
+\membersection{wxWindow::SetMinSize}\label{wxwindowsetminsize}
+
+\func{void}{SetMinSize}{\param{const wxSize\& }{size}}
+
+Sets the minimum size of the window, to indicate to the sizer layout mechanism
+that this is the minimum required size. You may need to call this
+if you change the window size after construction and before adding
+to its parent sizer.
+
\membersection{wxWindow::SetName}\label{wxwindowsetname}
\func{virtual void}{SetName}{\param{const wxString\& }{name}}
\helpref{wxWindow::GetName}{wxwindowgetname}
-\membersection{wxWindow::SetPalette}\label{wxwindowsetpalette}
-\func{virtual void}{SetPalette}{\param{wxPalette* }{palette}}
+\membersection{wxWindow::SetOwnBackgroundColour}\label{wxwindowsetownbackgroundcolour}
-Obsolete - use \helpref{wxDC::SetPalette}{wxdcsetpalette} instead.
+\func{void}{SetOwnBackgroundColour}{\param{const wxColour\& }{colour}}
-\membersection{wxWindow::SetReturnCode}\label{wxwindowsetreturncode}
+Sets the background colour of the window but prevents it from being inherited
+by the children of this window.
-\func{void}{SetReturnCode}{\param{int }{retCode}}
+\wxheading{See also}
-Sets the return code for this window.
+\helpref{SetBackgroundColour}{wxwindowsetbackgroundcolour},\rtfsp
+\helpref{InheritAttributes}{wxwindowinheritattributes}
-\wxheading{Parameters}
-\docparam{retCode}{The integer return code, usually a control identifier.}
+\membersection{wxWindow::SetOwnFont}\label{wxwindowsetownfont}
-\wxheading{Remarks}
+\func{void}{SetOwnFont}{\param{const wxFont\& }{font}}
+
+Sets the font of the window but prevents it from being inherited by the
+children of this window.
+
+\wxheading{See also}
+
+\helpref{SetFont}{wxwindowsetfont},\rtfsp
+\helpref{InheritAttributes}{wxwindowinheritattributes}
+
+
+\membersection{wxWindow::SetOwnForegroundColour}\label{wxwindowsetownforegroundcolour}
+
+\func{void}{SetOwnForegroundColour}{\param{const wxColour\& }{colour}}
-A return code is normally associated with a modal dialog, where \helpref{wxDialog::ShowModal}{wxdialogshowmodal} returns
-a code to the application. The function \helpref{wxDialog::EndModal}{wxdialogendmodal} calls {\bf SetReturnCode}.
+Sets the foreground colour of the window but prevents it from being inherited
+by the children of this window.
\wxheading{See also}
-\helpref{wxWindow::GetReturnCode}{wxwindowgetreturncode}, \helpref{wxDialog::ShowModal}{wxdialogshowmodal},\rtfsp
-\helpref{wxDialog::EndModal}{wxdialogendmodal}
+\helpref{SetForegroundColour}{wxwindowsetforegroundcolour},\rtfsp
+\helpref{InheritAttributes}{wxwindowinheritattributes}
+
+
+\membersection{wxWindow::SetPalette}\label{wxwindowsetpalette}
+
+\func{virtual void}{SetPalette}{\param{wxPalette* }{palette}}
+
+Obsolete - use \helpref{wxDC::SetPalette}{wxdcsetpalette} instead.
+
\membersection{wxWindow::SetScrollbar}\label{wxwindowsetscrollbar}
\func{virtual void}{SetScrollbar}{\param{int }{orientation}, \param{int }{position},\rtfsp
\param{int }{thumbSize}, \param{int }{range},\rtfsp
-\param{const bool }{refresh = TRUE}}
+\param{bool }{refresh = {\tt true}}}
Sets the scrollbar properties of a built-in scrollbar.
\docparam{range}{The maximum position of the scrollbar.}
-\docparam{refresh}{TRUE to redraw the scrollbar, FALSE otherwise.}
+\docparam{refresh}{{\tt true} to redraw the scrollbar, {\tt false} otherwise.}
\wxheading{Remarks}
the scrollbar settings when the window size changes. You could therefore put your
scrollbar calculations and SetScrollbar
call into a function named AdjustScrollbars, which can be called initially and also
-from your \helpref{wxWindow::OnSize}{wxwindowonsize} event handler function.
+from your \helpref{wxSizeEvent}{wxsizeevent} handler function.
\wxheading{See also}
\helpref{Scrolling overview}{scrollingoverview},\rtfsp
-\helpref{wxScrollBar}{wxscrollbar}, \helpref{wxScrolledWindow}{wxscrolledwindow}
+\helpref{wxScrollBar}{wxscrollbar}, \helpref{wxScrolledWindow}{wxscrolledwindow},\rtfsp
+\helpref{wxScrollWinEvent}{wxscrollwinevent}
\begin{comment}
+
+
\membersection{wxWindow::SetScrollPage}\label{wxwindowsetscrollpage}
-\func{virtual void}{SetScrollPage}{\param{int }{orientation}, \param{int }{pageSize}, \param{const bool }{refresh = TRUE}}
+\func{virtual void}{SetScrollPage}{\param{int }{orientation}, \param{int }{pageSize}, \param{bool }{refresh = {\tt true}}}
Sets the page size of one of the built-in scrollbars.
\docparam{pageSize}{Page size in scroll units.}
-\docparam{refresh}{TRUE to redraw the scrollbar, FALSE otherwise.}
+\docparam{refresh}{{\tt true} to redraw the scrollbar, {\tt false} otherwise.}
\wxheading{Remarks}
\wxheading{See also}
\helpref{wxWindow::SetScrollPos}{wxwindowsetscrollpos},\rtfsp
-\helpref{wxWindow::GetScrollPos}{wxwindowsetscrollpos},\rtfsp
-\helpref{wxWindow::GetScrollPage}{wxwindowsetscrollpage},\rtfsp
+\helpref{wxWindow::GetScrollPos}{wxwindowgetscrollpos},\rtfsp
+\helpref{wxWindow::GetScrollPage}{wxwindowgetscrollpage},\rtfsp
\helpref{wxScrollBar}{wxscrollbar}, \helpref{wxScrolledWindow}{wxscrolledwindow}
\end{comment}
+
\membersection{wxWindow::SetScrollPos}\label{wxwindowsetscrollpos}
-\func{virtual void}{SetScrollPos}{\param{int }{orientation}, \param{int }{pos}, \param{const bool }{refresh = TRUE}}
+\func{virtual void}{SetScrollPos}{\param{int }{orientation}, \param{int }{pos}, \param{bool }{refresh = {\tt true}}}
Sets the position of one of the built-in scrollbars.
\docparam{pos}{Position in scroll units.}
-\docparam{refresh}{TRUE to redraw the scrollbar, FALSE otherwise.}
+\docparam{refresh}{{\tt true} to redraw the scrollbar, {\tt false} otherwise.}
\wxheading{Remarks}
\wxheading{See also}
\helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar},\rtfsp
-\helpref{wxWindow::GetScrollPos}{wxwindowsetscrollpos},\rtfsp
+\helpref{wxWindow::GetScrollPos}{wxwindowgetscrollpos},\rtfsp
\helpref{wxWindow::GetScrollThumb}{wxwindowgetscrollthumb},\rtfsp
\helpref{wxScrollBar}{wxscrollbar}, \helpref{wxScrolledWindow}{wxscrolledwindow}
\begin{comment}
+
+
\membersection{wxWindow::SetScrollRange}\label{wxwindowsetscrollrange}
-\func{virtual void}{SetScrollRange}{\param{int }{orientation}, \param{int }{range}, \param{const bool }{refresh = TRUE}}
+\func{virtual void}{SetScrollRange}{\param{int }{orientation}, \param{int }{range}, \param{bool }{refresh = {\tt true}}}
Sets the range of one of the built-in scrollbars.
\docparam{range}{Scroll range.}
-\docparam{refresh}{TRUE to redraw the scrollbar, FALSE otherwise.}
+\docparam{refresh}{{\tt true} to redraw the scrollbar, {\tt false} otherwise.}
\wxheading{Remarks}
\helpref{wxWindow::SetScrollPos}{wxwindowsetscrollpos},\rtfsp
\helpref{wxWindow::SetScrollPage}{wxwindowsetscrollpage},\rtfsp
-\helpref{wxWindow::GetScrollPos}{wxwindowsetscrollpos},\rtfsp
-\helpref{wxWindow::GetScrollPage}{wxwindowsetscrollpage},\rtfsp
+\helpref{wxWindow::GetScrollPos}{wxwindowgetscrollpos},\rtfsp
+\helpref{wxWindow::GetScrollPage}{wxwindowgetscrollpage},\rtfsp
\helpref{wxScrollBar}{wxscrollbar}, \helpref{wxScrolledWindow}{wxscrolledwindow}
\end{comment}
+
\membersection{wxWindow::SetSize}\label{wxwindowsetsize}
\func{virtual void}{SetSize}{\param{int}{ x}, \param{int}{ y}, \param{int}{ width}, \param{int}{ height},
\func{virtual void}{SetSize}{\param{const wxRect\&}{ rect}}
-Sets the size and position of the window in pixels.
+Sets the position and size of the window in pixels.
\func{virtual void}{SetSize}{\param{int}{ width}, \param{int}{ height}}
\wxheading{Parameters}
-\docparam{x}{Required x position in pixels, or -1 to indicate that the existing
+\docparam{x}{Required x position in pixels, or wxDefaultCoord to indicate that the existing
value should be used.}
-\docparam{y}{Required y position in pixels, or -1 to indicate that the existing
+\docparam{y}{Required y position in pixels, or wxDefaultCoord to indicate that the existing
value should be used.}
-\docparam{width}{Required width in pixels, or -1 to indicate that the existing
+\docparam{width}{Required width in pixels, or wxDefaultCoord to indicate that the existing
value should be used.}
-\docparam{height}{Required height position in pixels, or -1 to indicate that the existing
+\docparam{height}{Required height position in pixels, or wxDefaultCoord to indicate that the existing
value should be used.}
\docparam{size}{\helpref{wxSize}{wxsize} object for setting the size.}
\docparam{sizeFlags}{Indicates the interpretation of other parameters. It is a bit list of the following:
-{\bf wxSIZE\_AUTO\_WIDTH}: a -1 width value is taken to indicate
-a wxWindows-supplied default width.\\
-{\bf wxSIZE\_AUTO\_HEIGHT}: a -1 height value is taken to indicate
-a wxWindows-supplied default width.\\
-{\bf wxSIZE\_AUTO}: -1 size values are taken to indicate
-a wxWindows-supplied default size.\\
+{\bf wxSIZE\_AUTO\_WIDTH}: a $wxDefaultCoord$ width value is taken to indicate
+a wxWidgets-supplied default width.\\
+{\bf wxSIZE\_AUTO\_HEIGHT}: a $wxDefaultCoord$ height value is taken to indicate
+a wxWidgets-supplied default height.\\
+{\bf wxSIZE\_AUTO}: $wxDefaultCoord$ size values are taken to indicate
+a wxWidgets-supplied default size.\\
{\bf wxSIZE\_USE\_EXISTING}: existing dimensions should be used
-if -1 values are supplied.\\
-{\bf wxSIZE\_ALLOW\_MINUS\_ONE}: allow dimensions of -1 and less to be interpreted
+if $wxDefaultCoord$ values are supplied.\\
+{\bf wxSIZE\_ALLOW\_MINUS\_ONE}: allow negative dimensions (ie. value of $wxDefaultCoord$) to be interpreted
as real dimensions, not default values.
+{\bf wxSIZE\_FORCE}: normally, if the position and the size of the window are
+already the same as the parameters of this function, nothing is done. but with
+this flag a window resize may be forced even in this case (supported in wx
+2.6.2 and later and only implemented for MSW and ignored elsewhere currently)
}
\wxheading{Remarks}
x and y parameters, and must be used with non-default width and height values.
The first form sets the position and optionally size, of the window.
-Parameters may be -1 to indicate either that a default should be supplied
-by wxWindows, or that the current value of the dimension should be used.
+Parameters may be $wxDefaultCoord$ to indicate either that a default should be supplied
+by wxWidgets, or that the current value of the dimension should be used.
\wxheading{See also}
\pythonnote{In place of a single overloaded method name, wxPython
implements the following methods:\par
\indented{2cm}{\begin{twocollist}
-\twocolitem{\bf{SetDimensions(x, y, width, height, sizeFlags=wxSIZE_AUTO)}}{}
-\twocolitem{\bf{SetSize(size)}}{}
-\twocolitem{\bf{SetPosition(point)}}{}
+\twocolitem{{\bf SetDimensions(x, y, width, height, sizeFlags=wxSIZE\_AUTO)}}{}
+\twocolitem{{\bf SetSize(size)}}{}
+\twocolitem{{\bf SetPosition(point)}}{}
\end{twocollist}}
}
+
\membersection{wxWindow::SetSizeHints}\label{wxwindowsetsizehints}
-\func{virtual void}{SetSizeHints}{\param{int}{ minW=-1}, \param{int}{ minH=-1}, \param{int}{ maxW=-1}, \param{int}{ maxH=-1},
- \param{int}{ incW=-1}, \param{int}{ incH=-1}}
+Use of this function for windows which are not toplevel windows
+(such as wxDialog or wxFrame) is discouraged. Please use
+\helpref{SetMinSize}{wxwindowsetminsize} and \helpref{SetMaxSize}{wxwindowsetmaxsize}
+instead.
+
+\wxheading{See also}
+
+\helpref{wxTopLevelWindow::SetSizeHints}{wxtoplevelwindowsetsizehints}.
+
+
+\membersection{wxWindow::SetSizer}\label{wxwindowsetsizer}
+
+\func{void}{SetSizer}{\param{wxSizer* }{sizer}, \param{bool }{deleteOld=true}}
+
+Sets the window to have the given layout sizer. The window
+will then own the object, and will take care of its deletion.
+If an existing layout constraints object is already owned by the
+window, it will be deleted if the deleteOld parameter is true.
+
+Note that this function will also call
+\helpref{SetAutoLayout}{wxwindowsetautolayout} implicitly with {\tt true}
+parameter if the {\it sizer}\/ is non-NULL and {\tt false} otherwise.
+
+\wxheading{Parameters}
+
+\docparam{sizer}{The sizer to set. Pass NULL to disassociate and conditionally delete
+the window's sizer. See below.}
+
+\docparam{deleteOld}{If true (the default), this will delete any pre-existing sizer.
+Pass false if you wish to handle deleting the old sizer yourself.}
+
+\wxheading{Remarks}
+
+SetSizer now enables and disables Layout automatically, but prior to wxWidgets 2.3.3
+the following applied:
+
+You must call \helpref{wxWindow::SetAutoLayout}{wxwindowsetautolayout} to tell a window to use
+the sizer automatically in OnSize; otherwise, you must override OnSize and call Layout()
+explicitly. When setting both a wxSizer and a \helpref{wxLayoutConstraints}{wxlayoutconstraints},
+only the sizer will have effect.
+
+
+\membersection{wxWindow::SetSizerAndFit}\label{wxwindowsetsizerandfit}
+
+\func{void}{SetSizerAndFit}{\param{wxSizer* }{sizer}, \param{bool }{deleteOld=true}}
+
+The same as \helpref{SetSizer}{wxwindowsetsizer}, except it also sets the size hints
+for the window based on the sizer's minimum size.
+
+
+\membersection{wxWindow::SetThemeEnabled}\label{wxwindowsetthemeenabled}
+
+\func{virtual void}{SetThemeEnabled}{\param{bool }{enable}}
+
+This function tells a window if it should use the system's "theme" code
+to draw the windows' background instead if its own background drawing
+code. This does not always have any effect since the underlying platform
+obviously needs to support the notion of themes in user defined windows.
+One such platform is GTK+ where windows can have (very colourful) backgrounds
+defined by a user's selected theme.
+
+Dialogs, notebook pages and the status bar have this flag set to true
+by default so that the default look and feel is simulated best.
+
+
+\membersection{wxWindow::SetToolTip}\label{wxwindowsettooltip}
+
+\func{void}{SetToolTip}{\param{const wxString\& }{tip}}
+
+\func{void}{SetToolTip}{\param{wxToolTip* }{tip}}
+
+Attach a tooltip to the window.
+
+See also: \helpref{GetToolTip}{wxwindowgettooltip},
+ \helpref{wxToolTip}{wxtooltip}
+
+
+\membersection{wxWindow::SetValidator}\label{wxwindowsetvalidator}
+
+\func{virtual void}{SetValidator}{\param{const wxValidator\&}{ validator}}
+
+Deletes the current validator (if any) and sets the window validator, having called wxValidator::Clone to
+create a new validator of this type.
+
+
+\membersection{wxWindow::SetVirtualSize}\label{wxwindowsetvirtualsize}
-Allows specification of minimum and maximum window sizes, and window size increments.
-If a pair of values is not set (or set to -1), the default values will be used.
+\func{void}{SetVirtualSize}{\param{int}{ width}, \param{int}{ height}}
+
+\func{void}{SetVirtualSize}{\param{const wxSize\&}{ size}}
+
+Sets the virtual size of the window in pixels.
+
+
+\membersection{wxWindow::SetVirtualSizeHints}\label{wxwindowsetvirtualsizehints}
+
+\func{virtual void}{SetVirtualSizeHints}{\param{int}{ minW},\param{int}{ minH}, \param{int}{ maxW=-1}, \param{int}{ maxH=-1}}
+
+\func{void}{SetVirtualSizeHints}{\param{const wxSize\&}{ minSize=wxDefaultSize},
+\param{const wxSize\&}{ maxSize=wxDefaultSize}}
+
+
+Allows specification of minimum and maximum virtual window sizes.
+If a pair of values is not set (or set to -1), the default values
+will be used.
\wxheading{Parameters}
\docparam{maxH}{Specifies the maximum height allowable.}
-\docparam{incW}{Specifies the increment for sizing the width (Motif/Xt only).}
+\docparam{minSize}{Minimum size.}
-\docparam{incH}{Specifies the increment for sizing the height (Motif/Xt only).}
+\docparam{maxSize}{Maximum size.}
\wxheading{Remarks}
-If this function is called, the user will not be able to size the window outside the
-given bounds.
+If this function is called, the user will not be able to size the virtual area
+of the window outside the given bounds.
-The resizing increments are only significant under Motif or Xt.
-\membersection{wxWindow::SetTitle}\label{wxwindowsettitle}
+\membersection{wxWindow::SetWindowStyle}\label{wxwindowsetwindowstyle}
-\func{virtual void}{SetTitle}{\param{const wxString\& }{title}}
+\func{void}{SetWindowStyle}{\param{long}{ style}}
-Sets the window's title. Applicable only to frames and dialogs.
+Identical to \helpref{SetWindowStyleFlag}{wxwindowsetwindowstyleflag}.
-\wxheading{Parameters}
-\docparam{title}{The window's title.}
+\membersection{wxWindow::SetWindowStyleFlag}\label{wxwindowsetwindowstyleflag}
+
+\func{virtual void}{SetWindowStyleFlag}{\param{long}{ style}}
+
+Sets the style of the window. Please note that some styles cannot be changed
+after the window creation and that \helpref{Refresh()}{wxwindowrefresh} might
+need to be be called after changing the others for the change to take place
+immediately.
+
+See \helpref{Window styles}{windowstyles} for more information about flags.
\wxheading{See also}
-\helpref{wxWindow::GetTitle}{wxwindowgettitle}
+\helpref{GetWindowStyleFlag}{wxwindowgetwindowstyleflag}
+
+
+\membersection{wxWindow::SetWindowVariant}\label{wxwindowsetwindowvariant}
+
+\func{void}{SetWindowVariant}{\param{wxWindowVariant}{variant}}
+
+This function can be called under all platforms but only does anything under
+Mac OS X 10.3+ currently. Under this system, each of the standard control can
+exist in several sizes which correspond to the elements of wxWindowVariant
+enum:
+\begin{verbatim}
+enum wxWindowVariant
+{
+ wxWINDOW_VARIANT_NORMAL, // Normal size
+ wxWINDOW_VARIANT_SMALL, // Smaller size (about 25 % smaller than normal )
+ wxWINDOW_VARIANT_MINI, // Mini size (about 33 % smaller than normal )
+ wxWINDOW_VARIANT_LARGE, // Large size (about 25 % larger than normal )
+};
+\end{verbatim}
+
+By default the controls use the normal size, of course, but this function can
+be used to change this.
+
+
+\membersection{wxWindow::ShouldInheritColours}\label{wxwindowshouldinheritcolours}
+
+\func{virtual bool}{ShouldInheritColours}{\void}
+
+Return \true from here to allow the colours of this window to be changed by
+\helpref{InheritAttributes}{wxwindowinheritattributes}, returning \false
+forbids inheriting them from the parent window.
-\membersection{wxWindow::Show}
+The base class version returns \false, but this method is overridden in
+\helpref{wxControl}{wxcontrol} where it returns \true.
-\func{virtual bool}{Show}{\param{const bool}{ show}}
-Shows or hides the window.
+\membersection{wxWindow::Show}\label{wxwindowshow}
+
+\func{virtual bool}{Show}{\param{bool}{ show = {\tt true}}}
+
+Shows or hides the window. You may need to call \helpref{Raise}{wxwindowraise}
+for a top level window if you want to bring it to top, although this is not
+needed if Show() is called immediately after the frame creation.
\wxheading{Parameters}
-\docparam{show}{If TRUE, displays the window and brings it to the front. Otherwise,
-hides the window.}
+\docparam{show}{If {\tt true} displays the window. Otherwise, hides it.}
+
+\wxheading{Return value}
+
+{\tt true} if the window has been shown or hidden or {\tt false} if nothing was
+done because it already was in the requested state.
\wxheading{See also}
-\helpref{wxWindow::IsShown}{wxwindowisshown}
+\helpref{wxWindow::IsShown}{wxwindowisshown},\rtfsp
+\helpref{wxWindow::Hide}{wxwindowhide},\rtfsp
+\helpref{wxRadioBox::Show}{wxradioboxshow}
+
+
+\membersection{wxWindow::Thaw}\label{wxwindowthaw}
+
+\func{virtual void}{Thaw}{\void}
+
+Reenables window updating after a previous call to
+\helpref{Freeze}{wxwindowfreeze}. To really thaw the control, it must be called
+exactly the same number of times as \helpref{Freeze}{wxwindowfreeze}.
+
+\wxheading{See also}
+
+\helpref{wxWindowUpdateLocker}{wxwindowupdatelocker}
+
+
+\membersection{wxWindow::ToggleWindowStyle}\label{wxwindowtogglewindowstyle}
+
+\func{bool}{ToggleWindowStyle}{\param{int }{flag}}
+
+Turns the given \arg{flag} on if it's currently turned off and vice versa.
+This function cannot be used if the value of the flag is $0$ (which is often
+the case for default flags).
+
+Also, please notice that not all styles can be changed after the control
+creation.
+
+\wxheading{Return value}
+
+Returns \true if the style was turned on by this function, \false if it was
+switched off.
+
+\wxheading{See also}
+
+\helpref{wxWindow::SetWindowStyleFlag}{wxwindowsetwindowstyleflag},\rtfsp
+\helpref{wxWindow::HasFlag}{wxwindowhasflag}
+
\membersection{wxWindow::TransferDataFromWindow}\label{wxwindowtransferdatafromwindow}
\func{virtual bool}{TransferDataFromWindow}{\void}
Transfers values from child controls to data areas specified by their validators. Returns
-FALSE if a transfer failed.
+{\tt false} if a transfer failed.
+
+If the window has {\tt wxWS\_EX\_VALIDATE\_RECURSIVELY} extra style flag set,
+the method will also call TransferDataFromWindow() of all child windows.
\wxheading{See also}
\helpref{wxWindow::TransferDataToWindow}{wxwindowtransferdatatowindow},\rtfsp
\helpref{wxValidator}{wxvalidator}, \helpref{wxWindow::Validate}{wxwindowvalidate}
+
\membersection{wxWindow::TransferDataToWindow}\label{wxwindowtransferdatatowindow}
\func{virtual bool}{TransferDataToWindow}{\void}
Transfers values to child controls from data areas specified by their validators.
+If the window has {\tt wxWS\_EX\_VALIDATE\_RECURSIVELY} extra style flag set,
+the method will also call TransferDataToWindow() of all child windows.
+
\wxheading{Return value}
-Returns FALSE if a transfer failed.
+Returns {\tt false} if a transfer failed.
\wxheading{See also}
\helpref{wxWindow::TransferDataFromWindow}{wxwindowtransferdatafromwindow},\rtfsp
\helpref{wxValidator}{wxvalidator}, \helpref{wxWindow::Validate}{wxwindowvalidate}
+
+\membersection{wxWindow::UnregisterHotKey}\label{wxwindowunregisterhotkey}
+
+\func{bool}{UnregisterHotKey}{\param{int}{ hotkeyId}}
+
+Unregisters a system wide hotkey.
+
+\wxheading{Parameters}
+
+\docparam{hotkeyId}{Numeric identifier of the hotkey. Must be the same id that was passed to RegisterHotKey.}
+
+\wxheading{Return value}
+
+{\tt true} if the hotkey was unregistered successfully, {\tt false} if the id was invalid.
+
+\wxheading{Remarks}
+
+This function is currently only implemented under MSW.
+
+\wxheading{See also}
+
+\helpref{wxWindow::RegisterHotKey}{wxwindowregisterhotkey}
+
+
+\membersection{wxWindow::Update}\label{wxwindowupdate}
+
+\func{virtual void}{Update}{\void}
+
+Calling this method immediately repaints the invalidated area of the window and
+all of its children recursively while this would usually only happen when the
+flow of control returns to the event loop.
+Notice that this function doesn't invalidate any area of the window so
+nothing happens if nothing has been invalidated (i.e. marked as requiring
+a redraw). Use \helpref{Refresh}{wxwindowrefresh} first if you want to
+immediately redraw the window unconditionally.
+
+
+\membersection{wxWindow::UpdateWindowUI}\label{wxwindowupdatewindowui}
+
+\func{virtual void}{UpdateWindowUI}{\param{long}{ flags = wxUPDATE\_UI\_NONE}}
+
+This function sends \helpref{wxUpdateUIEvents}{wxupdateuievent} to
+the window. The particular implementation depends on the window; for
+example a wxToolBar will send an update UI event for each toolbar button,
+and a wxFrame will send an update UI event for each menubar menu item.
+You can call this function from your application to ensure that your
+UI is up-to-date at this point (as far as your wxUpdateUIEvent handlers
+are concerned). This may be necessary if you have called
+\helpref{wxUpdateUIEvent::SetMode}{wxupdateuieventsetmode} or
+\helpref{wxUpdateUIEvent::SetUpdateInterval}{wxupdateuieventsetupdateinterval} to
+limit the overhead that wxWidgets incurs by sending update UI events in idle time.
+
+{\it flags} should be a bitlist of one or more of the following values.
+
+\begin{verbatim}
+enum wxUpdateUI
+{
+ wxUPDATE_UI_NONE = 0x0000, // No particular value
+ wxUPDATE_UI_RECURSE = 0x0001, // Call the function for descendants
+ wxUPDATE_UI_FROMIDLE = 0x0002 // Invoked from On(Internal)Idle
+};
+\end{verbatim}
+
+If you are calling this function from an OnInternalIdle or OnIdle
+function, make sure you pass the wxUPDATE\_UI\_FROMIDLE flag, since
+this tells the window to only update the UI elements that need
+to be updated in idle time. Some windows update their elements
+only when necessary, for example when a menu is about to be shown.
+The following is an example of how to call UpdateWindowUI from
+an idle function.
+
+\begin{verbatim}
+void MyWindow::OnInternalIdle()
+{
+ if (wxUpdateUIEvent::CanUpdate(this))
+ UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
+}
+\end{verbatim}
+
+\wxheading{See also}
+
+\helpref{wxUpdateUIEvent}{wxupdateuievent},
+\helpref{wxWindow::DoUpdateWindowUI}{wxwindowdoupdatewindowui},
+\helpref{wxWindow::OnInternalIdle}{wxwindowoninternalidle}
+
+
\membersection{wxWindow::Validate}\label{wxwindowvalidate}
\func{virtual bool}{Validate}{\void}
Validates the current values of the child controls using their validators.
+If the window has {\tt wxWS\_EX\_VALIDATE\_RECURSIVELY} extra style flag set,
+the method will also call Validate() of all child windows.
+
\wxheading{Return value}
-Returns FALSE if any of the validations failed.
+Returns {\tt false} if any of the validations failed.
\wxheading{See also}
\helpref{wxWindow::TransferDataFromWindow}{wxwindowtransferdatafromwindow},\rtfsp
-\helpref{wxWindow::TransferDataFromWindow}{wxwindowtransferdatafromwindow},\rtfsp
+\helpref{wxWindow::TransferDataToWindow}{wxwindowtransferdatatowindow},\rtfsp
\helpref{wxValidator}{wxvalidator}
+
\membersection{wxWindow::WarpPointer}\label{wxwindowwarppointer}
\func{void}{WarpPointer}{\param{int}{ x}, \param{int}{ y}}
Moves the pointer to the given position on the window.
+{\bf NB: } This function is not supported under Mac because Apple Human
+Interface Guidelines forbid moving the mouse cursor programmatically.
+
\wxheading{Parameters}
\docparam{x}{The new x position for the cursor.}
projects / wxWidgets.git / blobdiff