\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 objecto n
+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}
\helpref{wxEvtHandler}{wxevthandler}\\
\helpref{wxObject}{wxobject}
+\wxheading{Include files}
+
+<wx/window.h>
+
\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.}
+for this style. }
+\twocolitem{\windowstyle{wxDOUBLE\_BORDER}}{Displays a double border. Windows and Mac 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{wxSTATIC\_BORDER}}{Displays a border suitable for a static control. Windows only. }
+\twocolitem{\windowstyle{wxNO\_BORDER}}{Displays no border, overriding the default border style for the window.}
\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{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 create and send a
+wxNavigationKeyEvent in response to the key events for Tab and
+Shift-Tab.}
+\twocolitem{\windowstyle{wxNO\_FULL\_REPAINT\_ON\_RESIZE}}{Disables repainting
+the window completely when its size is changed - you will have to repaint the
+new window area manually if you use this style. Currently only has an effect for
+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{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 only implemented for wxMSW 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 the code which previously used to work you may want to try this.}
\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}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxWindow::wxWindow}
+
+\membersection{wxWindow::wxWindow}\label{wxwindowctor}
\func{}{wxWindow}{\void}
\docparam{id}{Window identifier. If -1, will automatically create an identifier.}
-\docparam{pos}{Window position. wxDefaultPosition is (-1, -1) which indicates that wxWindows
+\docparam{pos}{Window position. wxDefaultPosition is (-1, -1) which 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 is (-1, -1) which 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}}
\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}
\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::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.
+
\wxheading{See also}
\helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse}
+
\membersection{wxWindow::Center}\label{wxwindowcenter}
\func{void}{Center}{\param{int}{ direction}}
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.
-Clears the window by filling it with the current background colour.
\membersection{wxWindow::ClientToScreen}
\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.
\docparam{pt}{The client position for the second form of the function.}
+\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)}
+\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::GetForce}{wxcloseeventgetforce}, 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:
\helpref{wxWindow::ConvertPixelsToDialog}{wxwindowconvertpixelstodialog}
+\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}
+\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
+units to pixels}
+\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, wxPythonimplements 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}
+\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}
\func{virtual void}{DestroyChildren}{\void}
Destroys all children of a window. Called automatically by the destructor.
-\membersection{wxWindow::DragAcceptFiles}\label{wxwindowdragacceptfiles}
-\func{virtual void}{DragAcceptFiles}{\param{const bool}{ accept}}
+\membersection{wxWindow::Disable}\label{wxwindowdisable}
-Enables or disables elibility for drop file events (OnDropFiles).
+\func{bool}{Disable}{\void}
-\wxheading{Parameters}
+Disables the window, same as \helpref{Enable({\tt false})}{wxwindowenable}.
-\docparam{accept}{If TRUE, the window is eligible for drop file events. If FALSE, the window
-will not accept drop file events.}
+\wxheading{Return value}
-\wxheading{Remarks}
+Returns {\tt true} if the window has been disabled, {\tt false} if it had been
+already disabled before the call to this function.
-Windows only.
-\wxheading{See also}
+\membersection{wxWindow::DoUpdateWindowUI}\label{wxwindowdoupdatewindowui}
-\helpref{wxWindow::OnDropFiles}{wxwindowondropfiles}
+\func{virtual void}{DoUpdateWindowUI}{\param{wxUpdateUIEvent\&}{ event}}
-\membersection{wxWindow::Enable}\label{wxwindowenable}
+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}
-\func{virtual void}{Enable}{\param{const bool}{ enable}}
-Enable or disable the window for user input.
-\wxheading{Parameters}
+\membersection{wxWindow::DragAcceptFiles}\label{wxwindowdragacceptfiles}
-\docparam{enable}{If TRUE, enables the window for input. If FALSE, disables the window.}
+\func{virtual void}{DragAcceptFiles}{\param{bool}{ accept}}
-\wxheading{See also}
+Enables or disables eligibility for drop file events (OnDropFiles).
-\helpref{wxWindow::IsEnabled}{wxwindowisenabled}
+\wxheading{Parameters}
-\membersection{wxWindow::FakePopupMenu}\label{wxwindowfakepopupmenu}
+\docparam{accept}{If {\tt true}, the window is eligible for drop file events. If {\tt false}, the window
+will not accept drop file events.}
-\func{virtual bool}{FakePopupMenu}{\param{wxMenu* }{menu}, \param{int }{x}, \param{int }{y}}
+\wxheading{Remarks}
-A replacement for wxWindow::PopupMenu for cases where the PopupMenu implementation
-does not work correctly, in particular on Motif platforms.
+Windows only.
-\wxheading{Parameters}
-\docparam{menu}{Menu to pop up.}
+\membersection{wxWindow::Enable}\label{wxwindowenable}
-\docparam{x}{Required x position for the menu to appear.}
+\func{virtual bool}{Enable}{\param{bool}{ enable = {\tt true}}}
-\docparam{y}{Required y position for the menu to appear.}
+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{Remarks}
+\wxheading{Parameters}
-This is a cut-down version of PopupMenu using a dialog and listbox; pull-right menus
-are not supported.
+\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{wxMenu}{wxmenu}, \helpref{wxWindow::PopupMenu}{wxwindowpopupmenu}
+\helpref{wxWindow::IsEnabled}{wxwindowisenabled},\rtfsp
+\helpref{wxWindow::Disable}{wxwindowdisable}
+
\membersection{wxWindow::FindFocus}\label{wxwindowfindfocus}
\helpref{wxWindow::SetFocus}{wxwindowsetfocus}
+
+
\membersection{wxWindow::FindWindow}\label{wxwindowfindwindow}
\func{wxWindow*}{FindWindow}{\param{long}{ id}}
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}
+\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::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::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::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 the
+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 inserting large amount of text 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.
+
+
+\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{wxAccessibile*}{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 similar to \helpref{GetBestSize}{wxwindowgetbestsize}, except
+in one thing. GetBestSize should return the minimum untruncated size of the
+window, while this method will return the largest of BestSize and any user
+specified minimum size. ie. it is the minimum size the window should currently
+be drawn at, not the minimal size it can possibly tolerate.
+
\membersection{wxWindow::GetBackgroundColour}\label{wxwindowgetbackgroundcolour}
\helpref{wxWindow::SetBackgroundColour}{wxwindowsetbackgroundcolour},\rtfsp
\helpref{wxWindow::SetForegroundColour}{wxwindowsetforegroundcolour},\rtfsp
-\helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour},\rtfsp
-\helpref{wxWindow::OnEraseBackground}{wxwindowonerasebackground}
+\helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour}
+
+
+\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::GetCaret}\label{wxwindowgetcaret}
+
+\constfunc{wxCaret *}{GetCaret}{\void}
+
+Returns the \helpref{caret}{wxcaret} associated with the window.
+
+
+\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{wxMouseCaptureChangedEvent}{wxmousecapturechangedevent}
+
\membersection{wxWindow::GetCharHeight}
Returns the character height for this window.
+
\membersection{wxWindow::GetCharWidth}
\constfunc{virtual int}{GetCharWidth}{\void}
Returns the average character width for this window.
+
\membersection{wxWindow::GetChildren}
\func{wxList\&}{GetChildren}{\void}
Returns a reference to the list of the window's children.
+
+\membersection{wxControl::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}
+
+
\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.
+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, scrollbars, etc.
\wxheading{Parameters}
\docparam{height}{Receives the client height in pixels.}
+\pythonnote{In place of a single overloaded method name, wxPython
+implements the following methods:\par
+\indented{2cm}{\begin{twocollist}
+\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{wxControl::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}
\wxheading{See also}
-\helpref{wxWindow::SetDropTarget}{wxwindowsetdroptarget},
+\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}
\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}
\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 or {\bf GtkWidget} for GTK.
-\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::GetHelpText}\label{wxwindowgethelptext}
-Each window has an integer identifier. If the application has not provided one,
-an identifier will be generated.
+\constfunc{virtual wxString}{GetHelpText}{\void}
-TODO: perhaps there should be a default identifier for each class, rather
-choosing one, which could clash with other ones.
+Gets 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{wxWindow::SetId}{wxwindowsetid}
+\helpref{SetHelpText}{wxwindowsethelptext}, \helpref{wxHelpProvider}{wxhelpprovider}
-\membersection{wxWindow::GetPosition}
-\constfunc{virtual void}{GetPosition}{\param{int* }{x}, \param{int* }{y}}
+\membersection{wxWindow::GetId}\label{wxwindowgetid}
-This gets the position of the window in pixels, relative to the parent window or
-if no parent, relative to the whole display.
+\constfunc{int}{GetId}{\void}
-\wxheading{Parameters}
+Returns the identifier of the window.
-\docparam{x}{Receives the x position of the window.}
+\wxheading{Remarks}
+
+Each window has an integer identifier. If the application has not provided one
+(or the default Id -1) an unique identifier with a negative value will be generated.
+
+\wxheading{See also}
+
+\helpref{wxWindow::SetId}{wxwindowsetid},\rtfsp
+\helpref{Window identifiers}{windowids}
-\docparam{y}{Receives the y position of the window.}
\membersection{wxWindow::GetLabel}
-\constfunc{virtual wxString\& }{GetLabel}{\void}
+\constfunc{virtual wxString }{GetLabel}{\void}
Generic way of getting a label from any window, for
identification purposes.
tools or special-needs access programs) which need to identify windows
by name.
+
\membersection{wxWindow::GetName}\label{wxwindowgetname}
-\constfunc{virtual wxString\& }{GetName}{\void}
+\constfunc{virtual wxString }{GetName}{\void}
Returns the window's name.
\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}
+\membersection{wxWindow::GetPosition}\label{wxwindowgetposition}
-Returns the size and position of the window as a \helpref{wxRect}{wxrect} object.
+\constfunc{virtual void}{GetPosition}{\param{int* }{x}, \param{int* }{y}}
-\membersection{wxWindow::GetReturnCode}\label{wxwindowgetreturncode}
+\constfunc{wxPoint}{GetPosition}{\void}
-\func{int}{GetReturnCode}{\void}
+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.
-Gets the return code for this window.
+\wxheading{Parameters}
-\wxheading{Remarks}
+\docparam{x}{Receives the x position of the window.}
-A return code is normally associated with a modal dialog, where \helpref{wxDialog::ShowModal}{wxdialogshowmodal} returns
-a code to the application.
+\docparam{y}{Receives the y position of the window.}
-\wxheading{See also}
+\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}}
+}
-\helpref{wxWindow::SetReturnCode}{wxwindowsetreturncode}, \helpref{wxDialog::ShowModal}{wxdialogshowmodal},\rtfsp
-\helpref{wxDialog::EndModal}{wxdialogendmodal}
+\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::GetScrollThumb}\label{wxwindowgetscrollthumb}
-\func{virtual int}{GetScrollThumb}{\param{int }{orientation}}
+\membersection{wxWindow::GetRect}\label{wxwindowgetrect}
-Returns the built-in scrollbar thumb size.
+\constfunc{virtual wxRect}{GetRect}{\void}
-\wxheading{See also}
+Returns the size and position of the window as a \helpref{wxRect}{wxrect} object.
+
+
+\membersection{wxWindow::GetScrollThumb}\label{wxwindowgetscrollthumb}
+
+\func{virtual int}{GetScrollThumb}{\param{int }{orientation}}
+
+Returns the built-in scrollbar thumb size.
+
+\wxheading{See also}
\helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar}
+
\membersection{wxWindow::GetScrollPos}\label{wxwindowgetscrollpos}
\func{virtual int}{GetScrollPos}{\param{int }{orientation}}
See \helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar}
+
\membersection{wxWindow::GetScrollRange}\label{wxwindowgetscrollrange}
\func{virtual int}{GetScrollRange}{\param{int }{orientation}}
\helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar}
+
\membersection{wxWindow::GetSize}\label{wxwindowgetsize}
-\constfunc{virtual void}{GetSize}{\param{int* }{width}, \param{int* }{height}}
+\constfunc{void}{GetSize}{\param{int* }{width}, \param{int* }{height}}
-\constfunc{virtual wxSize}{GetSize}{\void}
+\constfunc{wxSize}{GetSize}{\void}
-This gets the size of the entire window in pixels.
+This gets the size of the entire window in pixels,
+including title bar, border, scrollbars, etc.
\wxheading{Parameters}
\docparam{height}{Receives the window height.}
-\membersection{wxWindow::GetTextExtent}
+\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}}
+}
+
+\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}
+}}
+
+\wxheading{See also}
+
+\helpref{GetClientSize}{wxwindowgetclientsize},\rtfsp
+\helpref{GetVirtualSize}{wxwindowgetvirtualsize}
+
+
+\membersection{wxWindow::GetSizer}\label{wxwindowgetsizer}
+
+\constfunc{wxSizer *}{GetSizer}{\void}
+
+Return the sizer associated with the window by a previous call to
+\helpref{SetSizer()}{wxwindowsetsizer} or {\tt NULL}.
+
+
+\membersection{wxWindow::GetTextExtent}\label{wxwindowgettextextent}
\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}}
+ \param{const wxFont* }{font = NULL}, \param{bool}{ use16 = {\tt false}}}
Gets the dimensions of the string as it would be drawn on the
window with the currently selected font.
\docparam{font}{Font to use instead of the current window font (optional).}
-\docparam{use16}{If TRUE, {\it string} contains 16-bit characters. The default is FALSE.}
+\docparam{use16}{If {\tt true}, {\it string} contains 16-bit characters. The default is {\tt false}.}
+
+\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}}
+}
+
+\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 )}.}
+
\membersection{wxWindow::GetTitle}\label{wxwindowgettitle}
\helpref{wxWindow::SetTitle}{wxwindowsettitle}
-\membersection{wxWindow::GetUpdateRegion}\label{wxwindowgetupdateregion}
-\constfunc{virtual wxRegion}{GetUpdateRegion}{\void}
+\membersection{wxWindow::GetToolTip}\label{wxwindowgettooltip}
-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}
+\constfunc{wxToolTip*}{GetToolTip}{\void}
-\helpref{wxRegion}{wxregion}, \helpref{wxRegionIterator}{wxregioniterator}, \helpref{wxWindow::OnPaint}{wxwindowonpaint}
+Get the associated tooltip or NULL if none.
-\membersection{wxWindow::GetWindowStyleFlag}
-\constfunc{long}{GetWindowStyleFlag}{\void}
-
-Gets the window style that was passed to the consructor or {\bf Create} member.
-
-\membersection{wxWindow::InitDialog}\label{wxwindowinitdialog}
+\membersection{wxWindow::GetUpdateRegion}\label{wxwindowgetupdateregion}
-\func{void}{InitDialog}{\void}
+\constfunc{virtual wxRegion}{GetUpdateRegion}{\void}
-Sends an \helpref{wxWindow::OnInitDialog}{wxwindowoninitdialog} event, which
-in turn transfers data to the dialog via validators.
+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{wxWindow::OnInitDialog}{wxwindowoninitdialog}
+\helpref{wxRegion}{wxregion},\rtfsp
+\helpref{wxRegionIterator}{wxregioniterator}
-\membersection{wxWindow::IsEnabled}\label{wxwindowisenabled}
-\constfunc{virtual bool}{IsEnabled}{\void}
+\membersection{wxWindow::GetValidator}\label{wxwindowgetvalidator}
-Returns TRUE if the window is enabled for input, FALSE otherwise.
+\constfunc{wxValidator*}{GetValidator}{\void}
-\wxheading{See also}
+Returns a pointer to the current validator for the window, or NULL if there is none.
-\helpref{wxWindow::Enable}{wxwindowenable}
-\membersection{wxWindow::IsRetained}\label{wxwindowisretained}
+\membersection{wxWindow::GetVirtualSize}\label{wxwindowgetvirtualsize}
-\constfunc{virtual bool}{IsRetained}{\void}
-
-Returns TRUE if the window is retained, FALSE otherwise.
-
-\wxheading{Remarks}
+\constfunc{void}{GetVirtualSize}{\param{int* }{width}, \param{int* }{height}}
-Retained windows are only available on X platforms.
+\constfunc{wxSize}{GetVirtualSize}{\void}
-\membersection{wxWindow::IsShown}\label{wxwindowisshown}
+This gets the virtual size of the window in pixels.
-\constfunc{virtual bool}{IsShown}{\void}
+\wxheading{Parameters}
-Returns TRUE if the window is shown, FALSE if it has been hidden.
+\docparam{width}{Receives the window virtual width.}
-\membersection{wxWindow::Layout}\label{wxwindowlayout}
+\docparam{height}{Receives the window virtual height.}
-\func{void}{Layout}{\void}
+\helpref{GetSize}{wxwindowgetsize},\rtfsp
+\helpref{GetClientSize}{wxwindowgetclientsize}
-Invokes the constraint-based layout algorithm for this window. It is called
-automatically by the default {\bf wxWindow::OnSize} member.
-\membersection{wxWindow::LoadFromResource}\label{wxwindowloadfromresource}
+\membersection{wxWindow::GetWindowStyleFlag}\label{wxwindowgetwindowstyleflag}
-\func{virtual bool}{LoadFromResource}{\param{wxWindow* }{parent},\rtfsp
-\param{const wxString\& }{resourceName}, \param{const wxResourceTable* }{resourceTable = NULL}}
+\constfunc{long}{GetWindowStyleFlag}{\void}
-Loads a panel or dialog from a resource file.
+Gets the window style that was passed to the constructor or {\bf Create}
+method. {\bf GetWindowStyle()} is another name for the same function.
-\wxheading{Parameters}
-\docparam{parent}{Parent window.}
+\membersection{wxWindow::GetWindowVariant}\label{wxwindowgetwindowvariant}
-\docparam{resourceName}{The name of the resource to load.}
+\constfunc{wxWindowVariant}{GetWindowVariant}{\void}
-\docparam{resourceTable}{The resource table to load it from. If this is NULL, the
-default resource table will be used.}
+Returns the value previous passed to
+\helpref{wxWindow::SetWindowVariant}{wxwindowsetwindowvariant}.
-\wxheading{Return value}
-TRUE if the operation succeeded, otherwise FALSE.
+\membersection{wxWindow::HasCapture}\label{wxwindowhascapture}
-\wxheading{Remarks}
+\constfunc{virtual bool}{HasCapture}{\void}
-TODO
+Returns true if this window has the current mouse capture.
\wxheading{See also}
-TODO
+\helpref{wxWindow::CaptureMouse}{wxwindowcapturemouse},
+\helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse},
+\helpref{wxMouseCaptureChangedEvent}{wxmousecapturechangedevent}
-\membersection{wxWindow::Lower}\label{wxwindowlower}
-\func{void}{Lower}{\void}
+\membersection{wxWindow::Hide}\label{wxwindowhide}
-Lowers the window to the bottom of the window hierarchy if it is a managed window (dialog
-or frame).
+\func{bool}{Hide}{\void}
-\membersection{wxWindow::MakeModal}\label{wxwindowmakemodal}
+Equivalent to calling \helpref{Show}{wxwindowshow}({\tt false}).
-\func{virtual void}{MakeModal}{\param{const bool }{flag}}
-Disables all other windows in the application so that
-the user can only interact with this window.
+\membersection{wxWindow::InheritAttributes}\label{wxwindowinheritattributes}
-\wxheading{Parameters}
+\func{void}{InheritAttributes}{\void}
-\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.}
+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.
-\membersection{wxWindow::Move}\label{wxwindowmove}
+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{SetDefaultFont}{wxwindowsetdefaultfont}) 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.
-\func{void}{Move}{\param{int}{ x}, \param{int}{ y}}
+This rather complicated logic is necessary in order to accomodate the
+different usage scenarius. 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.
-\func{void}{Move}{\param{const wxPoint\&}{ pt}}
-Moves the window to the given position.
+\membersection{wxWindow::InitDialog}\label{wxwindowinitdialog}
-\wxheading{Parameters}
+\func{void}{InitDialog}{\void}
-\docparam{x}{Required x position.}
+Sends an {\tt wxEVT\_INIT\_DIALOG} event, whose handler usually transfers data
+to the dialog via validators.
-\docparam{y}{Required y position.}
-\docparam{pt}{\helpref{wxPoint}{wxpoint} object representing the position.}
+\membersection{wxWindow::IsEnabled}\label{wxwindowisenabled}
-\wxheading{Remarks}
+\constfunc{virtual bool}{IsEnabled}{\void}
-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}
+Returns {\tt true} if the window is enabled for input, {\tt false} otherwise.
\wxheading{See also}
-\helpref{wxWindow::SetSize}{wxwindowsetsize}
+\helpref{wxWindow::Enable}{wxwindowenable}
-\membersection{wxWindow::OnActivate}\label{wxwindowonactivate}
-\func{void}{OnActivate}{\param{wxActivateEvent\&}{ event}}
+\membersection{wxWindow::IsExposed}\label{wxwindowisexposed}
-Called when a window is activated or deactivated.
+\constfunc{bool}{IsExposed}{\param{int }{x}, \param{int }{y}}
-\wxheading{Parameters}
+\constfunc{bool}{IsExposed}{\param{wxPoint }{\&pt}}
-\docparam{event}{Object containing activation information.}
+\constfunc{bool}{IsExposed}{\param{int }{x}, \param{int }{y}, \param{int }{w}, \param{int }{h}}
-\wxheading{Remarks}
+\constfunc{bool}{IsExposed}{\param{wxRect }{\&rect}}
-If the window is being activated, \helpref{wxActivateEvent::GetActive}{wxactivateeventgetactive} returns TRUE,
-otherwise it returns FALSE (it is being deactivated).
+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.
-\wxheading{See also}
+\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}}}
-\helpref{wxActivateEvent}{wxactivateevent},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
-\membersection{wxWindow::OnChar}\label{wxwindowonchar}
+\membersection{wxWindow::IsRetained}\label{wxwindowisretained}
-\func{void}{OnChar}{\param{wxKeyEvent\&}{ event}}
+\constfunc{virtual bool}{IsRetained}{\void}
-Called when the user has pressed a key.
+Returns {\tt true} if the window is retained, {\tt false} otherwise.
-\wxheading{Parameters}
+\wxheading{Remarks}
-\docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
-details about this class.}
+Retained windows are only available on X platforms.
-\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.
+\membersection{wxWindow::IsShown}\label{wxwindowisshown}
-Note that the ASCII values do not have explicit key codes: they are passed as ASCII
-values.
+\constfunc{virtual bool}{IsShown}{\void}
-Most, but not all, windows allow keypresses to be intercepted.
+Returns {\tt true} if the window is shown, {\tt false} if it has been hidden.
-\wxheading{See also}
-\helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\membersection{wxWindow::IsTopLevel}\label{wxwindowistoplevel}
-\membersection{wxWindow::OnCharHook}\label{wxwindowoncharhook}
+\constfunc{bool}{IsTopLevel}{\void}
-\func{void}{OnCharHook}{\param{wxKeyEvent\&}{ event}}
+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).
-This member is called to allow the window to intercept keyboard events
-before they are processed by child windows.
-\wxheading{Parameters}
+\membersection{wxWindow::Layout}\label{wxwindowlayout}
-\docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
-details about this class.}
+\func{void}{Layout}{\void}
-\wxheading{Remarks}
+Invokes the constraint-based layout algorithm or the sizer-based algorithm
+for this window.
-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.
+See \helpref{wxWindow::SetAutoLayout}{wxwindowsetautolayout}: when auto
+layout is on, this function gets called automatically when the window is resized.
-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.
+\membersection{wxWindow::LineDown}\label{wxwindowlinedown}
-This function is only relevant to top-level windows (frames and dialogs), and under
-Windows only.
+This is just a wrapper for \helpref{ScrollLines()}{wxwindowscrolllines}$(1)$.
-\wxheading{See also}
-\helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
-\helpref{wxApp::OnCharHook}{wxapponcharhook},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\membersection{wxWindow::LineUp}\label{wxwindowlineup}
-\membersection{wxWindow::OnCommand}\label{wxwindowoncommand}
+This is just a wrapper for \helpref{ScrollLines()}{wxwindowscrolllines}$(-1)$.
-\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.
+\membersection{wxWindow::Lower}\label{wxwindowlower}
-\wxheading{Parameters}
+\func{void}{Lower}{\void}
-\docparam{object}{Object receiving the command event.}
+Lowers the window to the bottom of the window hierarchy if it is a managed window (dialog
+or frame).
-\docparam{event}{Command event}
-\wxheading{Remarks}
+\membersection{wxWindow::MakeModal}\label{wxwindowmakemodal}
-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.
+\func{virtual void}{MakeModal}{\param{bool }{flag}}
-\wxheading{See also}
+Disables all other windows in the application so that
+the user can only interact with this window.
-\helpref{wxCommandEvent}{wxcommandevent},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\wxheading{Parameters}
-\membersection{wxWindow::OnClose}\label{wxwindowonclose}
+\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.}
-\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).
+\membersection{wxWindow::Move}\label{wxwindowmove}
-{\bf Note:} This is an obsolete function retained for backward compatibility.
-It is superceded by the \helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow} event
-handler.
+\func{void}{Move}{\param{int}{ x}, \param{int}{ y}}
-\wxheading{Return value}
+\func{void}{Move}{\param{const wxPoint\&}{ pt}}
-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.
+Moves the window to the given position.
-\wxheading{Remarks}
+\wxheading{Parameters}
-Derive your own class to handle this message. The default handler returns TRUE.
+\docparam{x}{Required x position.}
-\wxheading{See also}
+\docparam{y}{Required y position.}
-\helpref{Window deletion overview}{windowdeletionoverview},\rtfsp
-\helpref{wxWindow::Close}{wxwindowclose},\rtfsp
-\helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow},\rtfsp
-\helpref{wxCloseEvent}{wxcloseevent}
+\docparam{pt}{\helpref{wxPoint}{wxpoint} object representing the position.}
-\membersection{wxWindow::OnCloseWindow}\label{wxwindowonclosewindow}
+\wxheading{Remarks}
-\func{void}{OnCloseWindow}{\param{wxCloseEvent\& }{event}}
+Implementations of SetSize can also implicitly implement the
+wxWindow::Move function, which is defined in the base wxWindow class
+as the call:
-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.
+\begin{verbatim}
+ SetSize(x, y, -1, -1, wxSIZE_USE_EXISTING);
+\end{verbatim}
-Use the EVT\_CLOSE event table macro to handle close events.
+\wxheading{See also}
-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.
+\helpref{wxWindow::SetSize}{wxwindowsetsize}
-(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.)
+\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}}
+}
-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.
+%% 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 intercepts 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::OnMenuCommand}\label{wxwindowonmenucommand}
+%%
+%% \func{void}{OnMenuCommand}{\param{wxCommandEvent\& }{event}}
+%%
+%% Called when a menu command is received from a menu bar.
+%%
+%% \wxheading{Parameters}
+%%
+%% \docparam{event}{The menu command event. For more information, see \helpref{wxCommandEvent}{wxcommandevent}.}
+%%
+%% \wxheading{Remarks}
+%%
+%% 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.
+%%
+%% \wxheading{See also}
+%%
+%% \helpref{wxCommandEvent}{wxcommandevent},\rtfsp
+%% \helpref{wxWindow::OnMenuHighlight}{wxwindowonmenuhighlight},\rtfsp
+%% \helpref{Event handling overview}{eventhandlingoverview}
+%%
+%% \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{wxWindow::OnMenuCommand}{wxwindowonmenucommand},\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)$.
-\wxheading{Remarks}
-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.
+\membersection{wxWindow::PopEventHandler}\label{wxwindowpopeventhandler}
-\wxheading{See also}
+\constfunc{wxEvtHandler*}{PopEventHandler}{\param{bool }{deleteHandler = {\tt false}}}
-\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}
+Removes and returns the top-most event handler on the event handler stack.
-\membersection{wxWindow::OnDropFiles}\label{wxwindowondropfiles}
+\wxheading{Parameters}
-\func{void}{OnDropFiles}{\param{wxDropFilesEvent\&}{ event}}
+\docparam{deleteHandler}{If this is {\tt true}, the handler will be deleted after it is removed. The
+default value is {\tt false}.}
-Called when files have been dragged from the file manager to the window.
+\wxheading{See also}
-\wxheading{Parameters}
+\helpref{wxWindow::SetEventHandler}{wxwindowseteventhandler},\rtfsp
+\helpref{wxWindow::GetEventHandler}{wxwindowgeteventhandler},\rtfsp
+\helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler},\rtfsp
+\helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
+\helpref{wxEvtHandler}{wxevthandler}\rtfsp
-\docparam{event}{Drop files event. For more information, see \helpref{wxDropFilesEvent}{wxdropfilesevent}.}
-\wxheading{Remarks}
+\membersection{wxWindow::PopupMenu}\label{wxwindowpopupmenu}
-The window must have previously been enabled for dropping by calling
-\rtfsp\helpref{wxWindow::DragAcceptFiles}{wxwindowdragacceptfiles}.
+\func{bool}{PopupMenu}{\param{wxMenu* }{menu}, \param{const wxPoint\& }{pos = wxDefaultPosition}}
-This event is only generated under Windows.
+\func{bool}{PopupMenu}{\param{wxMenu* }{menu}, \param{int }{x}, \param{int }{y}}
-To intercept this event, use the EVT\_DROP\_FILES macro in an event table definition.
+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 corresponding menu event is generated and will be
+processed as usually. If the coordinates are not specified, current mouse
+cursor position is used.
-\wxheading{See also}
+\wxheading{Parameters}
-\helpref{wxDropFilesEvent}{wxdropfilesevent}, \helpref{wxWindow::DragAcceptFiles}{wxwindowdragacceptfiles},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\docparam{menu}{Menu to pop up.}
-\membersection{wxWindow::OnEraseBackground}\label{wxwindowonerasebackground}
+\docparam{pos}{The position where the menu will appear.}
-\func{void}{OnEraseBackground}{\param{wxEraseEvent\&}{ event}}
+\docparam{x}{Required x position for the menu to appear.}
-Called when the background of the window needs to be erased.
+\docparam{y}{Required y position for the menu to appear.}
-\wxheading{Parameters}
+\wxheading{See also}
-\docparam{event}{Erase background event. For more information, see \helpref{wxEraseEvent}{wxeraseevent}.}
+\helpref{wxMenu}{wxmenu}
\wxheading{Remarks}
-This event is only generated under Windows.
+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.
-To intercept this event, use the EVT\_ERASE\_BACKGROUND macro in an event table definition.
+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.
-\wxheading{See also}
+\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}}
+}
-\helpref{wxEraseEvent}{wxeraseevent}, \helpref{Event handling overview}{eventhandlingoverview}
-\membersection{wxWindow::OnKillFocus}\label{wxwindowonkillfocus}
+\membersection{wxWindow::PushEventHandler}\label{wxwindowpusheventhandler}
-\func{void}{OnKillFocus}{\param{wxFocusEvent\& }{event}}
+\func{void}{PushEventHandler}{\param{wxEvtHandler* }{handler}}
-Called when a window's focus is being killed.
+Pushes this event handler onto the event stack for the window.
\wxheading{Parameters}
-\docparam{event}{The focus event. For more information, see \helpref{wxFocusEvent}{wxfocusevent}.}
+\docparam{handler}{Specifies the handler to be pushed.}
\wxheading{Remarks}
-To intercept this event, use the macro EVT\_KILL\_FOCUS in an event table definition.
+An event handler is an object that is capable of processing the events
+sent to a window. By default, the window is its own event handler, but
+an application may wish to substitute another, for example to allow
+central implementation of event-handling for a variety of different
+window classes.
-Most, but not all, windows respond to this event.
+\helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler} allows
+an application to set up a chain of event handlers, where an event not handled by one event handler is
+handed to the next one in the chain. Use \helpref{wxWindow::PopEventHandler}{wxwindowpopeventhandler} to
+remove the event handler.
\wxheading{See also}
-\helpref{wxFocusEvent}{wxfocusevent}, \helpref{wxWindow::OnSetFocus}{wxwindowonsetfocus},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\helpref{wxWindow::SetEventHandler}{wxwindowseteventhandler},\rtfsp
+\helpref{wxWindow::GetEventHandler}{wxwindowgeteventhandler},\rtfsp
+\helpref{wxWindow::PopEventHandler}{wxwindowpusheventhandler},\rtfsp
+\helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
+\helpref{wxEvtHandler}{wxevthandler}
-\membersection{wxWindow::OnIdle}\label{wxwindowonidle}
-\func{void}{OnIdle}{\param{wxIdleEvent\& }{event}}
+\membersection{wxWindow::Raise}\label{wxwindowraise}
-Provide this member function for any processing which needs to be done
-when the application is idle.
+\func{void}{Raise}{\void}
-\wxheading{See also}
+Raises the window to the top of the window hierarchy if it is a managed window (dialog
+or frame).
-\helpref{wxApp::OnIdle}{wxapponidle}, \helpref{wxIdleEvent}{wxidleevent}
-\membersection{wxWindow::OnInitDialog}\label{wxwindowoninitdialog}
+\membersection{wxWindow::Refresh}\label{wxwindowrefresh}
-\func{void}{OnInitDialog}{\param{wxInitDialogEvent\&}{ event}}
+\func{virtual void}{Refresh}{\param{bool}{ eraseBackground = {\tt true}}, \param{const wxRect* }{rect
+= NULL}}
-Default handler for the wxEVT\_INIT\_DIALOG event. Calls \helpref{wxWindow::TransferDataToWindow}{wxwindowtransferdatatowindow}.
+Causes an event to be generated to repaint the
+window.
\wxheading{Parameters}
-\docparam{event}{Dialog initialisation event.}
-
-\wxheading{Remarks}
+\docparam{eraseBackground}{If {\tt true}, the background will be
+erased.}
-Gives the window the default behaviour of transferring data to child controls via
-the validator that each control has.
+\docparam{rect}{If non-NULL, only the given rectangle will
+be treated as damaged.}
\wxheading{See also}
-\helpref{wxValidator}{wxvalidator}, \helpref{wxWindow::TransferDataToWindow}{wxwindowtransferdatatowindow}
+\helpref{wxWindow::RefreshRect}{wxwindowrefreshrect}
-\membersection{wxWindow::OnMenuCommand}\label{wxwindowonmenucommand}
-\func{void}{OnMenuCommand}{\param{wxCommandEvent\& }{event}}
+\membersection{wxWindow::RefreshRect}\label{wxwindowrefreshrect}
-Called when a menu command is received from a menu bar.
+\func{void}{RefreshRect}{\param{const wxRect\& }{rect}}
-\wxheading{Parameters}
-
-\docparam{event}{The menu command event. For more information, see \helpref{wxCommandEvent}{wxcommandevent}.}
-
-\wxheading{Remarks}
+Redraws the contents of the given rectangle: the area inside it will be
+repainted.
-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.
+This is the same as \helpref{Refresh}{wxwindowrefresh} but has a nicer syntax.
-\wxheading{See also}
-
-\helpref{wxCommandEvent}{wxcommandevent},\rtfsp
-\helpref{wxWindow::OnMenuHighlight}{wxwindowonmenuhighlight},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
-\membersection{wxWindow::OnMenuHighlight}\label{wxwindowonmenuhighlight}
+\membersection{wxWindow::RegisterHotKey}\label{wxwindowregisterhotkey}
-\func{void}{OnMenuHighlight}{\param{wxMenuEvent\& }{event}}
+\func{bool}{RegisterHotKey}{\param{int}{ hotkeyId}, \param{int}{ modifiers}, \param{int}{ virtualKeyCode}}
-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.
+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{event}{The menu highlight event. For more information, see \helpref{wxMenuEvent}{wxmenuevent}.}
+\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.}
-\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.
+\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.}
-The default implementation for \helpref{wxFrame::OnMenuHighlight}{wxframeonmenuhighlight} displays help
-text in the first field of the status bar.
+\docparam{virtualKeyCode}{The virtual key code of the hotkey.}
-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{Return value}
-\wxheading{See also}
+{\tt true} if the hotkey was registered successfully. {\tt false} if some other application already registered a
+hotkey with this modifier/virtualKeyCode combination.
-\helpref{wxMenuEvent}{wxmenuevent},\rtfsp
-\helpref{wxWindow::OnMenuCommand}{wxwindowonmenucommand},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\wxheading{Remarks}
+Use EVT\_HOTKEY(hotkeyId, fnc) in the event table to capture the event.
+This function is currently only implemented under MSW.
-\membersection{wxWindow::OnMouseEvent}\label{wxwindowonmouseevent}
+\wxheading{See also}
-\func{void}{OnMouseEvent}{\param{wxMouseEvent\&}{ event}}
+\helpref{wxWindow::UnregisterHotKey}{wxwindowunregisterhotkey}
-Called when the user has initiated an event with the
-mouse.
-\wxheading{Parameters}
+\membersection{wxWindow::ReleaseMouse}\label{wxwindowreleasemouse}
-\docparam{event}{The mouse event. See \helpref{wxMouseEvent}{wxmouseevent} for
-more details.}
+\func{virtual void}{ReleaseMouse}{\void}
-\wxheading{Remarks}
+Releases mouse input captured with \helpref{wxWindow::CaptureMouse}{wxwindowcapturemouse}.
-Most, but not all, windows respond to this event.
+\wxheading{See also}
-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.
+\helpref{wxWindow::CaptureMouse}{wxwindowcapturemouse},
+\helpref{wxWindow::HasCapture}{wxwindowhascapture},
+\helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse},
+\helpref{wxMouseCaptureChangedEvent}{wxmousecapturechangedevent}
-\wxheading{See also}
-\helpref{wxMouseEvent}{wxmouseevent},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\membersection{wxWindow::RemoveChild}\label{wxwindowremovechild}
-\membersection{wxWindow::OnMove}\label{wxwindowonmove}
+\func{virtual void}{RemoveChild}{\param{wxWindow* }{child}}
-\func{void}{OnMove}{\param{wxMoveEvent\& }{event}}
+Removes a child window. This is called automatically by window deletion
+functions so should not be required by the application programmer.
-Called when a window is moved.
+Notice that this function is mostly internal to wxWidgets and shouldn't be
+called by the user code.
\wxheading{Parameters}
-\docparam{event}{The move event. For more information, see \helpref{wxMoveEvent}{wxmoveevent}.}
+\docparam{child}{Child window to remove.}
-\wxheading{Remarks}
-Use the EVT\_MOVE macro to intercept move events.
+\membersection{wxWindow::RemoveEventHandler}\label{wxwindowremoveeventhandler}
-\wxheading{Remarks}
+\func{bool}{RemoveEventHandler}{\param{wxEvtHandler *}{handler}}
-Not currently implemented.
+Find the given {\it handler} in the windows event handler chain and remove (but
+not delete) it from it.
-\wxheading{See also}
+\wxheading{Parameters}
-\helpref{wxMoveEvent}{wxmoveevent},\rtfsp
-\helpref{wxFrame::OnSize}{wxframeonsize},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\docparam{handler}{The event handler to remove, must be non {\tt NULL} and
+must be present in this windows event handlers chain}
-\membersection{wxWindow::OnPaint}\label{wxwindowonpaint}
+\wxheading{Return value}
-\func{void}{OnPaint}{\param{wxPaintEvent\& }{event}}
+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).
-Sent to the event handler when the window must be refreshed.
+\wxheading{See also}
-\wxheading{Parameters}
+\helpref{PushEventHandler}{wxwindowpusheventhandler},\rtfsp
+\helpref{PopEventHandler}{wxwindowpopeventhandler}
-\docparam{event}{Paint event. For more information, see \helpref{wxPaintEvent}{wxpaintevent}.}
-\wxheading{Remarks}
+\membersection{wxWindow::Reparent}\label{wxwindowreparent}
-Use the EVT\_PAINT macro in an event table definition to intercept paint events.
+\func{virtual bool}{Reparent}{\param{wxWindow* }{newParent}}
-In a paint event handler, the application should always create a \helpref{wxPaintDC}{wxpaintdc} object.
+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. Available on Windows and GTK.
-For example:
+\wxheading{Parameters}
-\small{%
-\begin{verbatim}
- void MyWindow::OnPaint(wxPaintEvent& event)
- {
- wxPaintDC dc(this);
+\docparam{newParent}{New parent.}
- 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.
+\membersection{wxWindow::ScreenToClient}\label{wxwindowscreentoclient}
-Here is an example of using the \helpref{wxRegionIterator}{wxregioniterator} class:
+\constfunc{virtual void}{ScreenToClient}{\param{int* }{x}, \param{int* }{y}}
-{\small%
-\begin{verbatim}
-// Called when window needs to be repainted.
-void MyWindow::OnPaint(wxPaintEvent& event)
-{
- wxPaintDC dc(this);
+\constfunc{virtual wxPoint}{ScreenToClient}{\param{const wxPoint\& }{pt}}
- // Find Out where the window is scrolled to
- int vbX,vbY; // Top left corner of client
- ViewStart(&vbX,&vbY);
+Converts from screen to client window coordinates.
- int vX,vY,vW,vH; // Dimensions of client area in pixels
- wxRegionIterator upd(GetUpdateRegion()); // get the update rect list
+\wxheading{Parameters}
- while (upd)
- {
- vX = upd.GetX();
- vY = upd.GetY();
- vW = upd.GetW();
- vH = upd.GetH();
+\docparam{x}{Stores the screen x coordinate and receives the client x coordinate.}
- // Alternatively we can do this:
- // wxRect rect;
- // upd.GetRect(&rect);
+\docparam{y}{Stores the screen x coordinate and receives the client x coordinate.}
- // Repaint this rectangle
- ...some code...
+\docparam{pt}{The screen position for the second form of the function.}
- upd ++ ;
- }
+\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)}
+\end{twocollist}}
}
-\end{verbatim}
-}%
-\wxheading{See also}
-\helpref{wxPaintEvent}{wxpaintevent},\rtfsp
-\helpref{wxPaintDC}{wxpaintdc},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\membersection{wxWindow::ScrollLines}\label{wxwindowscrolllines}
-\func{void}{OnScroll}{\param{wxScrollEvent\& }{event}}
+\func{virtual bool}{ScrollLines}{\param{int }{lines}}
-Called when a scroll event is received from one of the window's built-in scrollbars.
+Scrolls the window by the given number of lines down (if {\it lines} is
+positive) or up.
-\wxheading{Parameters}
+\wxheading{Return value}
-\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}.}
+Returns {\tt true} if the window was scrolled, {\tt false} if it was already
+on top/bottom and nothing was done.
\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).
+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{wxScrollEvent}{wxscrollevent},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\helpref{ScrollPages}{wxwindowscrollpages}
-\membersection{wxWindow::OnSetFocus}\label{wxwindowonsetfocus}
-\func{void}{OnSetFocus}{\param{wxFocusEvent\& }{event}}
+\membersection{wxWindow::ScrollPages}\label{wxwindowscrollpages}
-Called when a window's focus is being set.
+\func{virtual bool}{ScrollPages}{\param{int }{pages}}
-\wxheading{Parameters}
+Scrolls the window by the given number of pages down (if {\it pages} is
+positive) or up.
-\docparam{event}{The focus event. For more information, see \helpref{wxFocusEvent}{wxfocusevent}.}
+\wxheading{Return value}
-\wxheading{Remarks}
+Returns {\tt true} if the window was scrolled, {\tt false} if it was already
+on top/bottom and nothing was done.
-To intercept this event, use the macro EVT\_SET\_FOCUS in an event table definition.
+\wxheading{Remarks}
-Most, but not all, windows respond to this event.
+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{wxFocusEvent}{wxfocusevent}, \helpref{wxWindow::OnKillFocus}{wxwindowonkillfocus},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\helpref{ScrollLines}{wxwindowscrolllines}
+
-\membersection{wxWindow::OnSize}\label{wxwindowonsize}
+\membersection{wxWindow::ScrollWindow}\label{wxwindowscrollwindow}
-\func{void}{OnSize}{\param{wxSizeEvent\& }{event}}
+\func{virtual void}{ScrollWindow}{\param{int }{dx}, \param{int }{dy}, \param{const wxRect*}{ rect = NULL}}
-Called when the window has been resized.
+Physically scrolls the pixels in the window and move child windows accordingly.
\wxheading{Parameters}
-\docparam{event}{Size event. For more information, see \helpref{wxSizeEvent}{wxsizeevent}.}
+\docparam{dx}{Amount to scroll horizontally.}
+
+\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 optimize painting by checking for the invalidated region. This parameter is ignored under GTK.}
\wxheading{Remarks}
-You may wish to use this for frames to resize their child windows as appropriate.
+Use this function to optimise your scrolling implementations, to minimise the area that must be
+redrawn. Note that it is rarely required to call this function from a user program.
-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.
-\wxheading{See also}
+\membersection{wxWindow::SetAcceleratorTable}\label{wxwindowsetacceleratortable}
-\helpref{wxSizeEvent}{wxsizeevent},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
+\func{virtual void}{SetAcceleratorTable}{\param{const wxAcceleratorTable\&}{ accel}}
-\membersection{wxWindow::OnSysColourChanged}\label{wxwindowonsyscolourchanged}
+Sets the accelerator table for this window. See \helpref{wxAcceleratorTable}{wxacceleratortable}.
-\func{void}{OnSysColourChanged}{\param{wxOnSysColourChangedEvent\& }{event}}
-Called when the user has changed the system colours.
+\membersection{wxWindow::SetAccessible}\label{wxwindowsetaccessible}
-\wxheading{Parameters}
+\func{void}{SetAccessible}{\param{wxAccessibile*}{ accessible}}
-\docparam{event}{System colour change event. For more information, see \helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent}.}
+Sets the accessible for this window. Any existing accessible for this window
+will be deleted first, if not identical to {\it accessible}.
-\wxheading{See also}
+See also \helpref{wxAccessible}{wxaccessible}.
-\helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
-\membersection{wxWindow::PopEventHandler}\label{wxwindowpopeventhandler}
+\membersection{wxWindow::SetAutoLayout}\label{wxwindowsetautolayout}
-\constfunc{wxEvtHandler*}{PopEventHandler}{\param{bool }{deleteHandler = FALSE}}
+\func{void}{SetAutoLayout}{\param{bool}{ autoLayout}}
-Removes and returns the top-most event handler on the event handler stack.
+Determines whether the \helpref{wxWindow::Layout}{wxwindowlayout} function will
+be called automatically when the window is resized. It 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{deleteHandler}{If this is TRUE, the handler will be deleted after it is removed. The
-default value is FALSE.}
+\docparam{autoLayout}{Set this to {\tt true} if you wish the Layout function to be called
+from within wxWindow::OnSize functions.}
\wxheading{See also}
-\helpref{wxWindow::SetEventHandler}{wxwindowseteventhandler},\rtfsp
-\helpref{wxWindow::GetEventHandler}{wxwindowgeteventhandler},\rtfsp
-\helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler},\rtfsp
-\helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
-\helpref{wxEvtHandler}{wxevthandler}\rtfsp
+\helpref{wxWindow::SetConstraints}{wxwindowsetconstraints}
-\membersection{wxWindow::PopupMenu}\label{wxwindowpopupmenu}
-\func{virtual bool}{PopupMenu}{\param{wxMenu* }{menu}, \param{int }{x}, \param{int }{y}}
+\membersection{wxWindow::SetBackgroundColour}\label{wxwindowsetbackgroundcolour}
-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.
+\func{virtual void}{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{SetDefaultBackgroundColour}{wxwindowsetdefaultbackgroundcolour}.
\wxheading{Parameters}
-\docparam{menu}{Menu to pop up.}
+\docparam{colour}{The colour to be used as the background colour.}
-\docparam{x}{Required x position for the menu to appear.}
+\wxheading{Remarks}
-\docparam{y}{Required y position for the menu to appear.}
+The background colour is usually painted by the default\rtfsp
+\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::ClearBackground}{wxwindowclearbackground} or \helpref{wxWindow::Refresh}{wxwindowrefresh} after
+calling this function.
+
+Use this function with care under GTK+ as the new appearance of the window might
+not look equally well when used with "Themes", i.e GTK+'s ability to change its
+look as the user wishes with run-time loadable modules.
\wxheading{See also}
-\helpref{wxMenu}{wxmenu}, \helpref{wxWindow::FakePopupMenu}{wxwindowfakepopupmenu}
+\helpref{wxWindow::GetBackgroundColour}{wxwindowgetbackgroundcolour},\rtfsp
+\helpref{wxWindow::SetForegroundColour}{wxwindowsetforegroundcolour},\rtfsp
+\helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour},\rtfsp
+\helpref{wxWindow::ClearBackground}{wxwindowclearbackground},\rtfsp
+\helpref{wxWindow::Refresh}{wxwindowrefresh},\rtfsp
+\helpref{wxEraseEvent}{wxeraseevent}
-\membersection{wxWindow::PushEventHandler}\label{wxwindowpusheventhandler}
-\func{void}{PushEventHandler}{\param{wxEvtHandler* }{handler}}
+\membersection{wxWindow::SetCaret}\label{wxwindowsetcaret}
-Pushes this event handler onto the event stack for the window.
+\constfunc{void}{SetCaret}{\param{wxCaret *}{caret}}
-\wxheading{Parameters}
+Sets the \helpref{caret}{wxcaret} associated with the window.
-\docparam{handler}{Specifies the handler to be pushed.}
-\wxheading{Remarks}
+\membersection{wxWindow::SetClientSize}\label{wxwindowsetclientsize}
-An event handler is an object that is capable of processing the events
-sent to a window. By default, the window is its own event handler, but
-an application may wish to substitute another, for example to allow
-central implementation of event-handling for a variety of different
-window classes.
+\func{virtual void}{SetClientSize}{\param{int}{ width}, \param{int}{ height}}
-\helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler} allows
-an application to set up a chain of event handlers, where an event not handled by one event handler is
-handed to the next one in the chain. Use \helpref{wxWindow::PopEventHandler}{wxwindowpopeventhandler} to
-remove the event handler.
+\func{virtual void}{SetClientSize}{\param{const wxSize\&}{ size}}
-\wxheading{See also}
+This sets the size of the window client area in pixels. Using this function to size a window
+tends to be more device-independent than \helpref{wxWindow::SetSize}{wxwindowsetsize}, since the application need not
+worry about what dimensions the border or title bar have when trying to fit the window
+around panel items, for example.
-\helpref{wxWindow::SetEventHandler}{wxwindowseteventhandler},\rtfsp
-\helpref{wxWindow::GetEventHandler}{wxwindowgeteventhandler},\rtfsp
-\helpref{wxWindow::PopEventHandler}{wxwindowpusheventhandler},\rtfsp
-\helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
-\helpref{wxEvtHandler}{wxevthandler}
+\wxheading{Parameters}
-\membersection{wxWindow::Raise}\label{wxwindowraise}
+\docparam{width}{The required client area width.}
-\func{void}{Raise}{\void}
+\docparam{height}{The required client area height.}
-Raises the window to the top of the window hierarchy if it is a managed window (dialog
-or frame).
+\docparam{size}{The required client size.}
-\membersection{wxWindow::Refresh}\label{wxwindowrefresh}
+\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)}}{}
+\end{twocollist}}
+}
-\func{virtual void}{Refresh}{\param{const bool}{ eraseBackground = TRUE}, \param{const wxRect* }{rect
-= NULL}}
-Causes a message or event to be generated to repaint the
-window.
+\membersection{wxWindow::SetContainingSizer}\label{wxwindowsetcontainingsizer}
-\wxheading{Parameters}
+\func{void}{SetContainingSizer}{\param{wxSizer* }{sizer}}
-\docparam{eraseBackground}{If TRUE, the background will be
-erased.}
+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.
-\docparam{rect}{If non-NULL, only the given rectangle will
-be treated as damaged.}
-\membersection{wxWindow::ReleaseMouse}\label{wxwindowreleasemouse}
+\membersection{wxWindow::SetCursor}\label{wxwindowsetcursor}
-\func{virtual void}{ReleaseMouse}{\void}
+\func{virtual void}{SetCursor}{\param{const wxCursor\&}{cursor}}
-Releases mouse input captured with \helpref{wxWindow::CaptureMouse}{wxwindowcapturemouse}.
+% 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{wxWindow::CaptureMouse}{wxwindowcapturemouse}
+\helpref{::wxSetCursor}{wxsetcursor}, \helpref{wxCursor}{wxcursor}
-\membersection{wxWindow::RemoveChild}\label{wxwindowremovechild}
-\func{virtual void}{RemoveChild}{\param{wxWindow* }{child}}
+\membersection{wxWindow::SetConstraints}\label{wxwindowsetconstraints}
-Removes a child window. This is called automatically by window deletion
-functions so should not be required by the application programmer.
+\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{child}{Child window to remove.}
+\docparam{constraints}{The constraints to set. Pass NULL to disassociate and delete the window's
+constraints.}
-\membersection{wxWindow::ScreenToClient}\label{wxwindowscreentoclient}
+\wxheading{Remarks}
-\constfunc{virtual void}{ScreenToClient}{\param{int* }{x}, \param{int* }{y}}
+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.
-\constfunc{virtual wxPoint}{ScreenToClient}{\param{const wxPoint\& }{pt}}
-Converts from screen to client window coordinates.
+\membersection{wxWindow::SetDefaultBackgroundColour}\label{wxwindowsetdefaultbackgroundcolour}
-\wxheading{Parameters}
+\func{void}{SetDefaultBackgroundColour}{\param{const wxColour\& }{colour}}
-\docparam{x}{Stores the screen x coordinate and receives the client x coordinate.}
+Sets the background colour of the window but prevents it from being inherited
+by the children of this window.
-\docparam{y}{Stores the screen x coordinate and receives the client x coordinate.}
+\wxheading{See also}
-\docparam{pt}{The screen position for the second form of the function.}
+\helpref{SetBackgroundColour}{wxwindowsetbackgroundcolour},\rtfsp
+\helpref{InheritAttributes}{wxwindowinheritattributes}
-\membersection{wxWindow::ScrollWindow}\label{wxwindowscrollwindow}
-\func{virtual void}{ScrollWindow}{\param{int }{dx}, \param{int }{dy}, \param{const wxRect*}{ rect = NULL}}
+\membersection{wxWindow::SetDefaultFont}\label{wxwindowsetdefaultfont}
-Physically scrolls the pixels in the window.
+\func{void}{SetDefaultBackgroundColour}{\param{const wxColour\& }{colour}}
-\wxheading{Parameters}
+Sets the font of the window but prevents it from being inherited by the
+children of this window.
-\docparam{dx}{Amount to scroll horizontally.}
+\wxheading{See also}
-\docparam{dy}{Amount to scroll vertically.}
+\helpref{SetFont}{wxwindowsetfont},\rtfsp
+\helpref{InheritAttributes}{wxwindowinheritattributes}
-\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.}
-\wxheading{Remarks}
+\membersection{wxWindow::SetDefaultForegroundColour}\label{wxwindowsetdefaultforegroundcolour}
-Available only under Windows.
+\func{void}{SetDefaultForegroundColour}{\param{const wxColour\& }{colour}}
-Use this function to optimise your scrolling implementations, to minimise the area that must be
-redrawn.
+Sets the foreground colour of the window but prevents it from being inherited
+by the children of this window.
-\membersection{wxWindow::SetAcceleratorTable}\label{wxwindowsetacceleratortable}
+\wxheading{See also}
-\func{virtual void}{SetAcceleratorTable}{\param{const wxAcceleratorTable\&}{ accel}}
+\helpref{SetForegroundColour}{wxwindowsetforegroundcolour},\rtfsp
+\helpref{InheritAttributes}{wxwindowinheritattributes}
-Sets the accelerator table for this window. See \helpref{wxAcceleratorTable}{wxacceleratortable}.
-\membersection{wxWindow::SetAutoLayout}\label{wxwindowsetautolayout}
+\membersection{wxWindow::SetDropTarget}\label{wxwindowsetdroptarget}
+
+\func{void}{SetDropTarget}{\param{wxDropTarget*}{ target}}
-\func{void}{SetAutoLayout}{\param{const bool}{ autoLayout}}
+Associates a drop target with this window.
-Determines whether the \helpref{wxWindow::Layout}{wxwindowlayout} function will
-be called automatically when the window is resized.
+If the window already has a drop target, it is deleted.
-\wxheading{Parameters}
+\wxheading{See also}
-\docparam{autoLayout}{Set this to TRUE if you wish the Layout function to be called
-from within wxWindow::OnSize functions.}
+\helpref{wxWindow::GetDropTarget}{wxwindowgetdroptarget},
+\helpref{Drag and drop overview}{wxdndoverview}
-\wxheading{See also}
-\helpref{wxWindow::SetConstraints}{wxwindowsetconstraints}
-\membersection{wxWindow::SetBackgroundColour}\label{wxwindowsetbackgroundcolour}
+\membersection{wxWindow::SetEventHandler}\label{wxwindowseteventhandler}
-\func{virtual void}{SetBackgroundColour}{\param{const wxColour\& }{colour}}
+\func{void}{SetEventHandler}{\param{wxEvtHandler* }{handler}}
-Sets the background colour of the window.
+Sets the event handler for this window.
\wxheading{Parameters}
-\docparam{colour}{The colour to be used as the background colour.}
+\docparam{handler}{Specifies the handler to be set.}
\wxheading{Remarks}
-The background colour is usually painted by the default\rtfsp
-\helpref{wxWindow::OnEraseBackground}{wxwindowonerasebackground} event handler function.
+An event handler is an object that is capable of processing the events
+sent to a window. By default, the window is its own event handler, but
+an application may wish to substitute another, for example to allow
+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.
\wxheading{See also}
-\helpref{wxWindow::GetBackgroundColour}{wxwindowgetbackgroundcolour},\rtfsp
-\helpref{wxWindow::SetForegroundColour}{wxwindowsetforegroundcolour},\rtfsp
-\helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour},\rtfsp
-\helpref{wxWindow::OnEraseBackground}{wxwindowonerasebackground}
+\helpref{wxWindow::GetEventHandler}{wxwindowgeteventhandler},\rtfsp
+\helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler},\rtfsp
+\helpref{wxWindow::PopEventHandler}{wxwindowpusheventhandler},\rtfsp
+\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{wxFRAME\_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
+you should use the style of
+{\tt wxDEFAULT\_FRAME\_STYLE \& \textasciitilde(wxMINIMIZE\_BOX | wxMAXIMIZE\_BOX)} for the
+frames having this style (the dialogs don't have minimize nor maximize box by
+default)}
+\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}
-\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}}
-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{SetDefaultFont}{wxwindowsetdefaultfont} instead in this case and
+see \helpref{InheritAttributes}{wxwindowinheritattributes} for more
+explanations.
\wxheading{Parameters}
\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{SetDefaultForegroundColour}{wxwindowsetdefaultforegroundcolour}.
+
\wxheading{Parameters}
\docparam{colour}{The colour to be used as the foreground colour.}
to the window class; it may be the text colour or other colour, or it may not
be used at all.
+Note that when using this functions under GTK, you will disable the so called "themes",
+i.e. the user chosen appearance of windows and controls, including the themes of
+their parent windows.
+
\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}
an identifier will be generated. Normally, the identifier should be provided
on creation and should not be modified subsequently.
-TODO: perhaps there should be a default identifier for each class, rather
-choosing one, which could clash with other ones.
-
\wxheading{See also}
-\helpref{wxWindow::GetId}{wxwindowgetid}
+\helpref{wxWindow::GetId}{wxwindowgetid},\rtfsp
+\helpref{Window identifiers}{windowids}
+
\membersection{wxWindow::SetName}\label{wxwindowsetname}
\helpref{wxWindow::GetName}{wxwindowgetname}
-\membersection{wxWindow::SetReturnCode}\label{wxwindowsetreturncode}
-
-\func{void}{SetReturnCode}{\param{int }{retCode}}
-
-Sets the return code for this window.
-\wxheading{Parameters}
-
-\docparam{retCode}{The integer return code, usually a control identifier.}
-
-\wxheading{Remarks}
+\membersection{wxWindow::SetPalette}\label{wxwindowsetpalette}
-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}.
+\func{virtual void}{SetPalette}{\param{wxPalette* }{palette}}
-\wxheading{See also}
+Obsolete - use \helpref{wxDC::SetPalette}{wxdcsetpalette} instead.
-\helpref{wxWindow::GetReturnCode}{wxwindowgetreturncode}, \helpref{wxDialog::ShowModal}{wxdialogshowmodal},\rtfsp
-\helpref{wxDialog::EndModal}{wxdialogendmodal}
\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{wxScrollBar}{wxscrollbar}, \helpref{wxScrolledWindow}{wxscrolledwindow}
\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}
\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}
\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{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},
\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.\\
+a wxWidgets-supplied default width.\\
{\bf wxSIZE\_AUTO\_HEIGHT}: a -1 height value is taken to indicate
-a wxWindows-supplied default width.\\
+a wxWidgets-supplied default width.\\
{\bf wxSIZE\_AUTO}: -1 size values are taken to indicate
-a wxWindows-supplied default size.\\
+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
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.
+by wxWidgets, or that the current value of the dimension should be used.
\wxheading{See also}
\helpref{wxWindow::Move}{wxwindowmove}
+\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)}}{}
+\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}}
+\func{void}{SetSizeHints}{\param{const wxSize\&}{ minSize},
+\param{const wxSize\&}{ maxSize=wxDefaultSize}, \param{const wxSize\&}{ incSize=wxDefaultSize}}
+
+
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.
\docparam{incH}{Specifies the increment for sizing the height (Motif/Xt only).}
+\docparam{minSize}{Minimum size.}
+
+\docparam{maxSize}{Maximum size.}
+
+\docparam{incSize}{Increment size (Motif/Xt only).}
+
\wxheading{Remarks}
If this function is called, the user will not be able to size the window outside the
The resizing increments are only significant under Motif or Xt.
-\membersection{wxWindow::SetClientSize}
-\func{virtual void}{SetClientSize}{\param{int}{ width}, \param{int}{ height}}
+\membersection{wxWindow::SetSizer}\label{wxwindowsetsizer}
-\func{virtual void}{SetClientSize}{\param{const wxSize\&}{ size}}
+\func{void}{SetSizer}{\param{wxSizer* }{sizer}, \param{bool }{deleteOld=true}}
-This sets the size of the window client area in pixels. Using this function to size a window
-tends to be more device-independent than \helpref{wxWindow::SetSize}{wxwindowsetsize}, since the application need not
-worry about what dimensions the border or title bar have when trying to fit the window
-around panel items, for example.
+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{width}{The required client area width.}
+\docparam{sizer}{The sizer to set. Pass NULL to disassociate and conditionally delete
+the window's sizer. See below.}
-\docparam{height}{The required client area height.}
+\docparam{deleteOld}{If true (the default), this will delete any prexisting sizer.
+Pass false if you wish to handle deleting the old sizer yourself.}
-\docparam{size}{The required client size.}
+\wxheading{Remarks}
-\membersection{wxWindow::SetPalette}
+SetSizer now enables and disables Layout automatically, but prior to wxWidgets 2.3.3
+the following applied:
-\func{virtual void}{SetPalette}{\param{wxPalette* }{palette}}
+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.
-Obsolete - use \helpref{wxDC::SetPalette}{wxdcsetpalette} instead.
-\membersection{wxWindow::SetCursor}\label{wxwindowsetcursor}
+\membersection{wxWindow::SetSizerAndFit}\label{wxwindowsetsizerandfit}
-\func{virtual void}{SetCursor}{\param{const wxCursor\&}{cursor}}
+\func{void}{SetSizerAndFit}{\param{wxSizer* }{sizer}, \param{bool }{deleteOld=true}}
-Sets the window's cursor.
+The same as \helpref{SetSizer}{wxwindowsetsizer}, except it also sets the size hints
+for the window based on the sizer's minimum size.
-\wxheading{Parameters}
-\docparam{cursor}{Specifies the cursor that the window should normally display.}
+\membersection{wxWindow::SetTitle}\label{wxwindowsettitle}
-\wxheading{Remarks}
+\func{virtual void}{SetTitle}{\param{const wxString\& }{title}}
+
+Sets the window's title. Applicable only to frames and dialogs.
+
+\wxheading{Parameters}
-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.
+\docparam{title}{The window's title.}
\wxheading{See also}
-\helpref{::wxSetCursor}{wxsetcursor}, \helpref{wxCursor}{wxcursor}
+\helpref{wxWindow::GetTitle}{wxwindowgettitle}
-\membersection{wxWindow::SetEventHandler}\label{wxwindowseteventhandler}
-\func{void}{SetEventHandler}{\param{wxEvtHandler* }{handler}}
+\membersection{wxWindow::SetThemeEnabled}\label{wxwindowsetthemeenabled}
-Sets the event handler for this window.
+\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}
+
+\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{handler}{Specifies the handler to be set.}
+\docparam{minW}{Specifies the minimum width allowable.}
+
+\docparam{minH}{Specifies the minimum height allowable.}
+
+\docparam{maxW}{Specifies the maximum width allowable.}
+
+\docparam{maxH}{Specifies the maximum height allowable.}
+
+\docparam{minSize}{Minimum size.}
+
+\docparam{maxSize}{Maximum size.}
\wxheading{Remarks}
-An event handler is an object that is capable of processing the events
-sent to a window. By default, the window is its own event handler, but
-an application may wish to substitute another, for example to allow
-central implementation of event-handling for a variety of different
-window classes.
+If this function is called, the user will not be able to size the virtual area
+of the window outside the given bounds.
-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}
+\membersection{wxWindow::SetWindowStyle}\label{wxwindowsetwindowstyle}
-\helpref{wxWindow::GetEventHandler}{wxwindowgeteventhandler},\rtfsp
-\helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler},\rtfsp
-\helpref{wxWindow::PopEventHandler}{wxwindowpusheventhandler},\rtfsp
-\helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
-\helpref{wxEvtHandler}{wxevthandler}
+\func{void}{SetWindowStyle}{\param{long}{ style}}
-\membersection{wxWindow::SetTitle}\label{wxwindowsettitle}
+Identical to \helpref{SetWindowStyleFlag}{wxwindowsetwindowstyleflag}.
-\func{virtual void}{SetTitle}{\param{const wxString\& }{title}}
-Sets the window's title. Applicable only to frames and dialogs.
+\membersection{wxWindow::SetWindowStyleFlag}\label{wxwindowsetwindowstyleflag}
-\wxheading{Parameters}
+\func{virtual void}{SetWindowStyleFlag}{\param{long}{ style}}
-\docparam{title}{The window's title.}
+Sets the style of the window. Please note that some styles cannot be changed
+after the window creation and that \helpref{Refresh()}{wxwindowrefresh} might
+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 correpond 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}
+
+
+\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}.
+
+
\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
+while this would usually only happen when the flow of control returns to the
+event loop. Notice that this function doesn't refresh the window and does
+nothing if the window hadn't been already repainted. 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{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