a6aa9b1ee8
of child windows from wxNotebook and wxSplitter, as per Robert's request. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4084 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
2312 lines
76 KiB
TeX
2312 lines
76 KiB
TeX
\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.
|
|
|
|
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 or on all platforms.
|
|
|
|
\twocolwidtha{5cm}%
|
|
\begin{twocollist}\itemsep=0pt
|
|
\twocolitem{\windowstyle{wxSIMPLE\_BORDER}}{Displays a thin border around the window. wxBORDER is the old name
|
|
for this style. }
|
|
\twocolitem{\windowstyle{wxDOUBLE\_BORDER}}{Displays a double border. Windows only.}
|
|
\twocolitem{\windowstyle{wxSUNKEN\_BORDER}}{Displays a sunken border.}
|
|
\twocolitem{\windowstyle{wxRAISED\_BORDER}}{Displays a raised border. 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{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\_FULLREPAINT\_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 style. Currently only has 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.}
|
|
\end{twocollist}
|
|
|
|
See also \helpref{window styles overview}{windowstyles}.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{Event handling overview}{eventhandlingoverview}
|
|
|
|
\latexignore{\rtfignore{\wxheading{Members}}}
|
|
|
|
\membersection{wxWindow::wxWindow}
|
|
|
|
\func{}{wxWindow}{\void}
|
|
|
|
Default constructor.
|
|
|
|
\func{}{wxWindow}{\param{wxWindow*}{ parent}, \param{wxWindowID }{id},
|
|
\param{const wxPoint\& }{pos = wxDefaultPosition},
|
|
\param{const wxSize\& }{size = wxDefaultSize},
|
|
\param{long }{style = 0},
|
|
\param{const wxString\& }{name = wxPanelNameStr}}
|
|
|
|
Constructs a window, which can be a child of a frame, dialog or any other non-control window.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{parent}{Pointer to a parent window.}
|
|
|
|
\docparam{id}{Window identifier. If -1, will automatically create an identifier.}
|
|
|
|
\docparam{pos}{Window position. wxDefaultPosition is (-1, -1) which indicates that wxWindows
|
|
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. 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
|
|
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.
|
|
|
|
\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.
|
|
|
|
\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::Centre}\label{wxwindowcentre}
|
|
|
|
\func{void}{Centre}{\param{int}{ direction = wxHORIZONTAL}}
|
|
|
|
Centres the window.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{direction}{Specifies the direction for the centering. May be {\tt wxHORIZONTAL}, {\tt wxVERTICAL}\rtfsp
|
|
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.
|
|
|
|
\wxheading{Remarks}
|
|
|
|
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 = wxHORIZONTAL}}
|
|
|
|
Centres the window.
|
|
|
|
\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::CenterOnParent}{wxwindowcenteronparent}
|
|
|
|
\membersection{wxWindow::Clear}\label{wxwindowclear}
|
|
|
|
\func{void}{Clear}{\void}
|
|
|
|
Clears the window by filling it with the current background colour. Does not
|
|
cause an erase background event to be generated.
|
|
|
|
\membersection{wxWindow::ClientToScreen}
|
|
|
|
\constfunc{virtual void}{ClientToScreen}{\param{int* }{x}, \param{int* }{y}}
|
|
|
|
\constfunc{virtual wxPoint}{ClientToScreen}{\param{const wxPoint\&}{ pt}}
|
|
|
|
Converts to screen coordinates from coordinates relative to this window.
|
|
|
|
\docparam{x}{A pointer to a integer value for the x coordinate. Pass the client coordinate in, and
|
|
a screen coordinate will be passed out.}
|
|
|
|
\docparam{y}{A pointer to a integer value for the y coordinate. Pass the client coordinate in, and
|
|
a screen coordinate will be passed out.}
|
|
|
|
\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}}
|
|
|
|
The purpose of this call is to provide a safer way of destroying a window than using
|
|
the {\it delete} operator.
|
|
|
|
\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.}
|
|
|
|
\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.
|
|
|
|
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}.
|
|
|
|
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::OnCloseWindow}{wxwindowonclosewindow},\rtfsp
|
|
\helpref{wxWindow::Destroy}{wxwindowdestroy},\rtfsp
|
|
\helpref{wxCloseEvent}{wxcloseevent}
|
|
|
|
\membersection{wxWindow::ConvertDialogToPixels}\label{wxwindowconvertdialogtopixels}
|
|
|
|
\func{wxPoint}{ConvertDialogToPixels}{\param{const wxPoint\&}{ pt}}
|
|
|
|
\func{wxSize}{ConvertDialogToPixels}{\param{const wxSize\&}{ sz}}
|
|
|
|
Converts a point or size from dialog units to pixels.
|
|
|
|
For the x dimension, the dialog units are multiplied by the average character width
|
|
and then divided by 4.
|
|
|
|
For the y dimension, the dialog units are multiplied by the average character height
|
|
and then divided by 8.
|
|
|
|
\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:
|
|
|
|
{\small
|
|
\begin{verbatim}
|
|
#define wxDLG_UNIT(parent, pt) parent->ConvertDialogToPixels(pt)
|
|
\end{verbatim}
|
|
}
|
|
|
|
\wxheading{See also}
|
|
|
|
\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}}
|
|
|
|
\func{wxSize}{ConvertPixelsToDialog}{\param{const wxSize\&}{ sz}}
|
|
|
|
Converts a point or size from pixels to dialog units.
|
|
|
|
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
|
|
character height.
|
|
|
|
\wxheading{Remarks}
|
|
|
|
Dialog units are used for maintaining a dialog's proportions even if the font changes.
|
|
Dialogs created using Dialog Editor optionally use dialog units.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::ConvertDialogToPixels}{wxwindowconvertdialogtopixels}
|
|
|
|
|
|
\pythonnote{In place of a single overloaded method name, wxPython
|
|
implements the following methods:\par
|
|
\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
|
|
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
|
|
windows.
|
|
|
|
\wxheading{Return value}
|
|
|
|
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}}
|
|
|
|
Enables or disables elibility for drop file events (OnDropFiles).
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{accept}{If TRUE, the window is eligible for drop file events. If FALSE, the window
|
|
will not accept drop file events.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
Windows only.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::OnDropFiles}{wxwindowondropfiles}
|
|
|
|
\membersection{wxWindow::Enable}\label{wxwindowenable}
|
|
|
|
\func{virtual void}{Enable}{\param{const bool}{ enable}}
|
|
|
|
Enable or disable the window for user input.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{enable}{If TRUE, enables the window for input. If FALSE, disables the window.}
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::IsEnabled}{wxwindowisenabled}
|
|
|
|
\membersection{wxWindow::FindFocus}\label{wxwindowfindfocus}
|
|
|
|
\func{static wxWindow*}{FindFocus}{\void}
|
|
|
|
Finds the window or control which currently has the keyboard focus.
|
|
|
|
\wxheading{Remarks}
|
|
|
|
Note that this is a static function, so it can be called without needing a wxWindow pointer.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::SetFocus}{wxwindowsetfocus}
|
|
|
|
\membersection{wxWindow::FindWindow}\label{wxwindowfindwindow}
|
|
|
|
\func{wxWindow*}{FindWindow}{\param{long}{ id}}
|
|
|
|
Find a child of this window, by identifier.
|
|
|
|
\func{wxWindow*}{FindWindow}{\param{const wxString\&}{ name}}
|
|
|
|
Find a child of this window, by name.
|
|
|
|
\pythonnote{In place of a single overloaded method name, wxPython
|
|
implements the following methods:\par
|
|
\indented{2cm}{\begin{twocollist}
|
|
\twocolitem{\bf{FindWindowById(id)}}{Accepts an integer}
|
|
\twocolitem{\bf{FindWindowByName(name)}}{Accepts a string}
|
|
\end{twocollist}}
|
|
}
|
|
|
|
\membersection{wxWindow::Fit}\label{wxwindowfit}
|
|
|
|
\func{virtual void}{Fit}{\void}
|
|
|
|
Sizes the window so that it fits around its subwindows.
|
|
|
|
\membersection{wxWindow::GetBackgroundColour}\label{wxwindowgetbackgroundcolour}
|
|
|
|
\constfunc{virtual wxColour}{GetBackgroundColour}{\void}
|
|
|
|
Returns the background colour of the window.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::SetBackgroundColour}{wxwindowsetbackgroundcolour},\rtfsp
|
|
\helpref{wxWindow::SetForegroundColour}{wxwindowsetforegroundcolour},\rtfsp
|
|
\helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour},\rtfsp
|
|
\helpref{wxWindow::OnEraseBackground}{wxwindowonerasebackground}
|
|
|
|
\membersection{wxWindow::GetCharHeight}
|
|
|
|
\constfunc{virtual int}{GetCharHeight}{\void}
|
|
|
|
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{wxWindow::GetClientSize}\label{wxwindowgetclientsize}
|
|
|
|
\constfunc{virtual void}{GetClientSize}{\param{int* }{width}, \param{int* }{height}}
|
|
|
|
\constfunc{virtual 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.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{width}{Receives the client width in pixels.}
|
|
|
|
\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{wxGetClientSizeTuple()}}{Returns a 2-tuple of (width, height)}
|
|
\twocolitem{\bf{wxGetClientSize()}}{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}
|
|
|
|
Returns the associated drop target, which may be NULL.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::SetDropTarget}{wxwindowsetdroptarget},
|
|
\helpref{Drag and drop overview}{wxdndoverview}
|
|
|
|
\membersection{wxWindow::GetEventHandler}\label{wxwindowgeteventhandler}
|
|
|
|
\constfunc{wxEvtHandler*}{GetEventHandler}{\void}
|
|
|
|
Returns the event handler for this window. By default, the window is its
|
|
own event handler.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::SetEventHandler}{wxwindowseteventhandler},\rtfsp
|
|
\helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler},\rtfsp
|
|
\helpref{wxWindow::PopEventHandler}{wxwindowpusheventhandler},\rtfsp
|
|
\helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
|
|
\helpref{wxEvtHandler}{wxevthandler}\rtfsp
|
|
|
|
\membersection{wxWindow::GetFont}\label{wxwindowgetfont}
|
|
|
|
\constfunc{wxFont\&}{GetFont}{\void}
|
|
|
|
Returns a reference to the font for this window.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::SetFont}{wxwindowsetfont}
|
|
|
|
\membersection{wxWindow::GetForegroundColour}\label{wxwindowgetforegroundcolour}
|
|
|
|
\func{virtual wxColour}{GetForegroundColour}{\void}
|
|
|
|
Returns the foreground colour of the window.
|
|
|
|
\wxheading{Remarks}
|
|
|
|
The interpretation of foreground colour is open to interpretation according
|
|
to the window class; it may be the text colour or other colour, or it may not
|
|
be used at all.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::SetForegroundColour}{wxwindowsetforegroundcolour},\rtfsp
|
|
\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}
|
|
|
|
\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, {\bf Widget} for Motif or {\bf GtkWidget} for GTK.
|
|
|
|
\membersection{wxWindow::GetId}\label{wxwindowgetid}
|
|
|
|
\constfunc{int}{GetId}{\void}
|
|
|
|
Returns the identifier 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}
|
|
|
|
\membersection{wxWindow::GetPosition}
|
|
|
|
\constfunc{virtual void}{GetPosition}{\param{int* }{x}, \param{int* }{y}}
|
|
|
|
This gets the position of the window in pixels, relative to the parent window or
|
|
if no parent, relative to the whole display.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{x}{Receives the x position of the window.}
|
|
|
|
\docparam{y}{Receives the y position of the window.}
|
|
|
|
\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}}
|
|
}
|
|
|
|
\membersection{wxWindow::GetLabel}
|
|
|
|
\constfunc{virtual wxString }{GetLabel}{\void}
|
|
|
|
Generic way of getting a label from any window, for
|
|
identification purposes.
|
|
|
|
\wxheading{Remarks}
|
|
|
|
The interpretation of this function differs from class to class.
|
|
For frames and dialogs, the value returned is the title. For buttons or static text controls, it is
|
|
the button text. This function can be useful for meta-programs (such as testing
|
|
tools or special-needs access programs) which need to identify windows
|
|
by name.
|
|
|
|
\membersection{wxWindow::GetName}\label{wxwindowgetname}
|
|
|
|
\constfunc{virtual wxString }{GetName}{\void}
|
|
|
|
Returns the window's name.
|
|
|
|
\wxheading{Remarks}
|
|
|
|
This name is not guaranteed to be unique; it is up to the programmer to supply an appropriate
|
|
name in the window constructor or via \helpref{wxWindow::SetName}{wxwindowsetname}.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::SetName}{wxwindowsetname}
|
|
|
|
\membersection{wxWindow::GetParent}
|
|
|
|
\constfunc{virtual wxWindow*}{GetParent}{\void}
|
|
|
|
Returns the parent of the window, or NULL if there is no parent.
|
|
|
|
\membersection{wxWindow::GetRect}\label{wxwindowgetrect}
|
|
|
|
\constfunc{virtual wxRect}{GetRect}{\void}
|
|
|
|
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}}
|
|
|
|
Returns the built-in scrollbar position.
|
|
|
|
\wxheading{See also}
|
|
|
|
See \helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar}
|
|
|
|
\membersection{wxWindow::GetScrollRange}\label{wxwindowgetscrollrange}
|
|
|
|
\func{virtual int}{GetScrollRange}{\param{int }{orientation}}
|
|
|
|
Returns the built-in scrollbar range.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar}
|
|
|
|
\membersection{wxWindow::GetSize}\label{wxwindowgetsize}
|
|
|
|
\constfunc{virtual void}{GetSize}{\param{int* }{width}, \param{int* }{height}}
|
|
|
|
\constfunc{virtual wxSize}{GetSize}{\void}
|
|
|
|
This gets the size of the entire window in pixels.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{width}{Receives the window width.}
|
|
|
|
\docparam{height}{Receives the window height.}
|
|
|
|
\pythonnote{In place of a single overloaded method name, wxPython
|
|
implements the following methods:\par
|
|
\indented{2cm}{\begin{twocollist}
|
|
\twocolitem{\bf{GetSize()}}{Returns a wxSize}
|
|
\twocolitem{\bf{GetSizeTuple()}}{Returns a 2-tuple (width, height)}
|
|
\end{twocollist}}
|
|
}
|
|
|
|
\membersection{wxWindow::GetTextExtent}
|
|
|
|
\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}}
|
|
|
|
Gets the dimensions of the string as it would be drawn on the
|
|
window with the currently selected font.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{string}{String whose extent is to be measured.}
|
|
|
|
\docparam{x}{Return value for width.}
|
|
|
|
\docparam{y}{Return value for height.}
|
|
|
|
\docparam{descent}{Return value for descent (optional).}
|
|
|
|
\docparam{externalLeading}{Return value for external leading (optional).}
|
|
|
|
\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.}
|
|
|
|
|
|
\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}}
|
|
}
|
|
|
|
|
|
\membersection{wxWindow::GetTitle}\label{wxwindowgettitle}
|
|
|
|
\func{virtual wxString}{GetTitle}{\void}
|
|
|
|
Gets the window's title. Applicable only to frames and dialogs.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::SetTitle}{wxwindowsettitle}
|
|
|
|
\membersection{wxWindow::GetUpdateRegion}\label{wxwindowgetupdateregion}
|
|
|
|
\constfunc{virtual wxRegion}{GetUpdateRegion}{\void}
|
|
|
|
Returns the region specifying which parts of the window have been damaged. Should
|
|
only be called within an \helpref{OnPaint}{wxwindowonpaint} event handler.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxRegion}{wxregion}, \helpref{wxRegionIterator}{wxregioniterator}, \helpref{wxWindow::OnPaint}{wxwindowonpaint}
|
|
|
|
\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}
|
|
|
|
\constfunc{long}{GetWindowStyleFlag}{\void}
|
|
|
|
Gets the window style that was passed to the consructor or {\bf Create} member.
|
|
{\bf GetWindowStyle} is synonymous.
|
|
|
|
\membersection{wxWindow::InitDialog}\label{wxwindowinitdialog}
|
|
|
|
\func{void}{InitDialog}{\void}
|
|
|
|
Sends an \helpref{wxWindow::OnInitDialog}{wxwindowoninitdialog} event, which
|
|
in turn transfers data to the dialog via validators.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::OnInitDialog}{wxwindowoninitdialog}
|
|
|
|
\membersection{wxWindow::IsEnabled}\label{wxwindowisenabled}
|
|
|
|
\constfunc{virtual bool}{IsEnabled}{\void}
|
|
|
|
Returns TRUE if the window is enabled for input, FALSE otherwise.
|
|
|
|
\wxheading{See also}
|
|
|
|
\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.
|
|
|
|
\membersection{wxWindow::IsRetained}\label{wxwindowisretained}
|
|
|
|
\constfunc{virtual bool}{IsRetained}{\void}
|
|
|
|
Returns TRUE if the window is retained, FALSE otherwise.
|
|
|
|
\wxheading{Remarks}
|
|
|
|
Retained windows are only available on X platforms.
|
|
|
|
\membersection{wxWindow::IsShown}\label{wxwindowisshown}
|
|
|
|
\constfunc{virtual bool}{IsShown}{\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 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}
|
|
|
|
\func{virtual bool}{LoadFromResource}{\param{wxWindow* }{parent},\rtfsp
|
|
\param{const wxString\& }{resourceName}, \param{const wxResourceTable* }{resourceTable = NULL}}
|
|
|
|
Loads a panel or dialog from a resource file.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{parent}{Parent window.}
|
|
|
|
\docparam{resourceName}{The name of the resource to load.}
|
|
|
|
\docparam{resourceTable}{The resource table to load it from. If this is NULL, the
|
|
default resource table will be used.}
|
|
|
|
\wxheading{Return value}
|
|
|
|
TRUE if the operation succeeded, otherwise FALSE.
|
|
|
|
\membersection{wxWindow::Lower}\label{wxwindowlower}
|
|
|
|
\func{void}{Lower}{\void}
|
|
|
|
Lowers the window to the bottom of the window hierarchy if it is a managed window (dialog
|
|
or frame).
|
|
|
|
\membersection{wxWindow::MakeModal}\label{wxwindowmakemodal}
|
|
|
|
\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. (This function
|
|
is not implemented anywhere).
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{flag}{If TRUE, this call disables all other windows in the application so that
|
|
the user can only interact with this window. If FALSE, the effect is reversed.}
|
|
|
|
\membersection{wxWindow::Move}\label{wxwindowmove}
|
|
|
|
\func{void}{Move}{\param{int}{ x}, \param{int}{ y}}
|
|
|
|
\func{void}{Move}{\param{const wxPoint\&}{ pt}}
|
|
|
|
Moves the window to the given position.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{x}{Required x position.}
|
|
|
|
\docparam{y}{Required y position.}
|
|
|
|
\docparam{pt}{\helpref{wxPoint}{wxpoint} object representing the position.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
Implementations of SetSize can also implicitly implement the
|
|
wxWindow::Move function, which is defined in the base wxWindow class
|
|
as the call:
|
|
|
|
\begin{verbatim}
|
|
SetSize(x, y, -1, -1, wxSIZE_USE_EXISTING);
|
|
\end{verbatim}
|
|
|
|
\wxheading{See also}
|
|
|
|
\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}}
|
|
|
|
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 TRUE,
|
|
otherwise it returns 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.
|
|
|
|
\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}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
|
|
\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 superceded by the \helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow} event
|
|
handler.
|
|
|
|
\wxheading{Return value}
|
|
|
|
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.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{Window deletion overview}{windowdeletionoverview},\rtfsp
|
|
\helpref{wxWindow::Close}{wxwindowclose},\rtfsp
|
|
\helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow},\rtfsp
|
|
\helpref{wxCloseEvent}{wxcloseevent}
|
|
|
|
\membersection{wxWindow::OnCloseWindow}\label{wxwindowonclosewindow}
|
|
|
|
\func{void}{OnCloseWindow}{\param{wxCloseEvent\& }{event}}
|
|
|
|
This is an event handler function called when the user has tried to close a a frame
|
|
or dialog box using the window manager (X) or system menu (Windows). It is
|
|
called via the \helpref{wxWindow::Close}{wxwindowclose} function, so
|
|
that the application can also invoke the handler programmatically.
|
|
|
|
Use the EVT\_CLOSE event table macro to handle close events.
|
|
|
|
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.
|
|
|
|
(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.)
|
|
|
|
If you don't destroy the window, you should call \helpref{wxCloseEvent::Veto}{wxcloseeventveto} to
|
|
let the calling code know that you did not destroy the window. This allows the \helpref{wxWindow::Close}{wxwindowclose} function
|
|
to return TRUE or FALSE depending on whether the close instruction was honoured or not.
|
|
|
|
\wxheading{Remarks}
|
|
|
|
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.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{Window deletion overview}{windowdeletionoverview},\rtfsp
|
|
\helpref{wxWindow::Close}{wxwindowclose},\rtfsp
|
|
\helpref{wxWindow::OnClose}{wxwindowonclose},\rtfsp
|
|
\helpref{wxWindow::Destroy}{wxwindowdestroy},\rtfsp
|
|
\helpref{wxCloseEvent}{wxcloseevent},\rtfsp
|
|
\helpref{wxApp::OnQueryEndSession}{wxapponqueryendsession},\rtfsp
|
|
\helpref{wxApp::OnEndSession}{wxapponendsession}
|
|
|
|
\membersection{wxWindow::OnDropFiles}\label{wxwindowondropfiles}
|
|
|
|
\func{void}{OnDropFiles}{\param{wxDropFilesEvent\&}{ event}}
|
|
|
|
Called when files have been dragged from the file manager to the window.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{event}{Drop files event. For more information, see \helpref{wxDropFilesEvent}{wxdropfilesevent}.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
The window must have previously been enabled for dropping by calling
|
|
\rtfsp\helpref{wxWindow::DragAcceptFiles}{wxwindowdragacceptfiles}.
|
|
|
|
This event is only generated under Windows.
|
|
|
|
To intercept this event, use the EVT\_DROP\_FILES macro in an event table definition.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxDropFilesEvent}{wxdropfilesevent}, \helpref{wxWindow::DragAcceptFiles}{wxwindowdragacceptfiles},\rtfsp
|
|
\helpref{Event handling overview}{eventhandlingoverview}
|
|
|
|
\membersection{wxWindow::OnEraseBackground}\label{wxwindowonerasebackground}
|
|
|
|
\func{void}{OnEraseBackground}{\param{wxEraseEvent\&}{ event}}
|
|
|
|
Called when the background of the window needs to be erased.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{event}{Erase background event. For more information, see \helpref{wxEraseEvent}{wxeraseevent}.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
This event is only generated under Windows. 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.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxEraseEvent}{wxeraseevent}, \helpref{Event handling overview}{eventhandlingoverview}
|
|
|
|
\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.
|
|
|
|
\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::OnKillFocus}\label{wxwindowonkillfocus}
|
|
|
|
\func{void}{OnKillFocus}{\param{wxFocusEvent\& }{event}}
|
|
|
|
Called when a window's focus is being killed.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{event}{The focus event. For more information, see \helpref{wxFocusEvent}{wxfocusevent}.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
To intercept this event, use the macro EVT\_KILL\_FOCUS in an event table definition.
|
|
|
|
Most, but not all, windows respond to this event.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxFocusEvent}{wxfocusevent}, \helpref{wxWindow::OnSetFocus}{wxwindowonsetfocus},\rtfsp
|
|
\helpref{Event handling overview}{eventhandlingoverview}
|
|
|
|
\membersection{wxWindow::OnIdle}\label{wxwindowonidle}
|
|
|
|
\func{void}{OnIdle}{\param{wxIdleEvent\& }{event}}
|
|
|
|
Provide this member function for any processing which needs to be done
|
|
when the application is idle.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxApp::OnIdle}{wxapponidle}, \helpref{wxIdleEvent}{wxidleevent}
|
|
|
|
\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 wxWindows, 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.
|
|
|
|
In a paint event handler, the application should always create a \helpref{wxPaintDC}{wxpaintdc} object.
|
|
|
|
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
|
|
ViewStart(&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.
|
|
|
|
\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.
|
|
|
|
\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::PopEventHandler}\label{wxwindowpopeventhandler}
|
|
|
|
\constfunc{wxEvtHandler*}{PopEventHandler}{\param{bool }{deleteHandler = FALSE}}
|
|
|
|
Removes and returns the top-most event handler on the event handler stack.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{deleteHandler}{If this is TRUE, the handler will be deleted after it is removed. The
|
|
default value is FALSE.}
|
|
|
|
\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
|
|
|
|
\membersection{wxWindow::PopupMenu}\label{wxwindowpopupmenu}
|
|
|
|
\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 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{See also}
|
|
|
|
\helpref{wxMenu}{wxmenu}
|
|
|
|
\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. 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}
|
|
|
|
\func{void}{PushEventHandler}{\param{wxEvtHandler* }{handler}}
|
|
|
|
Pushes this event handler onto the event stack for the window.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{handler}{Specifies the handler to be pushed.}
|
|
|
|
\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.
|
|
|
|
\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{wxWindow::SetEventHandler}{wxwindowseteventhandler},\rtfsp
|
|
\helpref{wxWindow::GetEventHandler}{wxwindowgeteventhandler},\rtfsp
|
|
\helpref{wxWindow::PopEventHandler}{wxwindowpusheventhandler},\rtfsp
|
|
\helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent},\rtfsp
|
|
\helpref{wxEvtHandler}{wxevthandler}
|
|
|
|
\membersection{wxWindow::Raise}\label{wxwindowraise}
|
|
|
|
\func{void}{Raise}{\void}
|
|
|
|
Raises the window to the top of the window hierarchy if it is a managed window (dialog
|
|
or frame).
|
|
|
|
\membersection{wxWindow::Refresh}\label{wxwindowrefresh}
|
|
|
|
\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.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{eraseBackground}{If TRUE, the background will be
|
|
erased.}
|
|
|
|
\docparam{rect}{If non-NULL, only the given rectangle will
|
|
be treated as damaged.}
|
|
|
|
\membersection{wxWindow::ReleaseMouse}\label{wxwindowreleasemouse}
|
|
|
|
\func{virtual void}{ReleaseMouse}{\void}
|
|
|
|
Releases mouse input captured with \helpref{wxWindow::CaptureMouse}{wxwindowcapturemouse}.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::CaptureMouse}{wxwindowcapturemouse}
|
|
|
|
\membersection{wxWindow::RemoveChild}\label{wxwindowremovechild}
|
|
|
|
\func{virtual void}{RemoveChild}{\param{wxWindow* }{child}}
|
|
|
|
Removes a child window. This is called automatically by window deletion
|
|
functions so should not be required by the application programmer.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\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 (e.g. a wxMiniFrame for a
|
|
floating toolbar). 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}}
|
|
|
|
\constfunc{virtual wxPoint}{ScreenToClient}{\param{const wxPoint\& }{pt}}
|
|
|
|
Converts from screen to client window coordinates.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{x}{Stores the screen x coordinate and receives the client x coordinate.}
|
|
|
|
\docparam{y}{Stores the screen x coordinate and receives the client x coordinate.}
|
|
|
|
\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::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 and move child windows accordingly.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\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 optimise painting by checking for the invalidated region. This paramter is ignored under GTK,
|
|
instead the regions to be invalidated are calculated automatically. }
|
|
|
|
\wxheading{Remarks}
|
|
|
|
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.
|
|
|
|
\membersection{wxWindow::SetAcceleratorTable}\label{wxwindowsetacceleratortable}
|
|
|
|
\func{virtual void}{SetAcceleratorTable}{\param{const wxAcceleratorTable\&}{ accel}}
|
|
|
|
Sets the accelerator table for this window. See \helpref{wxAcceleratorTable}{wxacceleratortable}.
|
|
|
|
\membersection{wxWindow::SetAutoLayout}\label{wxwindowsetautolayout}
|
|
|
|
\func{void}{SetAutoLayout}{\param{const bool}{ autoLayout}}
|
|
|
|
Determines whether the \helpref{wxWindow::Layout}{wxwindowlayout} function will
|
|
be called automatically when the window is resized. Use in connection with
|
|
\helpref{wxWindow::SetSizer}{wxwindowsetsizer} and
|
|
\helpref{wxWindow::SetConstraints}{wxwindowsetconstraints} for layouting subwindows.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{autoLayout}{Set this to TRUE if you wish the Layout function to be called
|
|
from within wxWindow::OnSize functions.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
Note that this function is actually disabled for wxWindow. It has
|
|
effect for wxDialog, wxFrame, wxPanel and wxScrolledWindow. Windows
|
|
of other types that need to invoke the Layout algorithm should provide
|
|
an EVT_SIZE handler and call
|
|
\helpref{wxWindow::Layout}{wxwindowlayout} from within it.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::SetConstraints}{wxwindowsetconstraints}
|
|
|
|
\membersection{wxWindow::SetBackgroundColour}\label{wxwindowsetbackgroundcolour}
|
|
|
|
\func{virtual void}{SetBackgroundColour}{\param{const wxColour\& }{colour}}
|
|
|
|
Sets the background colour of the window.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{colour}{The colour to be used as the background colour.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
The background colour is usually painted by the default\rtfsp
|
|
\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.
|
|
|
|
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::GetBackgroundColour}{wxwindowgetbackgroundcolour},\rtfsp
|
|
\helpref{wxWindow::SetForegroundColour}{wxwindowsetforegroundcolour},\rtfsp
|
|
\helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour},\rtfsp
|
|
\helpref{wxWindow::Clear}{wxwindowclear},\rtfsp
|
|
\helpref{wxWindow::Refresh}{wxwindowrefresh},\rtfsp
|
|
\helpref{wxWindow::OnEraseBackground}{wxwindowonerasebackground}
|
|
|
|
\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}}
|
|
|
|
Sets the window's cursor. Notice that setting the cursor for this window does
|
|
not set it for its children so you'll need to explicitly call SetCursor() for
|
|
them too if you need it.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{cursor}{Specifies the cursor that the window should normally display.}
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{::wxSetCursor}{wxsetcursor}, \helpref{wxCursor}{wxcursor}
|
|
|
|
\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::SetConstraints}\label{wxwindowsetconstraints}
|
|
|
|
\func{void}{SetConstraints}{\param{wxLayoutConstraints* }{constraints}}
|
|
|
|
Sets the window to have the given layout constraints. The window
|
|
will then own the object, and will take care of its deletion.
|
|
If an existing layout constraints object is already owned by the
|
|
window, it will be deleted.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{constraints}{The constraints to set. Pass NULL to disassociate and delete the window's
|
|
constraints.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
You must call \helpref{wxWindow::SetAutoLayout}{wxwindowsetautolayout} to tell a window to use
|
|
the constraints automatically in OnSize; otherwise, you must override OnSize and call Layout()
|
|
explicitly. When setting both a wxLayoutConstraints and a \helpref{wxSizer}{wxsizer}, only the
|
|
sizer will have effect.
|
|
|
|
\membersection{wxWindow::SetDropTarget}\label{wxwindowsetdroptarget}
|
|
|
|
\func{void}{SetDropTarget}{\param{wxDropTarget*}{ target}}
|
|
|
|
Associates a drop target with this window.
|
|
|
|
If the window already has a drop target, it is deleted.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::GetDropTarget}{wxwindowgetdroptarget},
|
|
\helpref{Drag and drop overview}{wxdndoverview}
|
|
|
|
\membersection{wxWindow::SetFocus}\label{wxwindowsetfocus}
|
|
|
|
\func{virtual void}{SetFocus}{\void}
|
|
|
|
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.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{font}{Font to associate with this window.}
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::GetFont}{wxwindowgetfont}
|
|
|
|
\membersection{wxWindow::SetForegroundColour}\label{wxwindowsetforegroundcolour}
|
|
|
|
\func{virtual void}{SetForegroundColour}{\param{const wxColour\& }{colour}}
|
|
|
|
Sets the foreground colour of the window.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{colour}{The colour to be used as the foreground colour.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
The interpretation of foreground colour is open to interpretation according
|
|
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::SetId}\label{wxwindowsetid}
|
|
|
|
\func{void}{SetId}{\param{int}{ id}}
|
|
|
|
Sets the identifier of the window.
|
|
|
|
\wxheading{Remarks}
|
|
|
|
Each window has an integer identifier. If the application has not provided one,
|
|
an identifier will be generated. Normally, the identifier should be provided
|
|
on creation and should not be modified subsequently.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::GetId}{wxwindowgetid},\rtfsp
|
|
\helpref{Window identifiers}{windowids}
|
|
|
|
\membersection{wxWindow::SetName}\label{wxwindowsetname}
|
|
|
|
\func{virtual void}{SetName}{\param{const wxString\& }{name}}
|
|
|
|
Sets the window's name.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{name}{A name to set for the window.}
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::GetName}{wxwindowgetname}
|
|
|
|
\membersection{wxWindow::SetPalette}\label{wxwindowsetpalette}
|
|
|
|
\func{virtual void}{SetPalette}{\param{wxPalette* }{palette}}
|
|
|
|
Obsolete - use \helpref{wxDC::SetPalette}{wxdcsetpalette} instead.
|
|
|
|
\membersection{wxWindow::SetScrollbar}\label{wxwindowsetscrollbar}
|
|
|
|
\func{virtual void}{SetScrollbar}{\param{int }{orientation}, \param{int }{position},\rtfsp
|
|
\param{int }{thumbSize}, \param{int }{range},\rtfsp
|
|
\param{const bool }{refresh = TRUE}}
|
|
|
|
Sets the scrollbar properties of a built-in scrollbar.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{orientation}{Determines the scrollbar whose page size is to be set. May be wxHORIZONTAL or wxVERTICAL.}
|
|
|
|
\docparam{position}{The position of the scrollbar in scroll units.}
|
|
|
|
\docparam{thumbSize}{The size of the thumb, or visible portion of the scrollbar, in scroll units.}
|
|
|
|
\docparam{range}{The maximum position of the scrollbar.}
|
|
|
|
\docparam{refresh}{TRUE to redraw the scrollbar, FALSE otherwise.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
Let's say you wish to display 50 lines of text, using the same font.
|
|
The window is sized so that you can only see 16 lines at a time.
|
|
|
|
You would use:
|
|
|
|
{\small%
|
|
\begin{verbatim}
|
|
SetScrollbar(wxVERTICAL, 0, 16, 50);
|
|
\end{verbatim}
|
|
}
|
|
|
|
Note that with the window at this size, the thumb position can never go
|
|
above 50 minus 16, or 34.
|
|
|
|
You can determine how many lines are currently visible by dividing the current view
|
|
size by the character height in pixels.
|
|
|
|
When defining your own scrollbar behaviour, you will always need to recalculate
|
|
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.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{Scrolling overview}{scrollingoverview},\rtfsp
|
|
\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}}
|
|
|
|
Sets the page size of one of the built-in scrollbars.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{orientation}{Determines the scrollbar whose page size is to be set. May be wxHORIZONTAL or wxVERTICAL.}
|
|
|
|
\docparam{pageSize}{Page size in scroll units.}
|
|
|
|
\docparam{refresh}{TRUE to redraw the scrollbar, FALSE otherwise.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
The page size of a scrollbar is the number of scroll units that the scroll thumb travels when you
|
|
click on the area above/left of or below/right of the thumb. Normally you will want a whole visible
|
|
page to be scrolled, i.e. the size of the current view (perhaps the window client size). This
|
|
value has to be adjusted when the window is resized, since the page size will have changed.
|
|
|
|
In addition to specifying how far the scroll thumb travels when paging, in Motif and some versions of Windows
|
|
the thumb changes size to reflect the page size relative to the length of the document. When the
|
|
document size is only slightly bigger than the current view (window) size, almost all of the scrollbar
|
|
will be taken up by the thumb. When the two values become the same, the scrollbar will (on some systems)
|
|
disappear.
|
|
|
|
Currently, this function should be called before SetPageRange, because of a quirk in the Windows
|
|
handling of pages and ranges.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::SetScrollPos}{wxwindowsetscrollpos},\rtfsp
|
|
\helpref{wxWindow::GetScrollPos}{wxwindowsetscrollpos},\rtfsp
|
|
\helpref{wxWindow::GetScrollPage}{wxwindowsetscrollpage},\rtfsp
|
|
\helpref{wxScrollBar}{wxscrollbar}, \helpref{wxScrolledWindow}{wxscrolledwindow}
|
|
\end{comment}
|
|
|
|
\membersection{wxWindow::SetScrollPos}\label{wxwindowsetscrollpos}
|
|
|
|
\func{virtual void}{SetScrollPos}{\param{int }{orientation}, \param{int }{pos}, \param{const bool }{refresh = TRUE}}
|
|
|
|
Sets the position of one of the built-in scrollbars.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{orientation}{Determines the scrollbar whose position is to be set. May be wxHORIZONTAL or wxVERTICAL.}
|
|
|
|
\docparam{pos}{Position in scroll units.}
|
|
|
|
\docparam{refresh}{TRUE to redraw the scrollbar, FALSE otherwise.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
This function does not directly affect the contents of the window: it is up to the
|
|
application to take note of scrollbar attributes and redraw contents accordingly.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar},\rtfsp
|
|
\helpref{wxWindow::GetScrollPos}{wxwindowsetscrollpos},\rtfsp
|
|
\helpref{wxWindow::GetScrollThumb}{wxwindowgetscrollthumb},\rtfsp
|
|
\helpref{wxScrollBar}{wxscrollbar}, \helpref{wxScrolledWindow}{wxscrolledwindow}
|
|
|
|
\begin{comment}
|
|
\membersection{wxWindow::SetScrollRange}\label{wxwindowsetscrollrange}
|
|
|
|
\func{virtual void}{SetScrollRange}{\param{int }{orientation}, \param{int }{range}, \param{const bool }{refresh = TRUE}}
|
|
|
|
Sets the range of one of the built-in scrollbars.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{orientation}{Determines the scrollbar whose range is to be set. May be wxHORIZONTAL or wxVERTICAL.}
|
|
|
|
\docparam{range}{Scroll range.}
|
|
|
|
\docparam{refresh}{TRUE to redraw the scrollbar, FALSE otherwise.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
The range of a scrollbar is the number of steps that the thumb may travel, rather than the total
|
|
object length of the scrollbar. If you are implementing a scrolling window, for example, you
|
|
would adjust the scroll range when the window is resized, by subtracting the window view size from the
|
|
total virtual window size. When the two sizes are the same (all the window is visible), the range goes to zero
|
|
and usually the scrollbar will be automatically hidden.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::SetScrollPos}{wxwindowsetscrollpos},\rtfsp
|
|
\helpref{wxWindow::SetScrollPage}{wxwindowsetscrollpage},\rtfsp
|
|
\helpref{wxWindow::GetScrollPos}{wxwindowsetscrollpos},\rtfsp
|
|
\helpref{wxWindow::GetScrollPage}{wxwindowsetscrollpage},\rtfsp
|
|
\helpref{wxScrollBar}{wxscrollbar}, \helpref{wxScrolledWindow}{wxscrolledwindow}
|
|
\end{comment}
|
|
|
|
\membersection{wxWindow::SetSize}\label{wxwindowsetsize}
|
|
|
|
\func{virtual void}{SetSize}{\param{int}{ x}, \param{int}{ y}, \param{int}{ width}, \param{int}{ height},
|
|
\param{int}{ sizeFlags = wxSIZE\_AUTO}}
|
|
|
|
\func{virtual void}{SetSize}{\param{const wxRect\&}{ rect}}
|
|
|
|
Sets the size and position of the window in pixels.
|
|
|
|
\func{virtual void}{SetSize}{\param{int}{ width}, \param{int}{ height}}
|
|
|
|
\func{virtual void}{SetSize}{\param{const wxSize\&}{ size}}
|
|
|
|
Sets the size of the window in pixels.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{x}{Required x position in pixels, or -1 to indicate that the existing
|
|
value should be used.}
|
|
|
|
\docparam{y}{Required y position in pixels, or -1 to indicate that the existing
|
|
value should be used.}
|
|
|
|
\docparam{width}{Required width in pixels, or -1 to indicate that the existing
|
|
value should be used.}
|
|
|
|
\docparam{height}{Required height position in pixels, or -1 to indicate that the existing
|
|
value should be used.}
|
|
|
|
\docparam{size}{\helpref{wxSize}{wxsize} object for setting the size.}
|
|
|
|
\docparam{rect}{\helpref{wxRect}{wxrect} object for setting the position and size.}
|
|
|
|
\docparam{sizeFlags}{Indicates the interpretation of other parameters. It is a bit list of the following:
|
|
|
|
{\bf wxSIZE\_AUTO\_WIDTH}: a -1 width value is taken to indicate
|
|
a wxWindows-supplied default width.\\
|
|
{\bf wxSIZE\_AUTO\_HEIGHT}: a -1 height value is taken to indicate
|
|
a wxWindows-supplied default width.\\
|
|
{\bf wxSIZE\_AUTO}: -1 size values are taken to indicate
|
|
a wxWindows-supplied default size.\\
|
|
{\bf wxSIZE\_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
|
|
as real dimensions, not default values.
|
|
}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
The second form is a convenience for calling the first form with default
|
|
x and y parameters, and must be used with non-default width and height values.
|
|
|
|
The first form sets the position and optionally size, of the window.
|
|
Parameters may be -1 to indicate either that a default should be supplied
|
|
by wxWindows, or that the current value of the dimension should be used.
|
|
|
|
\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}}
|
|
|
|
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.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\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{incW}{Specifies the increment for sizing the width (Motif/Xt only).}
|
|
|
|
\docparam{incH}{Specifies the increment for sizing the height (Motif/Xt only).}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
If this function is called, the user will not be able to size the window outside the
|
|
given bounds.
|
|
|
|
The resizing increments are only significant under Motif or Xt.
|
|
|
|
\membersection{wxWindow::SetSizer}\label{wxwindowsetsizer}
|
|
|
|
\func{void}{SetSizer}{\param{wxSizer* }{sizer}}
|
|
|
|
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{sizer}{The sizer to set. Pass NULL to disassociate and delete the window's
|
|
sizer.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
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::SetTitle}\label{wxwindowsettitle}
|
|
|
|
\func{virtual void}{SetTitle}{\param{const wxString\& }{title}}
|
|
|
|
Sets the window's title. Applicable only to frames and dialogs.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{title}{The window's title.}
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::GetTitle}{wxwindowgettitle}
|
|
|
|
\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::Show}\label{wxwindowshow}
|
|
|
|
\func{virtual bool}{Show}{\param{const bool}{ show}}
|
|
|
|
Shows or hides the window.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{show}{If TRUE, displays the window and brings it to the front. Otherwise,
|
|
hides the window.}
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::IsShown}{wxwindowisshown}
|
|
|
|
\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.
|
|
|
|
\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.
|
|
|
|
\wxheading{Return value}
|
|
|
|
Returns FALSE if a transfer failed.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::TransferDataFromWindow}{wxwindowtransferdatafromwindow},\rtfsp
|
|
\helpref{wxValidator}{wxvalidator}, \helpref{wxWindow::Validate}{wxwindowvalidate}
|
|
|
|
\membersection{wxWindow::Validate}\label{wxwindowvalidate}
|
|
|
|
\func{virtual bool}{Validate}{\void}
|
|
|
|
Validates the current values of the child controls using their validators.
|
|
|
|
\wxheading{Return value}
|
|
|
|
Returns FALSE if any of the validations failed.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::TransferDataFromWindow}{wxwindowtransferdatafromwindow},\rtfsp
|
|
\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.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{x}{The new x position for the cursor.}
|
|
|
|
\docparam{y}{The new y position for the cursor.}
|
|
|