aab49a0b6a
Also fixed the bad event table in helpfrm.cpp. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@18252 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
2760 lines
94 KiB
TeX
2760 lines
94 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\_FULL\_REPAINT\_ON\_RESIZE}}{Disables repainting
|
|
the window completely when its size is changed - you will have to repaint the
|
|
new window area manually if you use this style. Currently only has an effect for
|
|
Windows.}
|
|
\twocolitem{\windowstyle{wxVSCROLL}}{Use this style to enable a vertical scrollbar.}
|
|
\twocolitem{\windowstyle{wxHSCROLL}}{Use this style to enable a horizontal scrollbar.}
|
|
\twocolitem{\windowstyle{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}\label{wxwindowctor}
|
|
|
|
\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::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.
|
|
|
|
Note that wxWindows maintains the stack of windows having captured the mouse
|
|
and when the mouse is released the capture returns to the window which had had
|
|
captured it previously and it is only really released if there were no previous
|
|
window. In particular, this means that you must release the mouse as many times
|
|
as you capture it.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse}
|
|
|
|
\membersection{wxWindow::Center}\label{wxwindowcenter}
|
|
|
|
\func{void}{Center}{\param{int}{ direction}}
|
|
|
|
A synonym for \helpref{Centre}{wxwindowcentre}.
|
|
|
|
\membersection{wxWindow::CenterOnParent}\label{wxwindowcenteronparent}
|
|
|
|
\func{void}{CenterOnParent}{\param{int}{ direction}}
|
|
|
|
A synonym for \helpref{CentreOnParent}{wxwindowcentreonparent}.
|
|
|
|
\membersection{wxWindow::CenterOnScreen}\label{wxwindowcenteronscreen}
|
|
|
|
\func{void}{CenterOnScreen}{\param{int}{ direction}}
|
|
|
|
A synonym for \helpref{CentreOnScreen}{wxwindowcentreonscreen}.
|
|
|
|
\membersection{wxWindow::Centre}\label{wxwindowcentre}
|
|
|
|
\func{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}. 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}
|
|
|
|
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}
|
|
|
|
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}}
|
|
|
|
\perlnote{In wxPerl this method returns a 2-element list instead of
|
|
modifying its parameters.}
|
|
|
|
\constfunc{virtual wxPoint}{ClientToScreen}{\param{const wxPoint\&}{ pt}}
|
|
|
|
Converts to screen coordinates from coordinates relative to this window.
|
|
|
|
\docparam{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{bool}{ force = {\tt FALSE}}}
|
|
|
|
The purpose of this call is to provide a safer way of destroying a window than using
|
|
the {\it delete} operator.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{force}{{\tt FALSE} if the window's close handler should be able to veto the destruction
|
|
of this window, {\tt TRUE} if it cannot.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
Close calls the \helpref{close handler}{wxcloseevent} for the window, providing an opportunity for the window to
|
|
choose whether to destroy the window.
|
|
|
|
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::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 multiplied by 8 and then divided by the average
|
|
character height.
|
|
|
|
\wxheading{Remarks}
|
|
|
|
Dialog units are used for maintaining a dialog's proportions even if the font changes.
|
|
Dialogs created using Dialog Editor optionally use dialog units.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::ConvertDialogToPixels}{wxwindowconvertdialogtopixels}
|
|
|
|
|
|
\pythonnote{In place of a single overloaded method name, wxPython
|
|
implements the following methods:\par
|
|
\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-existent
|
|
windows.
|
|
|
|
\wxheading{Return value}
|
|
|
|
{\tt TRUE} if the window has either been successfully deleted, or it has been added
|
|
to the list of windows pending real deletion.
|
|
|
|
\membersection{wxWindow::DestroyChildren}
|
|
|
|
\func{virtual void}{DestroyChildren}{\void}
|
|
|
|
Destroys all children of a window. Called automatically by the destructor.
|
|
|
|
\membersection{wxWindow::Disable}\label{wxwindowdisable}
|
|
|
|
\func{void}{Disable}{\void}
|
|
|
|
Disables the window, same as \helpref{Enable({\tt FALSE})}{wxwindowenable}.
|
|
|
|
\wxheading{Return value}
|
|
|
|
Returns {\tt TRUE} if the window has been disabled, {\tt FALSE} if it had been
|
|
already disabled before the call to this function.
|
|
|
|
\membersection{wxWindow::DragAcceptFiles}\label{wxwindowdragacceptfiles}
|
|
|
|
\func{virtual void}{DragAcceptFiles}{\param{bool}{ accept}}
|
|
|
|
Enables or disables eligibility for drop file events (OnDropFiles).
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{accept}{If {\tt TRUE}, the window is eligible for drop file events. If {\tt FALSE}, the window
|
|
will not accept drop file events.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
Windows only.
|
|
|
|
\membersection{wxWindow::Enable}\label{wxwindowenable}
|
|
|
|
\func{virtual bool}{Enable}{\param{bool}{ enable = {\tt TRUE}}}
|
|
|
|
Enable or disable the window for user input. Note that when a parent window is
|
|
disabled, all of its children are disabled as well and they are reenabled again
|
|
when the parent is.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{enable}{If {\tt TRUE}, enables the window for input. If {\tt FALSE}, disables the window.}
|
|
|
|
\wxheading{Return value}
|
|
|
|
Returns {\tt TRUE} if the window has been enabled or disabled, {\tt FALSE} if
|
|
nothing was done, i.e. if the window had already been in the specified state.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::IsEnabled}{wxwindowisenabled},\rtfsp
|
|
\helpref{wxWindow::Disable}{wxwindowdisable}
|
|
|
|
\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::FindWindowById}\label{wxwindowfindwindowbyid}
|
|
|
|
\func{static wxWindow*}{FindWindowById}{\param{long}{ id}, \param{wxWindow*}{ parent = NULL}}
|
|
|
|
Find the first window with the given {\it id}.
|
|
|
|
If {\it parent} is NULL, the search will start from all top-level
|
|
frames and dialog boxes; if non-NULL, the search will be limited to the given window hierarchy.
|
|
The search is recursive in both cases.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{FindWindow}{wxwindowfindwindow}
|
|
|
|
\membersection{wxWindow::FindWindowByName}\label{wxwindowfindwindowbyname}
|
|
|
|
\func{static wxWindow*}{FindWindowByName}{\param{const wxString\&}{ name}, \param{wxWindow*}{ parent = NULL}}
|
|
|
|
Find a window by its name (as given in a window constructor or {\bf Create} function call).
|
|
If {\it parent} is NULL, the search will start from all top-level
|
|
frames and dialog boxes; if non-NULL, the search will be limited to the given window hierarchy.
|
|
The search is recursive in both cases.
|
|
|
|
If no window with such name is found,
|
|
\helpref{FindWindowByLabel}{wxwindowfindwindowbylabel} is called.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{FindWindow}{wxwindowfindwindow}
|
|
|
|
\membersection{wxWindow::FindWindowByLabel}\label{wxwindowfindwindowbylabel}
|
|
|
|
\func{static wxWindow*}{FindWindowByLabel}{\param{const wxString\&}{ label}, \param{wxWindow*}{ parent = NULL}}
|
|
|
|
Find a window by its label. Depending on the type of window, the label may be a window title
|
|
or panel item label. If {\it parent} is NULL, the search will start from all top-level
|
|
frames and dialog boxes; if non-NULL, the search will be limited to the given window hierarchy.
|
|
The search is recursive in both cases.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{FindWindow}{wxwindowfindwindow}
|
|
|
|
\membersection{wxWindow::Fit}\label{wxwindowfit}
|
|
|
|
\func{virtual void}{Fit}{\void}
|
|
|
|
Sizes the window so that it fits around its subwindows. This function won't do
|
|
anything if there are no subwindows.
|
|
|
|
\membersection{wxWindow::FitInside}\label{wxwindowfitinside}
|
|
|
|
\func{virtual void}{FitInside}{\void}
|
|
|
|
Similar to \helpref{Fit}{wxwindowfit}, but sizes the interior (virtual) size
|
|
of a window. Mainly useful with scrolled windows to reset scrollbars after
|
|
sizing changes that do not trigger a size event, and/or scrolled windows without
|
|
an interior sizer. This function similarly won't do anything if there are no
|
|
subwindows.
|
|
|
|
\membersection{wxWindow::Freeze}\label{wxwindowfreeze}
|
|
|
|
\func{virtual void}{Freeze}{\void}
|
|
|
|
Freezes the window or, in other words, prevents any updates from taking place
|
|
on screen, the window is not redrawn at all. \helpref{Thaw}{wxwindowthaw} must
|
|
be called to reenable window redrawing.
|
|
|
|
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::GetAdjustedBestSize}\label{wxwindowgetadjustedbestsize}
|
|
|
|
\constfunc{wxSize}{GetAdjustedBestSize}{\void}
|
|
|
|
This method is similar to \helpref{GetBestSize}{wxwindowgetbestsize}, except
|
|
in one thing. GetBestSize should return the minimum untruncated size of the
|
|
window, while this method will return the largest of BestSize and any user
|
|
specified minimum size. ie. it is the minimum size the window should currently
|
|
be drawn at, not the minimal size it can possibly tolerate.
|
|
|
|
\membersection{wxWindow::GetBackgroundColour}\label{wxwindowgetbackgroundcolour}
|
|
|
|
\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}
|
|
|
|
\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::GetCapture}\label{wxwindowgetcapture}
|
|
|
|
\func{static wxWindow *}{GetCapture}{\void}
|
|
|
|
Returns the currently captured window.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::HasCapture}{wxwindowhascapture},
|
|
\helpref{wxWindow::CaptureMouse}{wxwindowcapturemouse},
|
|
\helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse},
|
|
\helpref{wxMouseCaptureChangedEvent}{wxmousecapturechangedevent}
|
|
|
|
\membersection{wxWindow::GetCharHeight}
|
|
|
|
\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}}
|
|
|
|
\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 area which may be drawn on by the programmer,
|
|
excluding title bar, border, scrollbars, 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 GetClientSizeTuple()}}{Returns a 2-tuple of (width, height)}
|
|
\twocolitem{{\bf GetClientSize()}}{Returns a wxSize object}
|
|
\end{twocollist}}
|
|
}
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{GetSize}{wxwindowgetsize}
|
|
\helpref{GetVirtualSize}{wxwindowgetvirtualsize}
|
|
|
|
\membersection{wxWindow::GetConstraints}\label{wxwindowgetconstraints}
|
|
|
|
\constfunc{wxLayoutConstraints*}{GetConstraints}{\void}
|
|
|
|
Returns a pointer to the window's layout constraints, or NULL if there are none.
|
|
|
|
\membersection{wxWindow::GetContainingSizer}\label{wxwindowgetcontainingsizer}
|
|
|
|
\constfunc{const wxSizer *}{GetContainingSizer}{\void}
|
|
|
|
Return the sizer that this window is a member of, if any, otherwise
|
|
{\tt NULL}.
|
|
|
|
\membersection{wxWindow::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::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 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}\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, {\bf Widget} for Motif or {\bf GtkWidget} for GTK.
|
|
|
|
\pythonnote{This method will return an integer in wxPython.}
|
|
|
|
\perlnote{This method will return an integer in wxPerl.}
|
|
|
|
\membersection{wxWindow::GetHelpText}\label{wxwindowgethelptext}
|
|
|
|
\constfunc{virtual wxString}{GetHelpText}{\void}
|
|
|
|
Gets the help text to be used as context-sensitive help for this window.
|
|
|
|
Note that the text is actually stored by the current \helpref{wxHelpProvider}{wxhelpprovider} implementation,
|
|
and not in the window object itself.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{SetHelpText}{wxwindowsethelptext}, \helpref{wxHelpProvider}{wxhelpprovider}
|
|
|
|
\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::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::GetPosition}\label{wxwindowgetposition}
|
|
|
|
\constfunc{virtual void}{GetPosition}{\param{int* }{x}, \param{int* }{y}}
|
|
|
|
\constfunc{wxPoint}{GetPosition}{\void}
|
|
|
|
This gets the position of the window in pixels, relative to the parent window
|
|
for the child windows or relative to the display origin for the top level
|
|
windows.
|
|
|
|
\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}}
|
|
}
|
|
|
|
\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}
|
|
|
|
\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,
|
|
including title bar, border, scrollbars, etc.
|
|
|
|
\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}}
|
|
}
|
|
|
|
\perlnote{In wxPerl there are two methods instead of a single overloaded
|
|
method:\par
|
|
\indented{2cm}{\begin{twocollist}
|
|
\twocolitem{{\bf GetSize()}}{Returns a Wx::Size}
|
|
\twocolitem{{\bf GetSizeWH()}}{Returns a 2-element list
|
|
{\tt ( width, height )}}
|
|
\end{twocollist}
|
|
}}
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{GetClientSize}{wxwindowgetclientsize},\rtfsp
|
|
\helpref{GetVirtualSize}{wxwindowgetvirtualsize}
|
|
|
|
\membersection{wxWindow::GetSizer}\label{wxwindowgetsizer}
|
|
|
|
\constfunc{wxSizer *}{GetSizer}{\void}
|
|
|
|
Return the sizer associated with the window by a previous call to
|
|
\helpref{SetSizer()}{wxwindowsetsizer} or {\tt NULL}.
|
|
|
|
\membersection{wxWindow::GetTextExtent}\label{wxwindowgettextextent}
|
|
|
|
\constfunc{virtual void}{GetTextExtent}{\param{const wxString\& }{string}, \param{int* }{x}, \param{int* }{y},
|
|
\param{int* }{descent = NULL}, \param{int* }{externalLeading = NULL},
|
|
\param{const wxFont* }{font = NULL}, \param{bool}{ use16 = {\tt 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 {\tt TRUE}, {\it string} contains 16-bit characters. The default is {\tt FALSE}.}
|
|
|
|
|
|
\pythonnote{In place of a single overloaded method name, wxPython
|
|
implements the following methods:\par
|
|
\indented{2cm}{\begin{twocollist}
|
|
\twocolitem{{\bf GetTextExtent(string)}}{Returns a 2-tuple, (width, height)}
|
|
\twocolitem{{\bf GetFullTextExtent(string, font=NULL)}}{Returns a
|
|
4-tuple, (width, height, descent, externalLeading) }
|
|
\end{twocollist}}
|
|
}
|
|
|
|
\perlnote{In wxPerl this method takes only the {\tt string} and optionally
|
|
{\tt font} parameters, and returns a 4-element list
|
|
{\tt ( x, y, descent, externalLeading )}.}
|
|
|
|
\membersection{wxWindow::GetTitle}\label{wxwindowgettitle}
|
|
|
|
\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{wxPaintEvent}{wxpaintevent} handler.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxRegion}{wxregion},\rtfsp
|
|
\helpref{wxRegionIterator}{wxregioniterator}
|
|
|
|
\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::GetVirtualSize}\label{wxwindowgetvirtualsize}
|
|
|
|
\constfunc{void}{GetVirtualSize}{\param{int* }{width}, \param{int* }{height}}
|
|
|
|
\constfunc{wxSize}{GetVirtualSize}{\void}
|
|
|
|
This gets the virtual size of the window in pixels.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{width}{Receives the window virtual width.}
|
|
|
|
\docparam{height}{Receives the window virtual height.}
|
|
|
|
\helpref{GetSize}{wxwindowgetsize},\rtfsp
|
|
\helpref{GetClientSize}{wxwindowgetclientsize}
|
|
|
|
\membersection{wxWindow::GetWindowStyleFlag}\label{wxwindowgetwindowstyleflag}
|
|
|
|
\constfunc{long}{GetWindowStyleFlag}{\void}
|
|
|
|
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::HasCapture}\label{wxwindowhascapture}
|
|
|
|
\constfunc{virtual bool}{HasCapture}{\void}
|
|
|
|
Returns TRUE if this window has the current mouse capture.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::CaptureMouse}{wxwindowcapturemouse},
|
|
\helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse},
|
|
\helpref{wxMouseCaptureChangedEvent}{wxmousecapturechangedevent}
|
|
|
|
\membersection{wxWindow::Hide}\label{wxwindowhide}
|
|
|
|
\func{bool}{Hide}{\void}
|
|
|
|
Equivalent to calling \helpref{Show}{wxwindowshow}({\tt FALSE}).
|
|
|
|
\membersection{wxWindow::InitDialog}\label{wxwindowinitdialog}
|
|
|
|
\func{void}{InitDialog}{\void}
|
|
|
|
Sends an {\tt wxEVT\_INIT\_DIALOG} event, whose handler usually transfers data
|
|
to the dialog via validators.
|
|
|
|
\membersection{wxWindow::IsEnabled}\label{wxwindowisenabled}
|
|
|
|
\constfunc{virtual bool}{IsEnabled}{\void}
|
|
|
|
Returns {\tt TRUE} if the window is enabled for input, {\tt 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 {\tt TRUE} if the given point or rectangle area has been exposed since the
|
|
last repaint. Call this in an paint event handler to optimize redrawing by
|
|
only redrawing those areas, which have been exposed.
|
|
|
|
\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 {\tt TRUE} if the window is retained, {\tt FALSE} otherwise.
|
|
|
|
\wxheading{Remarks}
|
|
|
|
Retained windows are only available on X platforms.
|
|
|
|
\membersection{wxWindow::IsShown}\label{wxwindowisshown}
|
|
|
|
\constfunc{virtual bool}{IsShown}{\void}
|
|
|
|
Returns {\tt TRUE} if the window is shown, {\tt FALSE} if it has been hidden.
|
|
|
|
\membersection{wxWindow::IsTopLevel}\label{wxwindowistoplevel}
|
|
|
|
\constfunc{bool}{IsTopLevel}{\void}
|
|
|
|
Returns {\tt TRUE} if the given window is a top-level one. Currently all frames and
|
|
dialogs are considered to be top-level windows (even if they have a parent
|
|
window).
|
|
|
|
\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}: when auto
|
|
layout is on, this function gets called automatically when the window is resized.
|
|
|
|
\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}
|
|
|
|
{\tt TRUE} if the operation succeeded, otherwise {\tt 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{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 {\tt TRUE}, this call disables all other windows in the application so that
|
|
the user can only interact with this window. If {\tt FALSE}, the effect is reversed.}
|
|
|
|
\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}}
|
|
}
|
|
|
|
%% VZ: wxWindow::OnXXX() functions should not be documented but I'm leaving
|
|
%% the old docs here in case we want to move any still needed bits to
|
|
%% the right location (i.e. probably the corresponding events docs)
|
|
%%
|
|
%% \membersection{wxWindow::OnActivate}\label{wxwindowonactivate}
|
|
%%
|
|
%% \func{void}{OnActivate}{\param{wxActivateEvent\&}{ event}}
|
|
%%
|
|
%% Called when a window is activated or deactivated.
|
|
%%
|
|
%% \wxheading{Parameters}
|
|
%%
|
|
%% \docparam{event}{Object containing activation information.}
|
|
%%
|
|
%% \wxheading{Remarks}
|
|
%%
|
|
%% If the window is being activated, \helpref{wxActivateEvent::GetActive}{wxactivateeventgetactive} returns {\tt TRUE},
|
|
%% otherwise it returns {\tt FALSE} (it is being deactivated).
|
|
%%
|
|
%% \wxheading{See also}
|
|
%%
|
|
%% \helpref{wxActivateEvent}{wxactivateevent},\rtfsp
|
|
%% \helpref{Event handling overview}{eventhandlingoverview}
|
|
%%
|
|
%% \membersection{wxWindow::OnChar}\label{wxwindowonchar}
|
|
%%
|
|
%% \func{void}{OnChar}{\param{wxKeyEvent\&}{ event}}
|
|
%%
|
|
%% Called when the user has pressed a key that is not a modifier (SHIFT, CONTROL or ALT).
|
|
%%
|
|
%% \wxheading{Parameters}
|
|
%%
|
|
%% \docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
|
|
%% details about this class.}
|
|
%%
|
|
%% \wxheading{Remarks}
|
|
%%
|
|
%% This member function is called in response to a keypress. To intercept this event,
|
|
%% use the EVT\_CHAR macro in an event table definition. Your {\bf OnChar} handler may call this
|
|
%% default function to achieve default keypress functionality.
|
|
%%
|
|
%% Note that the ASCII values do not have explicit key codes: they are passed as ASCII
|
|
%% values.
|
|
%%
|
|
%% Note that not all keypresses can be intercepted this way. If you wish to intercept modifier
|
|
%% keypresses, then you will need to use \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown} or
|
|
%% \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup}.
|
|
%%
|
|
%% Most, but not all, windows allow keypresses to be intercepted.
|
|
%%
|
|
%% {\bf Tip:} be sure to call {\tt event.Skip()} for events that you don't process in this function,
|
|
%% otherwise menu shortcuts may cease to work under Windows.
|
|
%%
|
|
%% \wxheading{See also}
|
|
%%
|
|
%% \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown}, \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup},\rtfsp
|
|
%% \helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
|
|
%% \helpref{Event handling overview}{eventhandlingoverview}
|
|
%%
|
|
%% \membersection{wxWindow::OnCharHook}\label{wxwindowoncharhook}
|
|
%%
|
|
%% \func{void}{OnCharHook}{\param{wxKeyEvent\&}{ event}}
|
|
%%
|
|
%% This member is called to allow the window to intercept keyboard events
|
|
%% before they are processed by child windows.
|
|
%%
|
|
%% \wxheading{Parameters}
|
|
%%
|
|
%% \docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
|
|
%% details about this class.}
|
|
%%
|
|
%% \wxheading{Remarks}
|
|
%%
|
|
%% This member function is called in response to a keypress, if the window is active. To intercept this event,
|
|
%% use the EVT\_CHAR\_HOOK macro in an event table definition. If you do not process a particular
|
|
%% keypress, call \helpref{wxEvent::Skip}{wxeventskip} to allow default processing.
|
|
%%
|
|
%% An example of using this function is in the implementation of escape-character processing for wxDialog,
|
|
%% where pressing ESC dismisses the dialog by {\bf OnCharHook} 'forging' a cancel button press event.
|
|
%%
|
|
%% Note that the ASCII values do not have explicit key codes: they are passed as ASCII
|
|
%% values.
|
|
%%
|
|
%% This function is only relevant to top-level windows (frames and dialogs), and under
|
|
%% Windows only. Under GTK the normal EVT\_CHAR\_ event has the functionality, i.e.
|
|
%% you can intercepts it and if you don't call \helpref{wxEvent::Skip}{wxeventskip}
|
|
%% the window won't get the event.
|
|
%%
|
|
%% \wxheading{See also}
|
|
%%
|
|
%% \helpref{wxKeyEvent}{wxkeyevent},\rtfsp
|
|
%% \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
|
|
%% %% GD: OnXXX functions are not documented
|
|
%% %%\helpref{wxApp::OnCharHook}{wxapponcharhook},\rtfsp
|
|
%% \helpref{Event handling overview}{eventhandlingoverview}
|
|
%%
|
|
%% \membersection{wxWindow::OnCommand}\label{wxwindowoncommand}
|
|
%%
|
|
%% \func{virtual void}{OnCommand}{\param{wxEvtHandler\& }{object}, \param{wxCommandEvent\& }{event}}
|
|
%%
|
|
%% This virtual member function is called if the control does not handle the command event.
|
|
%%
|
|
%% \wxheading{Parameters}
|
|
%%
|
|
%% \docparam{object}{Object receiving the command event.}
|
|
%%
|
|
%% \docparam{event}{Command event}
|
|
%%
|
|
%% \wxheading{Remarks}
|
|
%%
|
|
%% This virtual function is provided mainly for backward compatibility. You can also intercept commands
|
|
%% from child controls by using an event table, with identifiers or identifier ranges to identify
|
|
%% the control(s) in question.
|
|
%%
|
|
%% \wxheading{See also}
|
|
%%
|
|
%% \helpref{wxCommandEvent}{wxcommandevent},\rtfsp
|
|
%% \helpref{Event handling overview}{eventhandlingoverview}
|
|
%%
|
|
%% \membersection{wxWindow::OnClose}\label{wxwindowonclose}
|
|
%%
|
|
%% \func{virtual bool}{OnClose}{\void}
|
|
%%
|
|
%% Called when the user has tried to close a a frame
|
|
%% or dialog box using the window manager (X) or system menu (Windows).
|
|
%%
|
|
%% {\bf Note:} This is an obsolete function.
|
|
%% It is superseded by the \helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow} event
|
|
%% handler.
|
|
%%
|
|
%% \wxheading{Return value}
|
|
%%
|
|
%% If {\tt TRUE} is returned by OnClose, the window will be deleted by the system, otherwise the
|
|
%% attempt will be ignored. Do not delete the window from within this handler, although
|
|
%% you may delete other windows.
|
|
%%
|
|
%% \wxheading{See also}
|
|
%%
|
|
%% \helpref{Window deletion overview}{windowdeletionoverview},\rtfsp
|
|
%% \helpref{wxWindow::Close}{wxwindowclose},\rtfsp
|
|
%% \helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow},\rtfsp
|
|
%% \helpref{wxCloseEvent}{wxcloseevent}
|
|
%%
|
|
%% \membersection{wxWindow::OnKeyDown}\label{wxwindowonkeydown}
|
|
%%
|
|
%% \func{void}{OnKeyDown}{\param{wxKeyEvent\&}{ event}}
|
|
%%
|
|
%% Called when the user has pressed a key, before it is translated into an ASCII value using other
|
|
%% modifier keys that might be pressed at the same time.
|
|
%%
|
|
%% \wxheading{Parameters}
|
|
%%
|
|
%% \docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
|
|
%% details about this class.}
|
|
%%
|
|
%% \wxheading{Remarks}
|
|
%%
|
|
%% This member function is called in response to a key down event. To intercept this event,
|
|
%% use the EVT\_KEY\_DOWN macro in an event table definition. Your {\bf OnKeyDown} handler may call this
|
|
%% default function to achieve default keypress functionality.
|
|
%%
|
|
%% Note that not all keypresses can be intercepted this way. If you wish to intercept special
|
|
%% keys, such as shift, control, and function keys, then you will need to use \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown} or
|
|
%% \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup}.
|
|
%%
|
|
%% Most, but not all, windows allow keypresses to be intercepted.
|
|
%%
|
|
%% {\bf Tip:} be sure to call {\tt event.Skip()} for events that you don't process in this function,
|
|
%% otherwise menu shortcuts may cease to work under Windows.
|
|
%%
|
|
%% \wxheading{See also}
|
|
%%
|
|
%% \helpref{wxWindow::OnChar}{wxwindowonchar}, \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup},\rtfsp
|
|
%% \helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
|
|
%% \helpref{Event handling overview}{eventhandlingoverview}
|
|
%%
|
|
%% \membersection{wxWindow::OnKeyUp}\label{wxwindowonkeyup}
|
|
%%
|
|
%% \func{void}{OnKeyUp}{\param{wxKeyEvent\&}{ event}}
|
|
%%
|
|
%% Called when the user has released a key.
|
|
%%
|
|
%% \wxheading{Parameters}
|
|
%%
|
|
%% \docparam{event}{Object containing keypress information. See \helpref{wxKeyEvent}{wxkeyevent} for
|
|
%% details about this class.}
|
|
%%
|
|
%% \wxheading{Remarks}
|
|
%%
|
|
%% This member function is called in response to a key up event. To intercept this event,
|
|
%% use the EVT\_KEY\_UP macro in an event table definition. Your {\bf OnKeyUp} handler may call this
|
|
%% default function to achieve default keypress functionality.
|
|
%%
|
|
%% Note that not all keypresses can be intercepted this way. If you wish to intercept special
|
|
%% keys, such as shift, control, and function keys, then you will need to use \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown} or
|
|
%% \helpref{wxWindow::OnKeyUp}{wxwindowonkeyup}.
|
|
%%
|
|
%% Most, but not all, windows allow key up events to be intercepted.
|
|
%%
|
|
%% \wxheading{See also}
|
|
%%
|
|
%% \helpref{wxWindow::OnChar}{wxwindowonchar}, \helpref{wxWindow::OnKeyDown}{wxwindowonkeydown},\rtfsp
|
|
%% \helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnCharHook}{wxwindowoncharhook},\rtfsp
|
|
%% \helpref{Event handling overview}{eventhandlingoverview}
|
|
%%
|
|
%% \membersection{wxWindow::OnInitDialog}\label{wxwindowoninitdialog}
|
|
%%
|
|
%% \func{void}{OnInitDialog}{\param{wxInitDialogEvent\&}{ event}}
|
|
%%
|
|
%% Default handler for the wxEVT\_INIT\_DIALOG event. Calls \helpref{wxWindow::TransferDataToWindow}{wxwindowtransferdatatowindow}.
|
|
%%
|
|
%% \wxheading{Parameters}
|
|
%%
|
|
%% \docparam{event}{Dialog initialisation event.}
|
|
%%
|
|
%% \wxheading{Remarks}
|
|
%%
|
|
%% Gives the window the default behaviour of transferring data to child controls via
|
|
%% the validator that each control has.
|
|
%%
|
|
%% \wxheading{See also}
|
|
%%
|
|
%% \helpref{wxValidator}{wxvalidator}, \helpref{wxWindow::TransferDataToWindow}{wxwindowtransferdatatowindow}
|
|
%%
|
|
%% \membersection{wxWindow::OnMenuCommand}\label{wxwindowonmenucommand}
|
|
%%
|
|
%% \func{void}{OnMenuCommand}{\param{wxCommandEvent\& }{event}}
|
|
%%
|
|
%% Called when a menu command is received from a menu bar.
|
|
%%
|
|
%% \wxheading{Parameters}
|
|
%%
|
|
%% \docparam{event}{The menu command event. For more information, see \helpref{wxCommandEvent}{wxcommandevent}.}
|
|
%%
|
|
%% \wxheading{Remarks}
|
|
%%
|
|
%% A function with this name doesn't actually exist; you can choose any member function to receive
|
|
%% menu command events, using the EVT\_COMMAND macro for individual commands or EVT\_COMMAND\_RANGE for
|
|
%% a range of commands.
|
|
%%
|
|
%% \wxheading{See also}
|
|
%%
|
|
%% \helpref{wxCommandEvent}{wxcommandevent},\rtfsp
|
|
%% \helpref{wxWindow::OnMenuHighlight}{wxwindowonmenuhighlight},\rtfsp
|
|
%% \helpref{Event handling overview}{eventhandlingoverview}
|
|
%%
|
|
%% \membersection{wxWindow::OnMenuHighlight}\label{wxwindowonmenuhighlight}
|
|
%%
|
|
%% \func{void}{OnMenuHighlight}{\param{wxMenuEvent\& }{event}}
|
|
%%
|
|
%% Called when a menu select is received from a menu bar: that is, the
|
|
%% mouse cursor is over a menu item, but the left mouse button has not been
|
|
%% pressed.
|
|
%%
|
|
%% \wxheading{Parameters}
|
|
%%
|
|
%% \docparam{event}{The menu highlight event. For more information, see \helpref{wxMenuEvent}{wxmenuevent}.}
|
|
%%
|
|
%% \wxheading{Remarks}
|
|
%%
|
|
%% You can choose any member function to receive
|
|
%% menu select events, using the EVT\_MENU\_HIGHLIGHT macro for individual menu items or EVT\_MENU\_HIGHLIGHT\_ALL macro
|
|
%% for all menu items.
|
|
%%
|
|
%% The default implementation for \helpref{wxFrame::OnMenuHighlight}{wxframeonmenuhighlight} displays help
|
|
%% text in the first field of the status bar.
|
|
%%
|
|
%% This function was known as {\bf OnMenuSelect} in earlier versions of 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.
|
|
%%
|
|
%% Note that In a paint event handler, the application must {\it always} create a \helpref{wxPaintDC}{wxpaintdc} object,
|
|
%% even if you do not use it. Otherwise, under MS Windows, refreshing for this and other windows will go wrong.
|
|
%%
|
|
%% For example:
|
|
%%
|
|
%% \small{%
|
|
%% \begin{verbatim}
|
|
%% void MyWindow::OnPaint(wxPaintEvent\& event)
|
|
%% {
|
|
%% wxPaintDC dc(this);
|
|
%%
|
|
%% DrawMyDocument(dc);
|
|
%% }
|
|
%% \end{verbatim}
|
|
%% }%
|
|
%%
|
|
%% You can optimize painting by retrieving the rectangles
|
|
%% that have been damaged and only repainting these. The rectangles are in
|
|
%% terms of the client area, and are unscrolled, so you will need to do
|
|
%% some calculations using the current view position to obtain logical,
|
|
%% scrolled units.
|
|
%%
|
|
%% Here is an example of using the \helpref{wxRegionIterator}{wxregioniterator} class:
|
|
%%
|
|
%% {\small%
|
|
%% \begin{verbatim}
|
|
%% // Called when window needs to be repainted.
|
|
%% void MyWindow::OnPaint(wxPaintEvent\& event)
|
|
%% {
|
|
%% wxPaintDC dc(this);
|
|
%%
|
|
%% // Find Out where the window is scrolled to
|
|
%% int vbX,vbY; // Top left corner of client
|
|
%% GetViewStart(&vbX,&vbY);
|
|
%%
|
|
%% int vX,vY,vW,vH; // Dimensions of client area in pixels
|
|
%% wxRegionIterator upd(GetUpdateRegion()); // get the update rect list
|
|
%%
|
|
%% while (upd)
|
|
%% {
|
|
%% vX = upd.GetX();
|
|
%% vY = upd.GetY();
|
|
%% vW = upd.GetW();
|
|
%% vH = upd.GetH();
|
|
%%
|
|
%% // Alternatively we can do this:
|
|
%% // wxRect rect;
|
|
%% // upd.GetRect(&rect);
|
|
%%
|
|
%% // Repaint this rectangle
|
|
%% ...some code...
|
|
%%
|
|
%% upd ++ ;
|
|
%% }
|
|
%% }
|
|
%% \end{verbatim}
|
|
%% }%
|
|
%%
|
|
%% \wxheading{See also}
|
|
%%
|
|
%% \helpref{wxPaintEvent}{wxpaintevent},\rtfsp
|
|
%% \helpref{wxPaintDC}{wxpaintdc},\rtfsp
|
|
%% \helpref{Event handling overview}{eventhandlingoverview}
|
|
%%
|
|
%% \membersection{wxWindow::OnScroll}\label{wxwindowonscroll}
|
|
%%
|
|
%% \func{void}{OnScroll}{\param{wxScrollWinEvent\& }{event}}
|
|
%%
|
|
%% Called when a scroll window event is received from one of the window's built-in scrollbars.
|
|
%%
|
|
%% \wxheading{Parameters}
|
|
%%
|
|
%% \docparam{event}{Command event. Retrieve the new scroll position by
|
|
%% calling \helpref{wxScrollEvent::GetPosition}{wxscrolleventgetposition}, and the
|
|
%% scrollbar orientation by calling \helpref{wxScrollEvent::GetOrientation}{wxscrolleventgetorientation}.}
|
|
%%
|
|
%% \wxheading{Remarks}
|
|
%%
|
|
%% Note that it is not possible to distinguish between horizontal and vertical scrollbars
|
|
%% until the function is executing (you can't have one function for vertical, another
|
|
%% for horizontal events).
|
|
%%
|
|
%% \wxheading{See also}
|
|
%%
|
|
%% \helpref{wxScrollWinEvent}{wxscrollwinevent},\rtfsp
|
|
%% \helpref{Event handling overview}{eventhandlingoverview}
|
|
%%
|
|
%% \membersection{wxWindow::OnSetFocus}\label{wxwindowonsetfocus}
|
|
%%
|
|
%% \func{void}{OnSetFocus}{\param{wxFocusEvent\& }{event}}
|
|
%%
|
|
%% Called when a window's focus is being set.
|
|
%%
|
|
%% \wxheading{Parameters}
|
|
%%
|
|
%% \docparam{event}{The focus event. For more information, see \helpref{wxFocusEvent}{wxfocusevent}.}
|
|
%%
|
|
%% \wxheading{Remarks}
|
|
%%
|
|
%% To intercept this event, use the macro EVT\_SET\_FOCUS in an event table definition.
|
|
%%
|
|
%% Most, but not all, windows respond to this event.
|
|
%%
|
|
%% \wxheading{See also}
|
|
%%
|
|
%% \helpref{wxFocusEvent}{wxfocusevent}, \helpref{wxWindow::OnKillFocus}{wxwindowonkillfocus},\rtfsp
|
|
%% \helpref{Event handling overview}{eventhandlingoverview}
|
|
%%
|
|
%% \membersection{wxWindow::OnSize}\label{wxwindowonsize}
|
|
%%
|
|
%% \func{void}{OnSize}{\param{wxSizeEvent\& }{event}}
|
|
%%
|
|
%% Called when the window has been resized. This is not a virtual function; you should
|
|
%% provide your own non-virtual OnSize function and direct size events to it using EVT\_SIZE
|
|
%% in an event table definition.
|
|
%%
|
|
%% \wxheading{Parameters}
|
|
%%
|
|
%% \docparam{event}{Size event. For more information, see \helpref{wxSizeEvent}{wxsizeevent}.}
|
|
%%
|
|
%% \wxheading{Remarks}
|
|
%%
|
|
%% You may wish to use this for frames to resize their child windows as appropriate.
|
|
%%
|
|
%% Note that the size passed is of
|
|
%% the whole window: call \helpref{wxWindow::GetClientSize}{wxwindowgetclientsize} for the area which may be
|
|
%% used by the application.
|
|
%%
|
|
%% When a window is resized, usually only a small part of the window is damaged and you
|
|
%% may only need to repaint that area. However, if your drawing depends on the size of the window,
|
|
%% you may need to clear the DC explicitly and repaint the whole window. In which case, you
|
|
%% may need to call \helpref{wxWindow::Refresh}{wxwindowrefresh} to invalidate the entire window.
|
|
%%
|
|
%% \wxheading{See also}
|
|
%%
|
|
%% \helpref{wxSizeEvent}{wxsizeevent},\rtfsp
|
|
%% \helpref{Event handling overview}{eventhandlingoverview}
|
|
%%
|
|
%% \membersection{wxWindow::OnSysColourChanged}\label{wxwindowonsyscolourchanged}
|
|
%%
|
|
%% \func{void}{OnSysColourChanged}{\param{wxOnSysColourChangedEvent\& }{event}}
|
|
%%
|
|
%% Called when the user has changed the system colours. Windows only.
|
|
%%
|
|
%% \wxheading{Parameters}
|
|
%%
|
|
%% \docparam{event}{System colour change event. For more information, see \helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent}.}
|
|
%%
|
|
%% \wxheading{See also}
|
|
%%
|
|
%% \helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent},\rtfsp
|
|
%% \helpref{Event handling overview}{eventhandlingoverview}
|
|
|
|
\membersection{wxWindow::PopEventHandler}\label{wxwindowpopeventhandler}
|
|
|
|
\constfunc{wxEvtHandler*}{PopEventHandler}{\param{bool }{deleteHandler = {\tt FALSE}}}
|
|
|
|
Removes and returns the top-most event handler on the event handler stack.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{deleteHandler}{If this is {\tt TRUE}, the handler will be deleted after it is removed. The
|
|
default value is {\tt 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{bool}{ eraseBackground = {\tt TRUE}}, \param{const wxRect* }{rect
|
|
= NULL}}
|
|
|
|
Causes a message or event to be generated to repaint the
|
|
window.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{eraseBackground}{If {\tt TRUE}, the background will be
|
|
erased.}
|
|
|
|
\docparam{rect}{If non-NULL, only the given rectangle will
|
|
be treated as damaged.}
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::RefreshRect}{wxwindowrefreshrect}
|
|
|
|
\membersection{wxWindow::RefreshRect}\label{wxwindowrefreshrect}
|
|
|
|
\func{virtual void}{Refresh}{\param{const wxRect\& }{rect}}
|
|
|
|
Redraws the contents of the given rectangle: the area inside it will be
|
|
repainted.
|
|
|
|
This is the same as \helpref{Refresh}{wxwindowrefresh} but has a nicer syntax.
|
|
|
|
\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},
|
|
\helpref{wxWindow::HasCapture}{wxwindowhascapture},
|
|
\helpref{wxWindow::ReleaseMouse}{wxwindowreleasemouse},
|
|
\helpref{wxMouseCaptureChangedEvent}{wxmousecapturechangedevent}
|
|
|
|
\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::RemoveEventHandler}\label{wxwindowremoveeventhandler}
|
|
|
|
\func{bool}{RemoveEventHandler}{\param{wxEvtHandler *}{handler}}
|
|
|
|
Find the given {\it handler} in the windows event handler chain and remove (but
|
|
not delete) it from it.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{handler}{The event handler to remove, must be non {\tt NULL} and
|
|
must be present in this windows event handlers chain}
|
|
|
|
\wxheading{Return value}
|
|
|
|
Returns {\tt TRUE} if it was found and {\tt FALSE} otherwise (this also results
|
|
in an assert failure so this function should only be called when the
|
|
handler is supposed to be there).
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{PushEventHandler}{wxwindowpusheventhandler},\rtfsp
|
|
\helpref{PopEventHandler}{wxwindowpopeventhandler}
|
|
|
|
\membersection{wxWindow::Reparent}\label{wxwindowreparent}
|
|
|
|
\func{virtual bool}{Reparent}{\param{wxWindow* }{newParent}}
|
|
|
|
Reparents the window, i.e the window will be removed from its
|
|
current parent window (e.g. a non-standard toolbar in a wxFrame)
|
|
and then re-inserted into another. 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::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 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 optimize painting by checking for the invalidated region. This parameter is ignored under GTK.}
|
|
|
|
\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{bool}{ autoLayout}}
|
|
|
|
Determines whether the \helpref{wxWindow::Layout}{wxwindowlayout} function will
|
|
be called automatically when the window is resized. It is called implicitly by
|
|
\helpref{wxWindow::SetSizer}{wxwindowsetsizer} but if you use
|
|
\helpref{wxWindow::SetConstraints}{wxwindowsetconstraints} you should call it
|
|
manually or otherwise the window layout won't be correctly updated when its
|
|
size changes.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{autoLayout}{Set this to {\tt TRUE} if you wish the Layout function to be called
|
|
from within wxWindow::OnSize functions.}
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::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{wxEraseEvent}{wxeraseevent} event handler function
|
|
under Windows and automatically under GTK.
|
|
|
|
Note that setting the background colour does not cause an immediate refresh, so you
|
|
may wish to call \helpref{wxWindow::Clear}{wxwindowclear} or \helpref{wxWindow::Refresh}{wxwindowrefresh} after
|
|
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::SetForegroundColour}{wxwindowsetforegroundcolour},\rtfsp
|
|
\helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour},\rtfsp
|
|
\helpref{wxWindow::Clear}{wxwindowclear},\rtfsp
|
|
\helpref{wxWindow::Refresh}{wxwindowrefresh},\rtfsp
|
|
\helpref{wxEraseEvent}{wxeraseevent}
|
|
|
|
\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::SetContainingSizer}\label{wxwindowsetcontainingsizer}
|
|
|
|
\func{void}{SetContainingSizer}{\param{wxSizer* }{sizer}}
|
|
|
|
This normally does not need to be called by user code. It is called
|
|
when a window is added to a sizer, and is used so the window can
|
|
remove itself from the sizer when it is destroyed.
|
|
|
|
\membersection{wxWindow::SetCursor}\label{wxwindowsetcursor}
|
|
|
|
\func{virtual void}{SetCursor}{\param{const wxCursor\&}{cursor}}
|
|
|
|
% VZ: the docs are correct, if the code doesn't behave like this, it must be
|
|
% changed
|
|
Sets the window's cursor. Notice that the window cursor also sets it for the
|
|
children of the window implicitly.
|
|
|
|
The {\it cursor} may be {\tt wxNullCursor} in which case the window cursor will
|
|
be reset back to default.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{cursor}{Specifies the cursor that the window should normally display.}
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{::wxSetCursor}{wxsetcursor}, \helpref{wxCursor}{wxcursor}
|
|
|
|
\membersection{wxWindow::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::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 propagated upwards to the window parent recursively until a handler
|
|
for them is found. Using this style allows to prevent them from being
|
|
propagated beyond this window. Notice that wxDialog has this style on by
|
|
default for the reasons explained in the
|
|
\helpref{event processing overview}{eventprocessing}.}
|
|
\twocolitem{\windowstyle{wxWS\_EX\_TRANSIENT}}{This can be used to prevent a
|
|
window from being used as an implicit parent for the dialogs which were
|
|
created without a parent. It is useful for the windows which can disappear at
|
|
any moment as creating children of such windows results in fatal problems.}
|
|
\twocolitem{\windowstyle{wxFRAME\_EX\_CONTEXTHELP}}{Under Windows, puts a query button on the
|
|
caption. When pressed, Windows will go into a context-sensitive help mode and wxWindows will send
|
|
a wxEVT\_HELP event if the user clicked on an application window.
|
|
This style cannot be used together with wxMAXIMIZE\_BOX or wxMINIMIZE\_BOX, so
|
|
you should use the style of
|
|
{\tt wxDEFAULT\_FRAME\_STYLE \& \textasciitilde(wxMINIMIZE\_BOX | wxMAXIMIZE\_BOX)} for the
|
|
frames having this style (the dialogs don't have minimize nor maximize box by
|
|
default)}
|
|
\end{twocollist}
|
|
|
|
\membersection{wxWindow::SetFocus}\label{wxwindowsetfocus}
|
|
|
|
\func{virtual void}{SetFocus}{\void}
|
|
|
|
This sets the window to receive keyboard input.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxFocusEvent}{wxfocusevent}
|
|
|
|
\membersection{wxWindow::SetFocusFromKbd}\label{wxwindowsetfocusfromkbd}
|
|
|
|
\func{virtual void}{SetFocusFromKbd}{\void}
|
|
|
|
This function is called by wxWindows keyboard navigation code when the user
|
|
gives the focus to this window from keyboard (e.g. using {\tt TAB} key).
|
|
By default this method simply calls \helpref{SetFocus}{wxwindowsetfocus} but
|
|
can be overridden to do something in addition to this in the derived classes.
|
|
|
|
\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 appearance of windows and controls, including the themes of
|
|
their parent windows.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::GetForegroundColour}{wxwindowgetforegroundcolour},\rtfsp
|
|
\helpref{wxWindow::SetBackgroundColour}{wxwindowsetbackgroundcolour},\rtfsp
|
|
\helpref{wxWindow::GetBackgroundColour}{wxwindowgetbackgroundcolour}
|
|
|
|
\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}}
|
|
|
|
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{bool }{refresh = {\tt 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}{{\tt TRUE} to redraw the scrollbar, {\tt 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{wxSizeEvent}{wxsizeevent} 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{bool }{refresh = {\tt 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}{{\tt TRUE} to redraw the scrollbar, {\tt 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{bool }{refresh = {\tt 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}{{\tt TRUE} to redraw the scrollbar, {\tt 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{bool }{refresh = {\tt 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}{{\tt TRUE} to redraw the scrollbar, {\tt 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}, \param{bool }{deleteOld=TRUE}}
|
|
|
|
Sets the window to have the given layout sizer. The window
|
|
will then own the object, and will take care of its deletion.
|
|
If an existing layout constraints object is already owned by the
|
|
window, it will be deleted if the deleteOld parameter is TRUE.
|
|
|
|
Note that this function will also call
|
|
\helpref{SetAutoLayout}{wxwindowsetautolayout} implicitly with {\tt TRUE}
|
|
parameter if the {\it sizer}\/ is non-NULL and {\tt FALSE} otherwise.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{sizer}{The sizer to set. Pass NULL to disassociate and conditionally delete
|
|
the window's sizer. See below.}
|
|
|
|
\docparam{deleteOld}{If TRUE (the default), this will delete any prexisting sizer.
|
|
Pass FALSE if you wish to handle deleting the old sizer yourself.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
SetSizer now enables and disables Layout automatically, but prior to wxWindows 2.3.3
|
|
the following applied:
|
|
|
|
You must call \helpref{wxWindow::SetAutoLayout}{wxwindowsetautolayout} to tell a window to use
|
|
the sizer automatically in OnSize; otherwise, you must override OnSize and call Layout()
|
|
explicitly. When setting both a wxSizer and a \helpref{wxLayoutConstraints}{wxlayoutconstraints},
|
|
only the sizer will have effect.
|
|
|
|
\membersection{wxWindow::SetSizerAndFit}\label{wxwindowsetsizerandfit}
|
|
|
|
\func{void}{SetSizerAndFit}{\param{wxSizer* }{sizer}, \param{bool }{deleteOld=TRUE}}
|
|
|
|
The same as \helpref{SetSizer}{wxwindowsetsizer}, except it also sets the size hints
|
|
for the window based on the sizer's minimum size.
|
|
|
|
\membersection{wxWindow::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::SetThemeEnabled}\label{wxwindowsetthemeenabled}
|
|
|
|
\func{virtual void}{SetThemeEnabled}{\param{bool }{enable}}
|
|
|
|
This function tells a window if it should use the system's "theme" code
|
|
to draw the windows' background instead if its own background drawing
|
|
code. This does not always have any effect since the underlying platform
|
|
obviously needs to support the notion of themes in user defined windows.
|
|
One such platform is GTK+ where windows can have (very colourful) backgrounds
|
|
defined by a user's selected theme.
|
|
|
|
Dialogs, notebook pages and the status bar have this flag set to TRUE
|
|
by default so that the default look and feel is simulated best.
|
|
|
|
\membersection{wxWindow::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::SetToolTip}\label{wxwindowsettooltip}
|
|
|
|
\func{void}{SetToolTip}{\param{const wxString\& }{tip}}
|
|
|
|
\func{void}{SetToolTip}{\param{wxToolTip* }{tip}}
|
|
|
|
Attach a tooltip to the window.
|
|
|
|
See also: \helpref{GetToolTip}{wxwindowgettooltip},
|
|
\helpref{wxToolTip}{wxtooltip}
|
|
|
|
|
|
\membersection{wxWindow::GetToolTip}\label{wxwindowgettooltip}
|
|
|
|
\constfunc{wxToolTip*}{GetToolTip}{\void}
|
|
|
|
Get the associated tooltip or NULL if none.
|
|
|
|
|
|
\membersection{wxWindow::SetVirtualSize}\label{wxwindowsetvirtualsize}
|
|
|
|
\func{void}{SetVirtualSize}{\param{int}{ width}, \param{int}{ height}}
|
|
|
|
\func{void}{SetVirtualSize}{\param{const wxSize\&}{ size}}
|
|
|
|
Sets the virtual size of the window in pixels.
|
|
|
|
|
|
\membersection{wxWindow::SetVirtualSizeHints}\label{wxwindowsetvirtualsizehints}
|
|
|
|
\func{virtual void}{SetVirtualSizeHints}{\param{int}{ minW},\param{int}{ minH}, \param{int}{ maxW=-1}, \param{int}{ maxH=-1}}
|
|
|
|
Allows specification of minimum and maximum virtual window sizes.
|
|
If a pair of values is not set (or set to -1), the default values
|
|
will be used.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{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.}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
If this function is called, the user will not be able to size the virtual area
|
|
of the window outside the given bounds.
|
|
|
|
\membersection{wxWindow::SetWindowStyle}\label{wxwindowsetwindowstyle}
|
|
|
|
\func{void}{SetWindowStyle}{\param{long}{ style}}
|
|
|
|
Identical to \helpref{SetWindowStyleFlag}{wxwindowsetwindowstyleflag}.
|
|
|
|
\membersection{wxWindow::SetWindowStyleFlag}\label{wxwindowsetwindowstyleflag}
|
|
|
|
\func{virtual void}{SetWindowStyleFlag}{\param{long}{ style}}
|
|
|
|
Sets the style of the window. Please note that some styles cannot be changed
|
|
after the window creation and that \helpref{Refresh()}{wxwindowrefresh} might
|
|
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{GetWindowStyleFlag}{wxwindowgetwindowstyleflag}
|
|
|
|
\membersection{wxWindow::Show}\label{wxwindowshow}
|
|
|
|
\func{virtual bool}{Show}{\param{bool}{ show = {\tt TRUE}}}
|
|
|
|
Shows or hides the window. You may need to call \helpref{Raise}{wxwindowraise}
|
|
for a top level window if you want to bring it to top, although this is not
|
|
needed if Show() is called immediately after the frame creation.
|
|
|
|
\wxheading{Parameters}
|
|
|
|
\docparam{show}{If {\tt TRUE} displays the window. Otherwise, hides it.}
|
|
|
|
\wxheading{Return value}
|
|
|
|
{\tt TRUE} if the window has been shown or hidden or {\tt FALSE} if nothing was
|
|
done because it already was in the requested state.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::IsShown}{wxwindowisshown}
|
|
|
|
\membersection{wxWindow::Thaw}\label{wxwindowthaw}
|
|
|
|
\func{virtual void}{Thaw}{\void}
|
|
|
|
Reenables window updating after a previous call to
|
|
\helpref{Freeze}{wxwindowfreeze}.
|
|
|
|
\membersection{wxWindow::TransferDataFromWindow}\label{wxwindowtransferdatafromwindow}
|
|
|
|
\func{virtual bool}{TransferDataFromWindow}{\void}
|
|
|
|
Transfers values from child controls to data areas specified by their validators. Returns
|
|
{\tt FALSE} if a transfer failed.
|
|
|
|
If the window has {\tt wxWS\_EX\_VALIDATE\_RECURSIVELY} extra style flag set,
|
|
the method will also call TransferDataFromWindow() of all child windows.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::TransferDataToWindow}{wxwindowtransferdatatowindow},\rtfsp
|
|
\helpref{wxValidator}{wxvalidator}, \helpref{wxWindow::Validate}{wxwindowvalidate}
|
|
|
|
\membersection{wxWindow::TransferDataToWindow}\label{wxwindowtransferdatatowindow}
|
|
|
|
\func{virtual bool}{TransferDataToWindow}{\void}
|
|
|
|
Transfers values to child controls from data areas specified by their validators.
|
|
|
|
If the window has {\tt wxWS\_EX\_VALIDATE\_RECURSIVELY} extra style flag set,
|
|
the method will also call TransferDataToWindow() of all child windows.
|
|
|
|
\wxheading{Return value}
|
|
|
|
Returns {\tt FALSE} if a transfer failed.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxWindow::TransferDataFromWindow}{wxwindowtransferdatafromwindow},\rtfsp
|
|
\helpref{wxValidator}{wxvalidator}, \helpref{wxWindow::Validate}{wxwindowvalidate}
|
|
|
|
\membersection{wxWindow::Update}\label{wxwindowupdate}
|
|
|
|
\func{virtual void}{Update}{\void}
|
|
|
|
Calling this method immediately repaints the invalidated area of the window
|
|
while this would usually only happen when the flow of control returns to the
|
|
event loop. Notice that this function doesn't refresh the window and does
|
|
nothing if the window hadn't been already repainted. Use
|
|
\helpref{Refresh}{wxwindowrefresh} first if you want to immediately redraw the
|
|
window unconditionally.
|
|
|
|
\membersection{wxWindow::Validate}\label{wxwindowvalidate}
|
|
|
|
\func{virtual bool}{Validate}{\void}
|
|
|
|
Validates the current values of the child controls using their validators.
|
|
|
|
If the window has {\tt wxWS\_EX\_VALIDATE\_RECURSIVELY} extra style flag set,
|
|
the method will also call Validate() of all child windows.
|
|
|
|
\wxheading{Return value}
|
|
|
|
Returns {\tt 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.}
|
|
|