\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. Any children of the window will be deleted
+automatically by the destructor before the window itself is deleted.
+
+Please note that we documented a number of handler functions (OnChar(), OnMouse() etc.) in this
+help text. These must not be called by a user program and are documented only for illustration.
+On several platforms, only a few of these handlers are actually written (they are not always
+needed) and if you are uncertain on how to add a certain behaviour to a window class, intercept
+the respective event as usual and call \helpref{wxEvent::Skip}{wxeventskip} so that the native
+platform can implement its native behaviour or just ignore the event if nothing needs to be
+done.
\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.}
+for this style. }
\twocolitem{\windowstyle{wxDOUBLE\_BORDER}}{Displays a double border. Windows only.}
\twocolitem{\windowstyle{wxSUNKEN\_BORDER}}{Displays a sunken border.}
-\twocolitem{\windowstyle{wxRAISED\_BORDER}}{Displays a raised border.}
-\twocolitem{\windowstyle{wxSTATIC\_BORDER}}{Displays a border suitable for a static control.}
+\twocolitem{\windowstyle{wxRAISED\_BORDER}}{Displays a raised border. GTK only. }
+\twocolitem{\windowstyle{wxSTATIC\_BORDER}}{Displays a border suitable for a static control. Windows only. }
\twocolitem{\windowstyle{wxTRANSPARENT\_WINDOW}}{The window is transparent, that is, it will not receive paint
events. Windows only.}
\twocolitem{\windowstyle{wxNO\_3D}}{Prevents the children of this window taking on 3D styles, even though
the application-wide policy is for 3D controls. Windows only.}
\twocolitem{\windowstyle{wxTAB\_TRAVERSAL}}{Use this to enable tab traversal for non-dialog windows.}
-\twocolitem{\windowstyle{wxVSCROLL}}{Use this style to enable a vertical scrollbar.}
-\twocolitem{\windowstyle{wxHSCROLL}}{Use this style to enable a horizontal scrollbar.}
+\twocolitem{\windowstyle{wxWANTS\_CHARS}}{Use this to indicate that the window
+wants to get all char events - even for keys like TAB or ENTER which are
+usually used for dialog navigation and which wouldn't be generated without
+this style}
+\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. (Still used?) }
+\twocolitem{\windowstyle{wxHSCROLL}}{Use this style to enable a horizontal scrollbar. (Still used?) }
\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.}
\end{twocollist}
See also \helpref{window styles overview}{windowstyles}.
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxWindow::wxWindow}
+\membersection{wxWindow::wxWindow}\label{wxwindowctor}
\func{}{wxWindow}{\void}
an actual position.}
\docparam{size}{Window size. wxDefaultSize is (-1, -1) which indicates that wxWindows
-should generate a default size for the window.}
+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}.}
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::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::Clear}\label{wxwindowclear}
\func{void}{Clear}{\void}
\constfunc{virtual void}{ClientToScreen}{\param{int* }{x}, \param{int* }{y}}
+\perlnote{In wxPerl this method returns a 2-element list intead 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{virtual bool}{Close}{\param{bool}{ force = FALSE}}
The purpose of this call is to provide a safer way of destroying a window than using
the {\it delete} operator.
Applies to managed windows (wxFrame and wxDialog classes) only.
+{\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
+itself only hides the dialog.
+
+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::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}}
\helpref{wxWindow::ConvertDialogToPixels}{wxwindowconvertdialogtopixels}
+
+\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}}
+}
+
\membersection{wxWindow::Destroy}\label{wxwindowdestroy}
\func{virtual bool}{Destroy}{\void}
Destroys all children of a window. Called automatically by the destructor.
+\membersection{wxWindow::Disable}\label{wxwindowdisable}
+
+\func{void}{Disable}{\void}
+
+Disables the window, same as \helpref{Enable(FALSE)}{wxwindowenable}.
+
\membersection{wxWindow::DragAcceptFiles}\label{wxwindowdragacceptfiles}
-\func{virtual void}{DragAcceptFiles}{\param{const bool}{ accept}}
+\func{virtual void}{DragAcceptFiles}{\param{bool}{ accept}}
Enables or disables elibility for drop file events (OnDropFiles).
\membersection{wxWindow::Enable}\label{wxwindowenable}
-\func{virtual void}{Enable}{\param{const bool}{ enable}}
+\func{virtual void}{Enable}{\param{bool}{ enable = TRUE}}
Enable or disable the window for user input.
\wxheading{See also}
-\helpref{wxWindow::IsEnabled}{wxwindowisenabled}
+\helpref{wxWindow::IsEnabled}{wxwindowisenabled},\rtfsp
+\helpref{wxWindow::Disable}{wxwindowdisable}
\membersection{wxWindow::FindFocus}\label{wxwindowfindfocus}
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::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.
+
+\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.
+
+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 wxWindows and not a mandatory
+directive.
\membersection{wxWindow::GetBackgroundColour}\label{wxwindowgetbackgroundcolour}
\helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour},\rtfsp
\helpref{wxWindow::OnEraseBackground}{wxwindowonerasebackground}
+\membersection{wxWindow::GetBestSize}\label{wxwindowgetbestsize}
+
+\constfunc{virtual 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::GetCharHeight}
\constfunc{virtual int}{GetCharHeight}{\void}
\constfunc{virtual 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}
This gets the size of the window `client area' in pixels. The client area is the
\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}}
+}
+
\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}
-
-Returns a pointer to the button which is the default for this window, or NULL.
-
\membersection{wxWindow::GetDropTarget}\label{wxwindowgetdroptarget}
\constfunc{wxDropTarget*}{GetDropTarget}{\void}
\wxheading{See also}
-\helpref{wxWindow::SetDropTarget}{wxwindowsetdroptarget},
+\helpref{wxWindow::SetDropTarget}{wxwindowsetdroptarget},
\helpref{Drag and drop overview}{wxdndoverview}
\membersection{wxWindow::GetEventHandler}\label{wxwindowgeteventhandler}
\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}
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}
+\membersection{wxWindow::GetHelpText}\label{wxwindowgethelptext}
-Returns the identifier of the window.
+\constfunc{virtual wxString}{GetHelpText}{\void}
-\wxheading{Remarks}
+Gets the help text to be used as context-sensitive help for this window.
-Each window has an integer identifier. If the application has not provided one,
-an identifier will be generated.
+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}\rtfsp
-\helpref{Window identifiers}{windowids}
+\helpref{SetHelpText}{wxwindowsethelptext}, \helpref{wxHelpProvider}{wxhelpprovider}
-\membersection{wxWindow::GetPosition}
+\membersection{wxWindow::GetId}\label{wxwindowgetid}
-\constfunc{virtual void}{GetPosition}{\param{int* }{x}, \param{int* }{y}}
+\constfunc{int}{GetId}{\void}
-This gets the position of the window in pixels, relative to the parent window or
-if no parent, relative to the whole display.
+Returns the identifier of the window.
-\wxheading{Parameters}
+\wxheading{Remarks}
-\docparam{x}{Receives the x position of the window.}
+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.
-\docparam{y}{Receives the y position of the window.}
+\wxheading{See also}
+
+\helpref{wxWindow::SetId}{wxwindowsetid},\rtfsp
+\helpref{Window identifiers}{windowids}
\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.
\membersection{wxWindow::GetName}\label{wxwindowgetname}
-\constfunc{virtual wxString\& }{GetName}{\void}
+\constfunc{virtual wxString }{GetName}{\void}
Returns the window's name.
Returns the parent of the window, or NULL if there is no parent.
-\membersection{wxWindow::GetRect}\label{wxwindowgetrect}
+\membersection{wxWindow::GetPosition}\label{wxwindowgetposition}
-\constfunc{virtual wxRect}{GetRect}{\void}
+\constfunc{virtual void}{GetPosition}{\param{int* }{x}, \param{int* }{y}}
-Returns the size and position of the window as a \helpref{wxRect}{wxrect} object.
+\constfunc{wxPoint}{GetPosition}{\void}
-\membersection{wxWindow::GetReturnCode}\label{wxwindowgetreturncode}
+This gets the position of the window in pixels, relative to the parent window or
+if no parent, relative to the whole display.
-\func{int}{GetReturnCode}{\void}
+\wxheading{Parameters}
-Gets the return code for this window.
+\docparam{x}{Receives the x position of the window.}
-\wxheading{Remarks}
+\docparam{y}{Receives the y 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.
+\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}}
+}
-\wxheading{See also}
+\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::GetRect}\label{wxwindowgetrect}
-\helpref{wxWindow::SetReturnCode}{wxwindowsetreturncode}, \helpref{wxDialog::ShowModal}{wxdialogshowmodal},\rtfsp
-\helpref{wxDialog::EndModal}{wxdialogendmodal}
+\constfunc{virtual wxRect}{GetRect}{\void}
+
+Returns the size and position of the window as a \helpref{wxRect}{wxrect} object.
\membersection{wxWindow::GetScrollThumb}\label{wxwindowgetscrollthumb}
\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}
+}}
+
+\membersection{wxWindow::GetSizer}\label{wxwindowgetsizer}
+
+\constfunc{const wxSizer *}{GetSizer}{\void}
+
+Return the sizer associated with the window by a previous call to
+\helpref{SetSizer()}{wxwindowsetsizer} or {\tt NULL}.
\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 = FALSE}}
Gets the dimensions of the string as it would be drawn on the
window with the currently selected font.
\docparam{use16}{If TRUE, {\it string} contains 16-bit characters. The default is 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}
\func{virtual wxString}{GetTitle}{\void}
\helpref{wxRegion}{wxregion}, \helpref{wxRegionIterator}{wxregioniterator}, \helpref{wxWindow::OnPaint}{wxwindowonpaint}
-\membersection{wxWindow::GetWindowStyleFlag}
+\membersection{wxWindow::GetValidator}\label{wxwindowgetvalidator}
+
+\constfunc{wxValidator*}{GetValidator}{\void}
+
+Returns a pointer to the current validator for the window, or NULL if there is none.
+
+\membersection{wxWindow::GetWindowStyleFlag}\label{wxwindowgetwindowstyleflag}
\constfunc{long}{GetWindowStyleFlag}{\void}
-Gets the window style that was passed to the consructor or {\bf Create} member.
+Gets the window style that was passed to the constructor or {\bf Create}
+method. {\bf GetWindowStyle()} is another name for the same function.
\membersection{wxWindow::InitDialog}\label{wxwindowinitdialog}
\helpref{wxWindow::Enable}{wxwindowenable}
+\membersection{wxWindow:IsExposed}\label{wxwindowisexposed}
+
+\constfunc{bool}{IsExposed}{\param{int }{x}, \param{int }{y}}
+
+\constfunc{bool}{IsExposed}{\param{wxPoint }{\&pt}}
+
+\constfunc{bool}{IsExposed}{\param{int }{x}, \param{int }{y}, \param{int }{w}, \param{int }{h}}
+
+\constfunc{bool}{IsExposed}{\param{wxRect }{\&rect}}
+
+Returns TRUE if the given point or rectange 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.
+
+\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}}}
+
\membersection{wxWindow::IsRetained}\label{wxwindowisretained}
\constfunc{virtual bool}{IsRetained}{\void}
Returns TRUE if the window is shown, FALSE if it has been hidden.
+\membersection{wxWindow::IsTopLevel}\label{wxwindowistoplevel}
+
+\constfunc{bool}{IsTopLevel}{\void}
+
+Returns 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).
+
\membersection{wxWindow::Layout}\label{wxwindowlayout}
\func{void}{Layout}{\void}
-Invokes the constraint-based layout algorithm for this window. It is called
-automatically by the default {\bf wxWindow::OnSize} member.
+Invokes the constraint-based layout algorithm or the sizer-based algorithm
+for this window.
+
+See \helpref{wxWindow::SetAutoLayout}{wxwindowsetautolayout} on when
+this function gets called automatically using auto layout.
\membersection{wxWindow::LoadFromResource}\label{wxwindowloadfromresource}
\membersection{wxWindow::MakeModal}\label{wxwindowmakemodal}
-\func{virtual void}{MakeModal}{\param{const bool }{flag}}
+\func{virtual void}{MakeModal}{\param{bool }{flag}}
Disables all other windows in the application so that
-the user can only interact with this window.
+the user can only interact with this window. (This function
+is not implemented anywhere).
\wxheading{Parameters}
\helpref{wxWindow::SetSize}{wxwindowsetsize}
+\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}}
+}
+
\membersection{wxWindow::OnActivate}\label{wxwindowonactivate}
\func{void}{OnActivate}{\param{wxActivateEvent\&}{ event}}
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
+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
values.
This function is only relevant to top-level windows (frames and dialogs), and under
-Windows only.
+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}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
-\helpref{wxApp::OnCharHook}{wxapponcharhook},\rtfsp
+\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}
\helpref{wxWindow::OnClose}{wxwindowonclose},\rtfsp
\helpref{wxWindow::Destroy}{wxwindowdestroy},\rtfsp
\helpref{wxCloseEvent}{wxcloseevent},\rtfsp
-\helpref{wxApp::OnQueryEndSession}{wxapponqueryendsession},\rtfsp
-\helpref{wxApp::OnEndSession}{wxapponendsession}
+\helpref{wxApp::OnQueryEndSession}{wxapponqueryendsession}
+%% GD: OnXXX functions are not documented
+%%\helpref{wxApp::OnEndSession}{wxapponendsession}
\membersection{wxWindow::OnDropFiles}\label{wxwindowondropfiles}
\wxheading{Remarks}
-This event is only generated under Windows.
+Under non-Windows platforms, this event is simulated (simply generated just before the
+paint event) and may cause flicker. It is therefore recommended that
+you set the text background colour explicitly in order to prevent flicker.
+The default background colour under GTK is grey.
To intercept this event, use the EVT\_ERASE\_BACKGROUND macro in an event table definition.
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
+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
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
+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{wxApp::OnIdle}{wxapponidle}, \helpref{wxIdleEvent}{wxidleevent}
+%% GD: OnXXX functions are not documented
+%%\helpref{wxApp::OnIdle}{wxapponidle}
+\helpref{wxIdleEvent}{wxidleevent}
\membersection{wxWindow::OnInitDialog}\label{wxwindowoninitdialog}
Use the EVT\_PAINT macro in an event table definition to intercept paint events.
-In a paint event handler, the application should always create a \helpref{wxPaintDC}{wxpaintdc} object.
+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)
+ void MyWindow::OnPaint(wxPaintEvent\& event)
{
wxPaintDC dc(this);
{\small%
\begin{verbatim}
// Called when window needs to be repainted.
-void MyWindow::OnPaint(wxPaintEvent& event)
+void MyWindow::OnPaint(wxPaintEvent\& event)
{
wxPaintDC dc(this);
// Find Out where the window is scrolled to
int vbX,vbY; // Top left corner of client
- ViewStart(&vbX,&vbY);
+ GetViewStart(&vbX,&vbY);
int vX,vY,vW,vH; // Dimensions of client area in pixels
wxRegionIterator upd(GetUpdateRegion()); // get the update rect list
\membersection{wxWindow::OnScroll}\label{wxwindowonscroll}
-\func{void}{OnScroll}{\param{wxScrollEvent\& }{event}}
+\func{void}{OnScroll}{\param{wxScrollWinEvent\& }{event}}
-Called when a scroll event is received from one of the window's built-in scrollbars.
+Called when a scroll window event is received from one of the window's built-in scrollbars.
\wxheading{Parameters}
\wxheading{See also}
-\helpref{wxScrollEvent}{wxscrollevent},\rtfsp
+\helpref{wxScrollWinEvent}{wxscrollwinevent},\rtfsp
\helpref{Event handling overview}{eventhandlingoverview}
\membersection{wxWindow::OnSetFocus}\label{wxwindowonsetfocus}
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
\func{void}{OnSysColourChanged}{\param{wxOnSysColourChangedEvent\& }{event}}
-Called when the user has changed the system colours.
+Called when the user has changed the system colours. Windows only.
\wxheading{Parameters}
\membersection{wxWindow::PopupMenu}\label{wxwindowpopupmenu}
-\func{virtual bool}{PopupMenu}{\param{wxMenu* }{menu}, \param{int }{x}, \param{int }{y}}
+\func{bool}{PopupMenu}{\param{wxMenu* }{menu}, \param{const wxPoint\& }{pos}}
+
+\func{bool}{PopupMenu}{\param{wxMenu* }{menu}, \param{int }{x}, \param{int }{y}}
Pops up the given menu at the specified coordinates, relative to this
window, and returns control when the user has dismissed the menu. If a
-menu item is selected, the callback defined for the menu is called with
-wxMenu and wxCommandEvent reference arguments. The callback should access
-the commandInt member of the event to check the selected menu identifier.
+menu item is selected, the corresponding menu event is generated and will be
+processed as usually.
\wxheading{Parameters}
\docparam{menu}{Menu to pop up.}
+\docparam{pos}{The position where the menu will appear.}
+
\docparam{x}{Required x position for the menu to appear.}
\docparam{y}{Required y position for the menu to appear.}
\wxheading{Remarks}
Just before the menu is popped up, \helpref{wxMenu::UpdateUI}{wxmenuupdateui} is called
-to ensure that the menu items are in the correct state.
+to ensure that the menu items are in the correct state. The menu does not get deleted
+by the window.
+
+\pythonnote{In place of a single overloaded method name, wxPython
+implements the following methods:\par
+\indented{2cm}{\begin{twocollist}
+\twocolitem{{\bf PopupMenu(menu, point)}}{Specifies position with a wxPoint}
+\twocolitem{{\bf PopupMenuXY(menu, x, y)}}{Specifies position with two integers (x, y)}
+\end{twocollist}}
+}
\membersection{wxWindow::PushEventHandler}\label{wxwindowpusheventhandler}
\membersection{wxWindow::Refresh}\label{wxwindowrefresh}
-\func{virtual void}{Refresh}{\param{const bool}{ eraseBackground = TRUE}, \param{const wxRect* }{rect
+\func{virtual void}{Refresh}{\param{bool}{ eraseBackground = TRUE}, \param{const wxRect* }{rect
= NULL}}
Causes a message or event to be generated to repaint the
\docparam{child}{Child window to remove.}
+\membersection{wxWindow::Reparent}\label{wxwindowreparent}
+
+\func{virtual bool}{Reparent}{\param{wxWindow* }{newParent}}
+
+Reparents the window, i.e the window will be removed from its
+current parent window (e.g. a non-standard toolbar in a wxFrame)
+and then re-inserted into another. Available on Windows and GTK.
+
+\wxheading{Parameters}
+
+\docparam{newParent}{New parent.}
+
\membersection{wxWindow::ScreenToClient}\label{wxwindowscreentoclient}
\constfunc{virtual void}{ScreenToClient}{\param{int* }{x}, \param{int* }{y}}
\docparam{pt}{The screen 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 ScreenToClient(point)}}{Accepts and returns a wxPoint}
+\twocolitem{{\bf ScreenToClientXY(x, y)}}{Returns a 2-tuple, (x, y)}
+\end{twocollist}}
+}
+
+\membersection{wxWindow::ScrollLines}\label{wxwindowscrolllines}
+
+\func{virtual bool}{ScrollLines}{\param{int }{lines}}
+
+Scrolls the window by the given number of lines down (if {\it lines} is
+positive) or up.
+
+\wxheading{Return value}
+
+Returns {\tt TRUE} if the window was scrolled, {\tt FALSE} if it was already
+on top/bottom and nothing was done.
+
+\wxheading{Remarks}
+
+This function is currently only implemented under MSW and wxTextCtrl under
+wxGTK (it also works for wxScrolledWindow derived classes under all
+platforms).
+
+\wxheading{See also}
+
+\helpref{ScrollPages}{wxwindowscrollpages}
+
+\membersection{wxWindow::ScrollPages}\label{wxwindowscrollpages}
+
+\func{virtual bool}{ScrollPages}{\param{int }{pages}}
+
+Scrolls the window by the given number of pages down (if {\it pages} is
+positive) or up.
+
+\wxheading{Return value}
+
+Returns {\tt TRUE} if the window was scrolled, {\tt FALSE} if it was already
+on top/bottom and nothing was done.
+
+\wxheading{Remarks}
+
+This function is currently only implemented under MSW and wxTextCtrl under
+wxGTK (it also works for wxScrolledWindow derived classes under all
+platforms).
+
+\wxheading{See also}
+
+\helpref{ScrollLines}{wxwindowscrolllines}
+
\membersection{wxWindow::ScrollWindow}\label{wxwindowscrollwindow}
\func{virtual void}{ScrollWindow}{\param{int }{dx}, \param{int }{dy}, \param{const wxRect*}{ rect = NULL}}
-Physically scrolls the pixels in the window.
+Physically scrolls the pixels in the window and move child windows accordingly.
\wxheading{Parameters}
\docparam{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.}
+can optimize painting by checking for the invalidated region. This parameter is ignored under GTK.}
\wxheading{Remarks}
-Available only under Windows.
-
Use this function to optimise your scrolling implementations, to minimise the area that must be
-redrawn.
+redrawn. Note that it is rarely required to call this function from a user program.
\membersection{wxWindow::SetAcceleratorTable}\label{wxwindowsetacceleratortable}
\membersection{wxWindow::SetAutoLayout}\label{wxwindowsetautolayout}
-\func{void}{SetAutoLayout}{\param{const bool}{ autoLayout}}
+\func{void}{SetAutoLayout}{\param{bool}{ autoLayout}}
Determines whether the \helpref{wxWindow::Layout}{wxwindowlayout} function will
-be called automatically when the window is resized.
+be called automatically when the window is resized. Use in connection with
+\helpref{wxWindow::SetSizer}{wxwindowsetsizer} and
+\helpref{wxWindow::SetConstraints}{wxwindowsetconstraints} for laying out
+subwindows.
\wxheading{Parameters}
\wxheading{Remarks}
The background colour is usually painted by the default\rtfsp
-\helpref{wxWindow::OnEraseBackground}{wxwindowonerasebackground} event handler function.
+\helpref{wxWindow::OnEraseBackground}{wxwindowonerasebackground} event handler function
+under Windows and automatically under GTK.
Note that setting the background colour does not cause an immediate refresh, so you
may wish to call \helpref{wxWindow::Clear}{wxwindowclear} or \helpref{wxWindow::Refresh}{wxwindowrefresh} after
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{wxWindow::GetBackgroundColour}{wxwindowgetbackgroundcolour},\rtfsp
\helpref{wxWindow::Refresh}{wxwindowrefresh},\rtfsp
\helpref{wxWindow::OnEraseBackground}{wxwindowonerasebackground}
+\membersection{wxWindow::SetCaret}\label{wxwindowsetcaret}
+
+\constfunc{void}{SetCaret}{\param{wxCaret *}{caret}}
+
+Sets the \helpref{caret}{wxcaret} associated with the window.
+
+\membersection{wxWindow::SetClientSize}\label{wxwindowsetclientsize}
+
+\func{virtual void}{SetClientSize}{\param{int}{ width}, \param{int}{ height}}
+
+\func{virtual void}{SetClientSize}{\param{const wxSize\&}{ size}}
+
+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.
+
+\wxheading{Parameters}
+
+\docparam{width}{The required client area width.}
+
+\docparam{height}{The required client area height.}
+
+\docparam{size}{The required client size.}
+
+\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}}
+}
+
+\membersection{wxWindow::SetCursor}\label{wxwindowsetcursor}
+
+\func{virtual void}{SetCursor}{\param{const wxCursor\&}{cursor}}
+
+% VZ: the docs are correct, if the code doesn't behave like this, it must be
+% changed
+Sets the window's cursor. Notice that the window cursor also sets it for the
+children of the window implicitly.
+
+The {\it cursor} may be {\tt wxNullCursor} in which case the window cursor will
+be reset back to default.
+
+\wxheading{Parameters}
+
+\docparam{cursor}{Specifies the cursor that the window should normally display.}
+
+\wxheading{See also}
+
+\helpref{::wxSetCursor}{wxsetcursor}, \helpref{wxCursor}{wxcursor}
+
\membersection{wxWindow::SetConstraints}\label{wxwindowsetconstraints}
\func{void}{SetConstraints}{\param{wxLayoutConstraints* }{constraints}}
\wxheading{Remarks}
You must call \helpref{wxWindow::SetAutoLayout}{wxwindowsetautolayout} to tell a window to use
-the constraints automatically in OnSize; otherwise, you must
-override OnSize and call Layout explicitly.
+the constraints automatically in OnSize; otherwise, you must override OnSize and call Layout()
+explicitly. When setting both a wxLayoutConstraints and a \helpref{wxSizer}{wxsizer}, only the
+sizer will have effect.
\membersection{wxWindow::SetDropTarget}\label{wxwindowsetdroptarget}
\wxheading{See also}
-\helpref{wxWindow::GetDropTarget}{wxwindowgetdroptarget},
+\helpref{wxWindow::GetDropTarget}{wxwindowgetdroptarget},
\helpref{Drag and drop overview}{wxdndoverview}
+\membersection{wxWindow::SetEventHandler}\label{wxwindowseteventhandler}
+
+\func{void}{SetEventHandler}{\param{wxEvtHandler* }{handler}}
+
+Sets the event handler for this window.
+
+\wxheading{Parameters}
+
+\docparam{handler}{Specifies the handler to be set.}
+
+\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.
+
+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::GetEventHandler}{wxwindowgeteventhandler},\rtfsp
+\helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler},\rtfsp
+\helpref{wxWindow::PopEventHandler}{wxwindowpusheventhandler},\rtfsp
+\helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
+\helpref{wxEvtHandler}{wxevthandler}
+
+\membersection{wxWindow::SetExtraStyle}\label{wxwindowsetextrastyle}
+
+\func{void}{SetExtraStyle}{\param{long }{exStyle}}
+
+Sets the extra style bits for the window. The currently defined extra style
+bits are:
+
+\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 propagared 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 childs of such windows results in fatal problems.}
+\end{twocollist}
+
\membersection{wxWindow::SetFocus}\label{wxwindowsetfocus}
\func{virtual void}{SetFocus}{\void}
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 apperance 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}
+\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}
\func{void}{SetId}{\param{int}{ id}}
\helpref{wxWindow::GetName}{wxwindowgetname}
-\membersection{wxWindow::SetReturnCode}\label{wxwindowsetreturncode}
-
-\func{void}{SetReturnCode}{\param{int }{retCode}}
-
-Sets the return code for this window.
-
-\wxheading{Parameters}
+\membersection{wxWindow::SetPalette}\label{wxwindowsetpalette}
-\docparam{retCode}{The integer return code, usually a control identifier.}
-
-\wxheading{Remarks}
-
-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}.
-
-\wxheading{See also}
+\func{virtual void}{SetPalette}{\param{wxPalette* }{palette}}
-\helpref{wxWindow::GetReturnCode}{wxwindowgetreturncode}, \helpref{wxDialog::ShowModal}{wxdialogshowmodal},\rtfsp
-\helpref{wxDialog::EndModal}{wxdialogendmodal}
+Obsolete - use \helpref{wxDC::SetPalette}{wxdcsetpalette} instead.
\membersection{wxWindow::SetScrollbar}\label{wxwindowsetscrollbar}
\func{virtual void}{SetScrollbar}{\param{int }{orientation}, \param{int }{position},\rtfsp
\param{int }{thumbSize}, \param{int }{range},\rtfsp
-\param{const bool }{refresh = TRUE}}
+\param{bool }{refresh = TRUE}}
Sets the scrollbar properties of a built-in scrollbar.
\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 = TRUE}}
Sets the page size of one of the built-in scrollbars.
\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 = TRUE}}
Sets the position of one of the built-in scrollbars.
\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 = TRUE}}
Sets the range of one of the built-in scrollbars.
\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},
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}}
-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.
\wxheading{Parameters}
-\docparam{width}{The required client area width.}
+\docparam{sizer}{The sizer to set. Pass NULL to disassociate and delete the window's
+sizer.}
-\docparam{height}{The required client area height.}
+\wxheading{Remarks}
-\docparam{size}{The required client size.}
+You must call \helpref{wxWindow::SetAutoLayout}{wxwindowsetautolayout} to tell a window to use
+the sizer automatically in OnSize; otherwise, you must override OnSize and call Layout()
+explicitly. When setting both a wxSizer and a \helpref{wxLayoutConstraints}{wxlayoutconstraints},
+only the sizer will have effect.
-\membersection{wxWindow::SetPalette}
+\membersection{wxWindow::SetTitle}\label{wxwindowsettitle}
-\func{virtual void}{SetPalette}{\param{wxPalette* }{palette}}
+\func{virtual void}{SetTitle}{\param{const wxString\& }{title}}
-Obsolete - use \helpref{wxDC::SetPalette}{wxdcsetpalette} instead.
+Sets the window's title. Applicable only to frames and dialogs.
-\membersection{wxWindow::SetCursor}\label{wxwindowsetcursor}
+\wxheading{Parameters}
-\func{virtual void}{SetCursor}{\param{const wxCursor\&}{cursor}}
+\docparam{title}{The window's title.}
-Sets the window's cursor.
+\wxheading{See also}
-\wxheading{Parameters}
+\helpref{wxWindow::GetTitle}{wxwindowgettitle}
-\docparam{cursor}{Specifies the cursor that the window should normally display.}
+\membersection{wxWindow::SetValidator}\label{wxwindowsetvalidator}
-\wxheading{Remarks}
+\func{virtual void}{SetValidator}{\param{const wxValidator\&}{ validator}}
-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.
+Deletes the current validator (if any) and sets the window validator, having called wxValidator::Clone to
+create a new validator of this type.
-\wxheading{See also}
+\membersection{wxWindow::SetToolTip}\label{wxwindowsettooltip}
-\helpref{::wxSetCursor}{wxsetcursor}, \helpref{wxCursor}{wxcursor}
+\func{void}{SetToolTip}{\param{const wxString\& }{tip}}
-\membersection{wxWindow::SetEventHandler}\label{wxwindowseteventhandler}
+\func{void}{SetToolTip}{\param{wxToolTip* }{tip}}
-\func{void}{SetEventHandler}{\param{wxEvtHandler* }{handler}}
+Attach a tooltip to the window.
-Sets the event handler for this window.
+See also: \helpref{GetToolTip}{wxwindowgettooltip},
+ \helpref{wxToolTip}{wxtooltip}
-\wxheading{Parameters}
-\docparam{handler}{Specifies the handler to be set.}
+\membersection{wxWindow::GetToolTip}\label{wxwindowgettooltip}
-\wxheading{Remarks}
+\constfunc{wxToolTip*}{GetToolTip}{\void}
-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.
+Get the associated tooltip or NULL if none.
-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::GetEventHandler}{wxwindowgeteventhandler},\rtfsp
-\helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler},\rtfsp
-\helpref{wxWindow::PopEventHandler}{wxwindowpusheventhandler},\rtfsp
-\helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
-\helpref{wxEvtHandler}{wxevthandler}
+\membersection{wxWindow::SetWindowStyle}\label{wxwindowsetwindowstyle}
-\membersection{wxWindow::SetTitle}\label{wxwindowsettitle}
+\func{void}{SetWindowStyle}{\param{long}{ style}}
-\func{virtual void}{SetTitle}{\param{const wxString\& }{title}}
+Identical to \helpref{SetWindowStyleFlag}{wxwindowsetwindowstyleflag}.
-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::Show}
+\membersection{wxWindow::Show}\label{wxwindowshow}
-\func{virtual bool}{Show}{\param{const bool}{ show}}
+\func{virtual bool}{Show}{\param{bool}{ show}}
-Shows or hides the window.
+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 TRUE displays the window. Otherwise, hides it.}
\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}.
+
\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.
+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
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.
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.
projects / wxWidgets.git / blobdiff