\latexignore{\rtfignore{\wxheading{Function groups}}}
-\membersection{File name format}
+\membersection{File name format}\label{filenameformat}
wxFileName currently supports the file names in the Unix, DOS/Windows, Mac OS
and VMS formats. Although these formats are quite different, wxFileName tries
\helpref{IsRelative}{wxfilenameisrelative}
-\membersection{File name construction}
+\membersection{File name construction}\label{filenameconstruction}
TODO.
-\membersection{File tests}
+\membersection{File tests}\label{filetests}
Before doing the other tests you should use \helpref{IsOk}{wxfilenameisok} to
verify that the filename is well defined. If it is,
or \helpref{$==$}{wxfilenameoperatorequal}.
-\membersection{File name components}
+\membersection{File name components}\label{filenamecomponents}
These functions allow to examine and modify the directories of the path:
\helpref{SetVolume}{wxfilenamesetvolume}\\
-\membersection{Operations}
+\membersection{Operations}\label{filenameoperations}
These methods allow to work with the file creation, access and modification
times. Note that not all filesystems under all platforms implement these times
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxFontData::wxFontData}
+\membersection{wxFontData::wxFontData}\label{wxfontdatactor}
\func{}{wxFontData}{\void}
\rtfsp{\it allowSymbols} to true, {\it enableEffects} to true,
\rtfsp{\it minSize} to 0 and {\it maxSize} to 0.
-\membersection{wxFontData::\destruct{wxFontData}}
+\membersection{wxFontData::\destruct{wxFontData}}\label{wxfontdatadtor}
\func{}{\destruct{wxFontData}}{\void}
Destructor.
-\membersection{wxFontData::EnableEffects}
+\membersection{wxFontData::EnableEffects}\label{wxfontdataenableeffects}
\func{void}{EnableEffects}{\param{bool}{ enable}}
The default value is true.
-\membersection{wxFontData::GetAllowSymbols}
+\membersection{wxFontData::GetAllowSymbols}\label{wxfontdatagetallowsymbols}
\func{bool}{GetAllowSymbols}{\void}
The default value is true.
-\membersection{wxFontData::GetColour}
+\membersection{wxFontData::GetColour}\label{wxfontdatagetcolour}
\func{wxColour\&}{GetColour}{\void}
The default value is black.
-\membersection{wxFontData::GetChosenFont}
+\membersection{wxFontData::GetChosenFont}\label{wxfontdatagetchosenfont}
\func{wxFont}{GetChosenFont}{\void}
Gets the font chosen by the user if the user pressed OK (wxFontDialog::ShowModal returned wxID\_OK).
-\membersection{wxFontData::GetEnableEffects}
+\membersection{wxFontData::GetEnableEffects}\label{wxfontdatagetenableeffects}
\func{bool}{GetEnableEffects}{\void}
The default value is true.
-\membersection{wxFontData::GetInitialFont}
+\membersection{wxFontData::GetInitialFont}\label{wxfontdatagetinitialfont}
\func{wxFont}{GetInitialFont}{\void}
Gets the font that will be initially used by the font dialog. This should have
previously been set by the application.
-\membersection{wxFontData::GetShowHelp}
+\membersection{wxFontData::GetShowHelp}\label{wxfontdatagetshowhelp}
\func{bool}{GetShowHelp}{\void}
The default value is false.
-\membersection{wxFontData::SetAllowSymbols}
+\membersection{wxFontData::SetAllowSymbols}\label{wxfontdatasetallowsymbols}
\func{void}{SetAllowSymbols}{\param{bool}{ allowSymbols}}
The default value is true.
-\membersection{wxFontData::SetChosenFont}
+\membersection{wxFontData::SetChosenFont}\label{wxfontdatasetchosenfont}
\func{void}{SetChosenFont}{\param{const wxFont\& }{font}}
Sets the font that will be returned to the user (for internal use only).
-\membersection{wxFontData::SetColour}
+\membersection{wxFontData::SetColour}\label{wxfontdatasetcolour}
\func{void}{SetColour}{\param{const wxColour\&}{ colour}}
The default colour is black.
-\membersection{wxFontData::SetInitialFont}
+\membersection{wxFontData::SetInitialFont}\label{wxfontdatasetinitialfont}
\func{void}{SetInitialFont}{\param{const wxFont\&}{font}}
Sets the font that will be initially used by the font dialog.
-\membersection{wxFontData::SetRange}
+\membersection{wxFontData::SetRange}\label{wxfontdatasetrange}
\func{void}{SetRange}{\param{int}{ min}, \param{int}{ max}}
The default is 0, 0 (unrestricted range).
-\membersection{wxFontData::SetShowHelp}
+\membersection{wxFontData::SetShowHelp}\label{wxfontdatasetshowhelp}
\func{void}{SetShowHelp}{\param{bool}{ showHelp}}
The default value is false.
-\membersection{wxFontData::operator $=$}
+\membersection{wxFontData::operator $=$}\label{wxfontdataassign}
\func{void}{operator $=$}{\param{const wxFontData\&}{ data}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxFontDialog::wxFontDialog}
+\membersection{wxFontDialog::wxFontDialog}\label{wxfontdialogctor}
\func{}{wxFontDialog}{\void}
default constructor. Returns {\tt true} on success and {\tt false} if an error
occured.
-\membersection{wxFontDialog::\destruct{wxFontDialog}}
+\membersection{wxFontDialog::\destruct{wxFontDialog}}\label{wxfontdialogdtor}
\func{}{\destruct{wxFontDialog}}{\void}
Destructor.
-\membersection{wxFontDialog::GetFontData}
+\membersection{wxFontDialog::GetFontData}\label{wxfontdialoggetfontdata}
\constfunc{const wxFontData\&}{GetFontData}{\void}
Returns the \helpref{font data}{wxfontdata} associated with the font dialog.
-\membersection{wxFontDialog::ShowModal}
+\membersection{wxFontDialog::ShowModal}\label{wxfontdialogshowmodal}
\func{int}{ShowModal}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxFontList::wxFontList}
+\membersection{wxFontList::wxFontList}\label{wxfontlistctor}
\func{}{wxFontList}{\void}
Constructor. The application should not construct its own font list:
use the object pointer {\bf wxTheFontList}.
-\membersection{wxFontList::AddFont}
+\membersection{wxFontList::AddFont}\label{wxfontlistaddfont}
\func{void}{AddFont}{\param{wxFont *}{font}}
Finds a font of the given specification, or creates one and adds it to the list. See the \helpref{wxFont constructor}{wxfontconstr} for
details of the arguments.
-\membersection{wxFontList::RemoveFont}
+\membersection{wxFontList::RemoveFont}\label{wxfontlistremovefont}
\func{void}{RemoveFont}{\param{wxFont *}{font}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxFrame::wxFrame}\label{wxframeconstr}
+\membersection{wxFrame::wxFrame}\label{wxframector}
\func{}{wxFrame}{\void}
\helpref{wxFrame::Create}{wxframecreate}
-\membersection{wxFrame::\destruct{wxFrame}}
+\membersection{wxFrame::\destruct{wxFrame}}\label{wxframedtor}
\func{void}{\destruct{wxFrame}}{\void}
\param{const wxSize\&}{ size = wxDefaultSize}, \param{long}{ style = wxDEFAULT\_FRAME\_STYLE},\rtfsp
\param{const wxString\& }{name = ``frame"}}
-Used in two-step frame construction. See \helpref{wxFrame::wxFrame}{wxframeconstr}\rtfsp
+Used in two-step frame construction. See \helpref{wxFrame::wxFrame}{wxframector}\rtfsp
for further details.
\membersection{wxFrame::CreateStatusBar}\label{wxframecreatestatusbar}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxFTP::wxFTP}
+\membersection{wxFTP::wxFTP}\label{wxftpctor}
\func{}{wxFTP}{\void}
Default constructor.
-\membersection{wxFTP::\destruct{wxFTP}}
+\membersection{wxFTP::\destruct{wxFTP}}\label{wxftpdtor}
\func{}{\destruct{wxFTP}}{\void}
if an error occured.
-\membersection{wxFTP::CheckCommand}
+\membersection{wxFTP::CheckCommand}\label{wxftpcheckcommand}
\func{bool}{CheckCommand}{\param{const wxString\&}{ command}, \param{char }{ret}}
character of the return code.
-\membersection{wxFTP::GetLastResult}
+\membersection{wxFTP::GetLastResult}\label{wxftpgetlastresult}
\func{const wxString\&}{GetLastResult}{\void}
% ----------------------------------------------------------------------------
-\membersection{wxFTP::ChDir}
+\membersection{wxFTP::ChDir}\label{wxftpchdir}
\func{bool}{ChDir}{\param{const wxString\&}{ dir}}
Returns true if successful.
-\membersection{wxFTP::MkDir}
+\membersection{wxFTP::MkDir}\label{wxftpmkdir}
\func{bool}{MkDir}{\param{const wxString\&}{ dir}}
Returns true if successful.
-\membersection{wxFTP::RmDir}
+\membersection{wxFTP::RmDir}\label{wxftprmdir}
\func{bool}{RmDir}{\param{const wxString\&}{ dir}}
Returns true if successful.
-\membersection{wxFTP::Pwd}
+\membersection{wxFTP::Pwd}\label{wxftppwd}
\func{wxString}{Pwd}{\void}
% ----------------------------------------------------------------------------
-\membersection{wxFTP::Rename}
+\membersection{wxFTP::Rename}\label{wxftprename}
\func{bool}{Rename}{\param{const wxString\&}{ src}, \param{const wxString\&}{ dst}}
% ----------------------------------------------------------------------------
-\membersection{wxFTP::RmFile}
+\membersection{wxFTP::RmFile}\label{wxftprmfile}
\func{bool}{RmFile}{\param{const wxString\&}{ path}}
% ----------------------------------------------------------------------------
-\membersection{wxFTP::SetAscii}
+\membersection{wxFTP::SetAscii}\label{wxftpsetascii}
\func{bool}{SetAscii}{\void}
Sets the transfer mode to ASCII. It will be used for the next transfer.
-\membersection{wxFTP::SetBinary}
+\membersection{wxFTP::SetBinary}\label{wxftpsetbinary}
\func{bool}{SetBinary}{\void}
Sets the transfer mode to binary (IMAGE). It will be used for the next transfer.
-\membersection{wxFTP::SetPassive}
+\membersection{wxFTP::SetPassive}\label{wxftpsetpassive}
\func{void}{SetPassive}{\param{bool }{pasv}}
active connection.
-\membersection{wxFTP::SetTransferMode}
+\membersection{wxFTP::SetTransferMode}\label{wxftpsettransfermode}
\func{bool}{SetTransferMode}{\param{TransferMode }{mode}}
% ----------------------------------------------------------------------------
-\membersection{wxFTP::SetUser}
+\membersection{wxFTP::SetUser}\label{wxftpsetuser}
\func{void}{SetUser}{\param{const wxString\&}{ user}}
to specify a user and a password.
-\membersection{wxFTP::SetPassword}
+\membersection{wxFTP::SetPassword}\label{wxftpsetpassword}
\func{void}{SetPassword}{\param{const wxString\&}{ passwd}}
% ----------------------------------------------------------------------------
-\membersection{wxFTP::GetOutputStream}
+\membersection{wxFTP::GetOutputStream}\label{wxftpgetoutputstream}
\func{wxOutputStream *}{GetOutputStream}{\param{const wxString\&}{ file}}
% ----------------------------------------------------------------------------
-\membersection{wxFTP::GetInputStream}\label{wxftpgetinput}
+\membersection{wxFTP::GetInputStream}\label{wxftpgetinputstream}
\func{wxInputStream *}{GetInputStream}{\param{const wxString\&}{ path}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxGauge::wxGauge}\label{wxgaugeconstr}
+\membersection{wxGauge::wxGauge}\label{wxgaugector}
\func{}{wxGauge}{\void}
\helpref{wxGauge::Create}{wxgaugecreate}
-\membersection{wxGauge::\destruct{wxGauge}}
+\membersection{wxGauge::\destruct{wxGauge}}\label{wxgaugedtor}
\func{}{\destruct{wxGauge}}{\void}
\param{int}{ range}, \param{const wxPoint\& }{ pos = wxDefaultPosition}, \param{const wxSize\&}{ size = wxDefaultSize},\rtfsp
\param{long}{ style = wxGA\_HORIZONTAL}, \param{const wxValidator\& }{validator = wxDefaultValidator}, \param{const wxString\& }{name = ``gauge"}}
-Creates the gauge for two-step construction. See \helpref{wxGauge::wxGauge}{wxgaugeconstr}\rtfsp
+Creates the gauge for two-step construction. See \helpref{wxGauge::wxGauge}{wxgaugector}\rtfsp
for further details.
%%%%%%%%%%% FUNCTION GROUPS %%%%%%%%%%%%%
\latexignore{\rtfignore{\wxheading{Function groups}}}
-\membersection{Constructors and initialization}
+\membersection{Constructors and initialization}\label{wxgridconstructors}
\helpref{wxGrid}{wxgridctor}\\
\helpref{\destruct{wxGrid}}{wxgriddtor}\\
\helpref{CreateGrid}{wxgridcreategrid}\\
\helpref{SetTable}{wxgridsettable}
-\membersection{Display format}
+\membersection{Display format}\label{wxgriddisplayformat}
-\membersection{Selection functions}
+\membersection{Selection functions}\label{wxgridselectionfunctions}
\helpref{wxGrid::ClearSelection}{wxgridclearselection}\\
\helpref{wxGrid::IsSelection}{wxgridisselection}\\
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxHashTable::wxHashTable}
+\membersection{wxHashTable::wxHashTable}\label{wxhashtablector}
\func{}{wxHashTable}{\param{unsigned int}{ key\_type}, \param{int}{ size = 1000}}
Constructor. {\it key\_type} is one of wxKEY\_INTEGER, or wxKEY\_STRING,
and indicates what sort of keying is required. {\it size} is optional.
-\membersection{wxHashTable::\destruct{wxHashTable}}
+\membersection{wxHashTable::\destruct{wxHashTable}}\label{wxhashtabledtor}
\func{}{\destruct{wxHashTable}}{\void}
Destroys the hash table.
-\membersection{wxHashTable::BeginFind}
+\membersection{wxHashTable::BeginFind}\label{wxhashtablebeginfind}
\func{void}{BeginFind}{\void}
through all the data in the hash table, it can call {\it BeginFind} and
then loop on {\it Next}.
-\membersection{wxHashTable::Clear}
+\membersection{wxHashTable::Clear}\label{wxhashtableclear}
\func{void}{Clear}{\void}
Clears the hash table of all nodes (but as usual, doesn't delete user data).
-\membersection{wxHashTable::Delete}
+\membersection{wxHashTable::Delete}\label{wxhashtabledelete}
\func{wxObject *}{Delete}{\param{long}{ key}}
Deletes entry in hash table and returns the user's data (if found).
-\membersection{wxHashTable::DeleteContents}
+\membersection{wxHashTable::DeleteContents}\label{wxhashtabledeletecontents}
\func{void}{DeleteContents}{\param{bool}{ flag}}
is destroyed.
-\membersection{wxHashTable::Get}
+\membersection{wxHashTable::Get}\label{wxhashtableget}
\func{wxObject *}{Get}{\param{long}{ key}}
Gets data from the hash table, using an integer or string key (depending on which
has table constructor was used).
-\membersection{wxHashTable::MakeKey}
+\membersection{wxHashTable::MakeKey}\label{wxhashtablemakekey}
\func{long}{MakeKey}{\param{const wxString\& }{string}}
Makes an integer key out of a string. An application may wish to make a key
explicitly (for instance when combining two data values to form a key).
-\membersection{wxHashTable::Next}
+\membersection{wxHashTable::Next}\label{wxhashtablenext}
\func{wxHashTable::Node *}{Next}{\void}
implemented as a \textbf{wxNode}. The user will probably only wish to use the
\textbf{GetData} method to retrieve the data; the node may also be deleted.
-\membersection{wxHashTable::Put}
+\membersection{wxHashTable::Put}\label{wxhashtableput}
\func{void}{Put}{\param{long}{ key}, \param{wxObject *}{object}}
has table constructor was used). The key string is copied and stored by the hash
table implementation.
-\membersection{wxHashTable::GetCount}
+\membersection{wxHashTable::GetCount}\label{wxhashtablegetcount}
\constfunc{size\_t}{GetCount}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxHashMap::wxHashMap}
+\membersection{wxHashMap::wxHashMap}\label{wxhashmapctor}
\func{}{wxHashMap}{\param{size\_type}{ size = 10}}
Copy constructor.
-\membersection{wxHashMap::begin}
+\membersection{wxHashMap::begin}\label{wxhashmapbegin}
\constfunc{const\_iterator}{begin}{}
Returns an iterator pointing at the first element of the hash map.
Please remember that hash maps do not guarantee ordering.
-\membersection{wxHashMap::clear}
+\membersection{wxHashMap::clear}\label{wxhashmapclear}
\func{void}{clear}{}
Removes all elements from the hash map.
-\membersection{wxHashMap::count}
+\membersection{wxHashMap::count}\label{wxhashmapcount}
\constfunc{size\_type}{count}{\param{const key\_type\&}{ key}}
Counts the number of elements with the given key present in the map.
This function can actually return 0 or 1.
-\membersection{wxHashMap::empty}
+\membersection{wxHashMap::empty}\label{wxhashmapempty}
\constfunc{bool}{empty}{}
Returns true if the hash map does not contain any element, false otherwise.
-\membersection{wxHashMap::end}
+\membersection{wxHashMap::end}\label{wxhashmapend}
\constfunc{const\_iterator}{end}{}
Returns an iterator pointing at the one-after-the-last element of the hash map.
Please remember that hash maps do not guarantee ordering.
-\membersection{wxHashMap::erase}
+\membersection{wxHashMap::erase}\label{wxhashmaperase}
\func{size\_type}{erase}{\param{const key\_type\&}{ key}}
Erases the element pointed to by the iterator. After the deletion
the iterator is no longer valid and must not be used.
-\membersection{wxHashMap::find}
+\membersection{wxHashMap::find}\label{wxhashmapfind}
\func{iterator}{find}{\param{const key\_type\&}{ key}}
an iterator pointing at that element, otherwise an invalid iterator
is returned (i.e. hashmap.find( non\_existent\_key ) == hashmap.end()).
-\membersection{wxHashMap::insert}
+\membersection{wxHashMap::insert}\label{wxhashmapinsert}
\func{void}{insert}{\param{const value\_type\&}{ v}}
Inserts the given value in the hash map.
-\membersection{wxHashMap::operator[]}
+\membersection{wxHashMap::operator[]}\label{wxhashmapbracket}
\func{mapped\_type\&}{operator[]}{\param{const key\_type\&}{ key}}
given key is not present in the hash map, an element with the
default {\tt value\_type()} is inserted in the table.
-\membersection{wxHashMap::size}
+\membersection{wxHashMap::size}\label{wxhashmapsize}
\constfunc{size\_type}{size}{}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxHelpEvent::wxHelpEvent}
+\membersection{wxHelpEvent::wxHelpEvent}\label{wxhelpeventctor}
\func{}{wxHelpEvent}{\param{WXTYPE }{eventType = 0}, \param{bool}{ active = true}, \param{wxWindowID }{id = 0},
\param{const wxPoint\& }{point}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxHelpController::wxHelpController}
+\membersection{wxHelpController::wxHelpController}\label{wxhelpcontrollerctor}
\func{}{wxHelpController}{\void}
Constructs a help instance object, but does not invoke the help viewer.
-\membersection{wxHelpController::\destruct{wxHelpController}}
+\membersection{wxHelpController::\destruct{wxHelpController}}\label{wxhelpcontrollerdtor}
\func{}{\destruct{wxHelpController}}{\void}
% ----------------------------------------------------------------------------
-\membersection{wxHTTP::SetHeader}
+\membersection{wxHTTP::SetHeader}\label{wxhttpsetheader}
\func{void}{SetHeader}{\param{const wxString\&}{ header}, \param{const wxString\&}{ h\_data}}
name is specified by {\it header} and the content by {\it h\_data}.
This is a low level function and it assumes that you know what you are doing.
-\membersection{wxHTTP::GetHeader}
+\membersection{wxHTTP::GetHeader}\label{wxhttpgetheader}
\func{wxString}{GetHeader}{\param{const wxString\&}{ header}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxIcon::wxIcon}\label{wxiconconstr}
+\membersection{wxIcon::wxIcon}\label{wxiconctor}
\func{}{wxIcon}{\void}
\end{itemize}
}
-\membersection{wxIcon::\destruct{wxIcon}}
+\membersection{wxIcon::\destruct{wxIcon}}\label{wxicondtor}
\func{}{\destruct{wxIcon}}{\void}
Do not delete an icon that is selected into a memory device context.
-\membersection{wxIcon::GetDepth}
+\membersection{wxIcon::GetDepth}\label{wxicongetdepth}
\constfunc{int}{GetDepth}{\void}
\wxheading{See also}
-\helpref{wxIcon::wxIcon}{wxiconconstr}
+\helpref{wxIcon::wxIcon}{wxiconctor}
\membersection{wxIcon::Ok}\label{wxiconok}
\docparam{height}{Icon height in pixels.}
-\membersection{wxIcon::SetOk}
+\membersection{wxIcon::SetOk}\label{wxiconsetok}
\func{void}{SetOk}{\param{int }{isOk}}
\docparam{isOk}{Validity flag.}
-\membersection{wxIcon::SetWidth}
+\membersection{wxIcon::SetWidth}\label{wxiconsetwidth}
\func{void}{SetWidth}{\param{int }{width}}
\docparam{width}{Icon width in pixels.}
-\membersection{wxIcon::operator $=$}
+\membersection{wxIcon::operator $=$}\label{wxiconassign}
\func{wxIcon\& }{operator $=$}{\param{const wxIcon\& }{icon}}
Returns 'this' object.
-\membersection{wxIcon::operator $==$}
+\membersection{wxIcon::operator $==$}\label{wxiconequal}
\func{bool}{operator $==$}{\param{const wxIcon\& }{icon}}
Returns true if the icons were effectively equal, false otherwise.
-\membersection{wxIcon::operator $!=$}
+\membersection{wxIcon::operator $!=$}\label{wxiconnotequal}
\func{bool}{operator $!=$}{\param{const wxIcon\& }{icon}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxIdleEvent::wxIdleEvent}
+\membersection{wxIdleEvent::wxIdleEvent}\label{wxidleeventctor}
\func{}{wxIdleEvent}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\subsection{Edges and relationships}
+\subsection{Edges and relationships}\label{edgesandrelationships}
The {\it wxEdge}\index{wxEdge} enumerated type specifies the type of edge or dimension of a window.
\twocolitem{wxAbsolute}{The edge or dimension should be a given absolute value.}
\end{twocollist}
-\membersection{wxIndividualLayoutConstraint::wxIndividualLayoutConstraint}
+\membersection{wxIndividualLayoutConstraint::wxIndividualLayoutConstraint}\label{wxindividuallayoutconstraintctor}
\func{void}{wxIndividualLayoutConstraint}{\void}
Constructor. Not used by the end-user.
-\membersection{wxIndividualLayoutConstraint::Above}
+\membersection{wxIndividualLayoutConstraint::Above}\label{wxindividuallayoutconstraintabove}
\func{void}{Above}{\param{wxWindow *}{otherWin}, \param{int}{ margin = 0}}
Constrains this edge to be above the given window, with an
optional margin. Implicitly, this is relative to the top edge of the other window.
-\membersection{wxIndividualLayoutConstraint::Absolute}
+\membersection{wxIndividualLayoutConstraint::Absolute}\label{wxindividuallayoutconstraintabsolute}
\func{void}{Absolute}{\param{int}{ value}}
Constrains this edge or dimension to be the given absolute value.
-\membersection{wxIndividualLayoutConstraint::AsIs}
+\membersection{wxIndividualLayoutConstraint::AsIs}\label{wxindividuallayoutconstraintasis}
\func{void}{AsIs}{\void}
to have a default size, such as a button, which may take its size
from the size of the button label.
-\membersection{wxIndividualLayoutConstraint::Below}
+\membersection{wxIndividualLayoutConstraint::Below}\label{wxindividuallayoutconstraintbelow}
\func{void}{Below}{\param{wxWindow *}{otherWin}, \param{int}{ margin = 0}}
Constrains this edge to be below the given window, with an
optional margin. Implicitly, this is relative to the bottom edge of the other window.
-\membersection{wxIndividualLayoutConstraint::Unconstrained}
+\membersection{wxIndividualLayoutConstraint::Unconstrained}\label{wxindividuallayoutconstraintunconstrained}
\func{void}{Unconstrained}{\void}
Sets this edge or dimension to be unconstrained, that is, dependent on
other edges and dimensions from which this value can be deduced.
-\membersection{wxIndividualLayoutConstraint::LeftOf}
+\membersection{wxIndividualLayoutConstraint::LeftOf}\label{wxindividuallayoutconstraintleftof}
\func{void}{LeftOf}{\param{wxWindow *}{otherWin}, \param{int}{ margin = 0}}
Constrains this edge to be to the left of the given window, with an
optional margin. Implicitly, this is relative to the left edge of the other window.
-\membersection{wxIndividualLayoutConstraint::PercentOf}
+\membersection{wxIndividualLayoutConstraint::PercentOf}\label{wxindividuallayoutconstraintpercentof}
\func{void}{PercentOf}{\param{wxWindow *}{otherWin}, \param{wxEdge}{ edge}, \param{int}{ per}}
Constrains this edge or dimension to be to a percentage of the given window, with an
optional margin.
-\membersection{wxIndividualLayoutConstraint::RightOf}
+\membersection{wxIndividualLayoutConstraint::RightOf}\label{wxindividuallayoutconstraintrightof}
\func{void}{RightOf}{\param{wxWindow *}{otherWin}, \param{int}{ margin = 0}}
Constrains this edge to be to the right of the given window, with an
optional margin. Implicitly, this is relative to the right edge of the other window.
-\membersection{wxIndividualLayoutConstraint::SameAs}
+\membersection{wxIndividualLayoutConstraint::SameAs}\label{wxindividuallayoutconstraintsameas}
\func{void}{SameAs}{\param{wxWindow *}{otherWin}, \param{wxEdge}{ edge}, \param{int}{ margin = 0}}
Constrains this edge or dimension to be to the same as the edge of the given window, with an
optional margin.
-\membersection{wxIndividualLayoutConstraint::Set}
+\membersection{wxIndividualLayoutConstraint::Set}\label{wxindividuallayoutconstraintset}
\func{void}{Set}{\param{wxRelationship}{ rel}, \param{wxWindow *}{otherWin}, \param{wxEdge}{ otherEdge},
\param{int}{ value = 0}, \param{int}{ margin = 0}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxImage::wxImage}\label{wximageconstr}
+\membersection{wxImage::wxImage}\label{wximagector}
\func{}{wxImage}{\void}
\end{itemize}
}
-\membersection{wxImage::\destruct{wxImage}}
+\membersection{wxImage::\destruct{wxImage}}\label{wximagedtor}
\func{}{\destruct{wxImage}}{\void}
returns true if the current image handlers can read this file
\pythonnote{In wxPython this static method is named {\tt wxImage\_AddHandler}.}
-\membersection{wxImage::CleanUpHandlers}
+\membersection{wxImage::CleanUpHandlers}\label{wximagecleanuphandlers}
\func{static void}{CleanUpHandlers}{\void}
Note that this method involves computing the histogram, which is
computationally intensive operation.
-\membersection{wxImage::FindHandler}
+\membersection{wxImage::FindHandler}\label{wximagefindhandler}
\func{static wxImageHandler*}{FindHandler}{\param{const wxString\& }{name}}
\helpref{wxImageHandler}{wximagehandler}
-\membersection{wxImage::GetImageExtWildcard}
+\membersection{wxImage::GetImageExtWildcard}\label{wximagegetimageextwildcard}
\func{static wxString}{GetImageExtWildcard}{\void}
Number of available images. For most image handlers, this is 1 (exceptions
are TIFF and ICO formats).
-\membersection{wxImage::GetHandlers}
+\membersection{wxImage::GetHandlers}\label{wximagegethandlers}
\func{static wxList\&}{GetHandlers}{\void}
\helpref{wxImage::GetOption}{wximagegetoption},\rtfsp
\helpref{wxImage::GetOptionInt}{wximagegetoptionint}
-\membersection{wxImage::InitStandardHandlers}
+\membersection{wxImage::InitStandardHandlers}\label{wximageinitstandardhandlers}
\func{static void}{InitStandardHandlers}{\void}
\helpref{wxImageHandler}{wximagehandler},
\helpref{wxInitAllImageHandlers}{wxinitallimagehandlers}
-\membersection{wxImage::InsertHandler}
+\membersection{wxImage::InsertHandler}\label{wximageinserthandler}
\func{static void}{InsertHandler}{\param{wxImageHandler*}{ handler}}
Returns true if image data is present.
-\membersection{wxImage::RemoveHandler}
+\membersection{wxImage::RemoveHandler}\label{wximageremovehandler}
\func{static bool}{RemoveHandler}{\param{const wxString\& }{name}}
be set directly. In that case you will have to get access to the image data
using the \helpref{GetData}{wximagegetdata} method.
-\membersection{wxImage::operator $=$}
+\membersection{wxImage::operator $=$}\label{wximageassign}
\func{wxImage\& }{operator $=$}{\param{const wxImage\& }{image}}
Returns 'this' object.
-\membersection{wxImage::operator $==$}
+\membersection{wxImage::operator $==$}\label{wximageequal}
\constfunc{bool}{operator $==$}{\param{const wxImage\& }{image}}
Returns true if the images were effectively equal, false otherwise.
-\membersection{wxImage::operator $!=$}
+\membersection{wxImage::operator $!=$}\label{wximagenotequal}
\constfunc{bool}{operator $!=$}{\param{const wxImage\& }{image}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxImageHandler::wxImageHandler}\label{wximagehandlerconstr}
+\membersection{wxImageHandler::wxImageHandler}\label{wximagehandlerctor}
\func{}{wxImageHandler}{\void}
Default constructor. In your own default constructor, initialise the members
m\_name, m\_extension and m\_type.
-\membersection{wxImageHandler::\destruct{wxImageHandler}}
+\membersection{wxImageHandler::\destruct{wxImageHandler}}\label{wximagehandlerdtor}
\func{}{\destruct{wxImageHandler}}{\void}
Destroys the wxImageHandler object.
-\membersection{wxImageHandler::GetName}
+\membersection{wxImageHandler::GetName}\label{wximagehandlergetname}
\constfunc{wxString}{GetName}{\void}
Gets the name of this handler.
-\membersection{wxImageHandler::GetExtension}
+\membersection{wxImageHandler::GetExtension}\label{wximagehandlergetextension}
\constfunc{wxString}{GetExtension}{\void}
Number of available images. For most image handlers, this is 1 (exceptions
are TIFF and ICO formats).
-\membersection{wxImageHandler::GetType}
+\membersection{wxImageHandler::GetType}\label{wximagehandlergettype}
\constfunc{long}{GetType}{\void}
Gets the image type associated with this handler.
-\membersection{wxImageHandler::GetMimeType}
+\membersection{wxImageHandler::GetMimeType}\label{wximagehandlergetmimetype}
\constfunc{wxString}{GetMimeType}{\void}
\helpref{wxImage::SaveFile}{wximagesavefile},
\helpref{wxImageHandler::LoadFile}{wximagehandlerloadfile}
-\membersection{wxImageHandler::SetName}
+\membersection{wxImageHandler::SetName}\label{wximagehandlersetname}
\func{void}{SetName}{\param{const wxString\& }{name}}
\docparam{name}{Handler name.}
-\membersection{wxImageHandler::SetExtension}
+\membersection{wxImageHandler::SetExtension}\label{wximagehandlersetextension}
\func{void}{SetExtension}{\param{const wxString\& }{extension}}
\docparam{mimename}{Handler MIME type.}
-\membersection{wxImageHandler::SetType}
+\membersection{wxImageHandler::SetType}\label{wximagehandlersettype}
\func{void}{SetType}{\param{long }{type}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxInitDialogEvent::wxInitDialogEvent}
+\membersection{wxInitDialogEvent::wxInitDialogEvent}\label{wxinitdialogeventctor}
\func{}{wxInitDialogEvent}{\param{int }{id = 0}}
% -----------
% ctor & dtor
% -----------
-\membersection{wxInputStream::wxInputStream}
+\membersection{wxInputStream::wxInputStream}\label{wxinputstreamctor}
\func{}{wxInputStream}{\void}
Creates a dummy input stream.
-\membersection{wxInputStream::\destruct{wxInputStream}}
+\membersection{wxInputStream::\destruct{wxInputStream}}\label{wxinputstreamdtor}
\func{}{\destruct{wxInputStream}}{\void}
Destructor.
-\membersection{wxInputStream::GetC}
+\membersection{wxInputStream::GetC}\label{wxinputstreamgetc}
\func{char}{GetC}{\void}
Returns the last number of bytes read.
-\membersection{wxInputStream::Peek}
+\membersection{wxInputStream::Peek}\label{wxinputstreampeek}
\func{char}{Peek}{\void}
ever does (i.e. EOF) LastRead() will return 0 (and the return value is
undefined), otherwise LastRead() returns 1.
-\membersection{wxInputStream::Read}
+\membersection{wxInputStream::Read}\label{wxinputstreamread}
\func{wxInputStream\&}{Read}{\param{void *}{buffer}, \param{size\_t}{ size}}
The new stream position or wxInvalidOffset on error.
-\membersection{wxInputStream::TellI}
+\membersection{wxInputStream::TellI}\label{wxinputstreamtelli}
\constfunc{off\_t}{TellI}{\void}
% Hostname
%
-\membersection{wxIPaddress::Hostname}
+\membersection{wxIPaddress::Hostname}\label{wxipaddresshostname}
\func{virtual bool}{Hostname}{\param{const wxString\&}{ hostname}}
Returns true on success, false if something goes wrong
(invalid hostname or invalid IP address).
-%
-% Hostname
-%
-
-\membersection{wxIPaddress::Hostname}
-
\func{virtual wxString}{Hostname}{\void}
Returns the hostname which matches the IP address.
% IPAddress
%
-\membersection{wxIPaddress::IPAddress}
+\membersection{wxIPaddress::IPAddress}\label{wxipaddressipaddress}
\func{virtual wxString}{IPAddress}{\void}
% Service
%
-\membersection{wxIPaddress::Service}
+\membersection{wxIPaddress::Service}\label{wxipaddressservice}
\func{virtual bool}{Service}{\param{const wxString\&}{ service}}
Returns true on success, false if something goes wrong
(invalid service).
-%
-% Service
-%
-
-\membersection{wxIPaddress::Service}
-
\func{virtual bool}{Service}{\param{unsigned short}{ service}}
Set the port to that corresponding to the specified {\it service}.
Returns true on success, false if something goes wrong
(invalid service).
-%
-% Service
-%
-
-\membersection{wxIPaddress::Service}
-
\func{virtual unsigned short}{Service}{\void}
Returns the current service.
% Hostname
%
-\membersection{wxIPV4address::Hostname}
+\membersection{wxIPV4address::Hostname}\label{wxipv4addresshostname}
\func{bool}{Hostname}{\param{const wxString\&}{ hostname}}
Returns true on success, false if something goes wrong
(invalid hostname or invalid IP address).
-%
-% Hostname
-%
-
-\membersection{wxIPV4address::Hostname}
-
\func{wxString}{Hostname}{\void}
Returns the hostname which matches the IP address.
% IPAddress
%
-\membersection{wxIPV4address::IPAddress}
+\membersection{wxIPV4address::IPAddress}\label{wxipv4addressipaddress}
\func{wxString}{IPAddress}{\void}
% Service
%
-\membersection{wxIPV4address::Service}
+\membersection{wxIPV4address::Service}\label{wxipv4addressservice}
\func{bool}{Service}{\param{const wxString\&}{ service}}
Returns true on success, false if something goes wrong
(invalid service).
-%
-% Service
-%
-
-\membersection{wxIPV4address::Service}
-
\func{bool}{Service}{\param{unsigned short}{ service}}
Set the port to that corresponding to the specified {\it service}.
Returns true on success, false if something goes wrong
(invalid service).
-%
-% Service
-%
-
-\membersection{wxIPV4address::Service}
-
\func{unsigned short}{Service}{\void}
Returns the current service.
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxJoystickEvent::wxJoystickEvent}
+\membersection{wxJoystickEvent::wxJoystickEvent}\label{wxjoystickeventctor}
\func{}{wxJoystickEvent}{\param{WXTYPE}{ eventType = 0}, \param{int}{ state = 0},
\param{int}{ joystick = wxJOYSTICK1}, \param{int }{change = 0}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxJoystick::wxJoystick}\label{wxjoystickconstr}
+\membersection{wxJoystick::wxJoystick}\label{wxjoystickctor}
\func{}{wxJoystick}{\param{int}{ joystick = wxJOYSTICK1}}
Constructor. {\it joystick} may be one of wxJOYSTICK1, wxJOYSTICK2, indicating the joystick
controller of interest.
-\membersection{wxJoystick::\destruct{wxJoystick}}
+\membersection{wxJoystick::\destruct{wxJoystick}}\label{wxjoystickdtor}
\func{}{\destruct{wxJoystick}}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxKeyEvent::m\_altDown}
+\membersection{wxKeyEvent::m\_altDown}\label{wxkeyeventmaltdown}
\member{bool}{m\_altDown}
true if the Alt key is pressed down.
-\membersection{wxKeyEvent::m\_controlDown}
+\membersection{wxKeyEvent::m\_controlDown}\label{wxkeyeventmcontroldown}
\member{bool}{m\_controlDown}
true if control is pressed down.
-\membersection{wxKeyEvent::m\_keyCode}
+\membersection{wxKeyEvent::m\_keyCode}\label{wxkeyeventmkeycode}
\member{long}{m\_keyCode}
Virtual keycode. See \helpref{Keycodes}{keycodes} for a list of identifiers.
-\membersection{wxKeyEvent::m\_metaDown}
+\membersection{wxKeyEvent::m\_metaDown}\label{wxkeyeventmmetadown}
\member{bool}{m\_metaDown}
true if the Meta key is pressed down.
-\membersection{wxKeyEvent::m\_shiftDown}
+\membersection{wxKeyEvent::m\_shiftDown}\label{wxkeyeventmshiftdown}
\member{bool}{m\_shiftDown}
true if shift is pressed down.
-\membersection{wxKeyEvent::m\_x}
+\membersection{wxKeyEvent::m\_x}\label{wxkeyeventmx}
\member{int}{m\_x}
X position of the event.
-\membersection{wxKeyEvent::m\_y}
+\membersection{wxKeyEvent::m\_y}\label{wxkeyeventmy}
\member{int}{m\_y}
Y position of the event.
-\membersection{wxKeyEvent::wxKeyEvent}
+\membersection{wxKeyEvent::wxKeyEvent}\label{wxkeyeventctor}
\func{}{wxKeyEvent}{\param{WXTYPE}{ keyEventType}}
Constructor. Currently, the only valid event types are wxEVT\_CHAR and wxEVT\_CHAR\_HOOK.
-\membersection{wxKeyEvent::AltDown}
+\membersection{wxKeyEvent::AltDown}\label{wxkeyeventaltdown}
\constfunc{bool}{AltDown}{\void}
Returns true if the control key was down at the time of the key event.
-\membersection{wxKeyEvent::GetKeyCode}
+\membersection{wxKeyEvent::GetKeyCode}\label{wxkeyeventgetkeycode}
\constfunc{int}{GetKeyCode}{\void}
left cursor key. See \helpref{Keycodes}{keycodes} for a full list of the virtual key codes.
-\membersection{wxKeyEvent::GetPosition}
+\membersection{wxKeyEvent::GetPosition}\label{wxkeyeventgetposition}
\constfunc{wxPoint}{GetPosition}{\void}
Obtains the position (in client coordinates) at which the key was pressed.
-\membersection{wxKeyEvent::GetRawKeyCode}
+\membersection{wxKeyEvent::GetRawKeyCode}\label{wxkeyeventgetrawkeycode}
\constfunc{wxUint32}{GetRawKeyCode}{\void}
{\tt\#ifdef wxHAS\_RAW\_KEY\_CODES} to determine if this feature is available.
-\membersection{wxKeyEvent::GetRawKeyFlags}
+\membersection{wxKeyEvent::GetRawKeyFlags}\label{wxkeyeventgetrawkeyflags}
\constfunc{wxUint32}{GetRawKeyFlags}{\void}
{\tt \#ifdef wxHAS\_RAW\_KEY\_CODES} to determine if this feature is available.
-\membersection{wxKeyEvent::GetUnicodeKey}
+\membersection{wxKeyEvent::GetUnicodeKey}\label{wxkeyeventgetunicodekey}
\constfunc{wxChar}{GetUnicodeKey}{\void}
\texttt{wxUSE\_UNICODE} is $1$.
-\membersection{wxKeyEvent::GetX}
+\membersection{wxKeyEvent::GetX}\label{wxkeyeventgetx}
\constfunc{long}{GetX}{\void}
Returns the X position (in client coordinates) of the event.
-\membersection{wxKeyEvent::GetY}
+\membersection{wxKeyEvent::GetY}\label{wxkeyeventgety}
\constfunc{long}{GetY}{\void}
Returns the Y (in client coordinates) position of the event.
-\membersection{wxKeyEvent::HasModifiers}
+\membersection{wxKeyEvent::HasModifiers}\label{wxkeyeventhasmodifiers}
\constfunc{bool}{HasModifiers}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxLayoutAlgorithm::wxLayoutAlgorithm}
+\membersection{wxLayoutAlgorithm::wxLayoutAlgorithm}\label{wxlayoutalgorithmctor}
\func{}{wxLayoutAlgorithm}{\void}
Default constructor.
-\membersection{wxLayoutAlgorithm::\destruct{wxLayoutAlgorithm}}
+\membersection{wxLayoutAlgorithm::\destruct{wxLayoutAlgorithm}}\label{wxlayoutalgorithmdtor}
\func{}{\destruct{wxLayoutAlgorithm}}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxLayoutConstraints::wxLayoutConstraints}
+\membersection{wxLayoutConstraints::wxLayoutConstraints}\label{wxlayoutconstraintsctor}
\func{}{wxLayoutConstraints}{\void}
Constructor.
-\membersection{wxLayoutConstraints::bottom}
+\membersection{wxLayoutConstraints::bottom}\label{wxlayoutconstraintsbottom}
\member{wxIndividualLayoutConstraint}{bottom}
Constraint for the bottom edge.
-\membersection{wxLayoutConstraints::centreX}
+\membersection{wxLayoutConstraints::centreX}\label{wxlayoutconstraintscentrex}
\member{wxIndividualLayoutConstraint}{centreX}
Constraint for the horizontal centre point.
-\membersection{wxLayoutConstraints::centreY}
+\membersection{wxLayoutConstraints::centreY}\label{wxlayoutconstraintscentrey}
\member{wxIndividualLayoutConstraint}{centreY}
Constraint for the vertical centre point.
-\membersection{wxLayoutConstraints::height}
+\membersection{wxLayoutConstraints::height}\label{wxlayoutconstraintsheight}
\member{wxIndividualLayoutConstraint}{height}
Constraint for the height.
-\membersection{wxLayoutConstraints::left}
+\membersection{wxLayoutConstraints::left}\label{wxlayoutconstraintsleft}
\member{wxIndividualLayoutConstraint}{left}
Constraint for the left-hand edge.
-\membersection{wxLayoutConstraints::right}
+\membersection{wxLayoutConstraints::right}\label{wxlayoutconstraintsright}
\member{wxIndividualLayoutConstraint}{right}
Constraint for the right-hand edge.
-\membersection{wxLayoutConstraints::top}
+\membersection{wxLayoutConstraints::top}\label{wxlayoutconstraintstop}
\member{wxIndividualLayoutConstraint}{top}
Constraint for the top edge.
-\membersection{wxLayoutConstraints::width}
+\membersection{wxLayoutConstraints::width}\label{wxlayoutconstraintswidth}
\member{wxIndividualLayoutConstraint}{width}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxList::wxList}
+\membersection{wxList::wxList}\label{wxlistctor}
\func{}{wxList}{\void}
The variable-length argument list constructor must be supplied with a
terminating NULL.
-\membersection{wxList::\destruct{wxList}}
+\membersection{wxList::\destruct{wxList}}\label{wxlistdtor}
\func{}{\destruct{wxList}}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxListBox::wxListBox}\label{wxlistboxconstr}
+\membersection{wxListBox::wxListBox}\label{wxlistboxctor}
\func{}{wxListBox}{\void}
\perlnote{In wxPerl there is just an array reference in place of {\tt n}
and {\tt choices}.}
-\membersection{wxListBox::\destruct{wxListBox}}
+\membersection{wxListBox::\destruct{wxListBox}}\label{wxlistboxdtor}
\func{void}{\destruct{wxListBox}}{\void}
\param{const wxArrayString\& }{choices},\rtfsp
\param{long}{ style = 0}, \param{const wxValidator\& }{validator = wxDefaultValidator}, \param{const wxString\& }{name = ``listBox"}}
-Creates the listbox for two-step construction. See \helpref{wxListBox::wxListBox}{wxlistboxconstr}\rtfsp
+Creates the listbox for two-step construction. See \helpref{wxListBox::wxListBox}{wxlistboxctor}\rtfsp
for further details.
\membersection{wxListBox::Deselect}\label{wxlistboxdeselect}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxListCtrl::wxListCtrl}\label{wxlistctrlconstr}
+\membersection{wxListCtrl::wxListCtrl}\label{wxlistctrlctor}
\func{}{wxListCtrl}{\void}
\helpref{wxListCtrl::Create}{wxlistctrlcreate}, \helpref{wxValidator}{wxvalidator}
-\membersection{wxListCtrl::\destruct{wxListCtrl}}
+\membersection{wxListCtrl::\destruct{wxListCtrl}}\label{wxlistctrldtor}
\func{void}{\destruct{wxListCtrl}}{\void}
\param{const wxPoint\&}{ pos = wxDefaultPosition}, \param{const wxSize\&}{ size = wxDefaultSize},\rtfsp
\param{long}{ style = wxLC\_ICON}, \param{const wxValidator\& }{validator = wxDefaultValidator}, \param{const wxString\& }{name = ``listCtrl"}}
-Creates the list control. See \helpref{wxListCtrl::wxListCtrl}{wxlistctrlconstr} for further details.
+Creates the list control. See \helpref{wxListCtrl::wxListCtrl}{wxlistctrlctor} for further details.
\membersection{wxListCtrl::DeleteAllItems}\label{wxlistctrldeleteallitems}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxListEvent::wxListEvent}
+\membersection{wxListEvent::wxListEvent}\label{wxlisteventctor}
\func{}{wxListEvent}{\param{WXTYPE }{commandType = 0}, \param{int }{id = 0}}
Wx::LanguageInfo->new( language, canonicalName, WinLang, WinSubLang, Description )}
-\membersection{wxLocale::FindLanguageInfo}{wxlocalefindlanguageinfo}
+\membersection{wxLocale::FindLanguageInfo}\label{wxlocalefindlanguageinfo}
\constfunc{static wxLanguageInfo *}{FindLanguageInfo}{\param{const wxString\& }{locale}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxMDIChildFrame::wxMDIChildFrame}\label{wxmdichildframeconstr}
+\membersection{wxMDIChildFrame::wxMDIChildFrame}\label{wxmdichildframector}
\func{}{wxMDIChildFrame}{\void}
\helpref{wxMDIChildFrame::Create}{wxmdichildframecreate}
-\membersection{wxMDIChildFrame::\destruct{wxMDIChildFrame}}
+\membersection{wxMDIChildFrame::\destruct{wxMDIChildFrame}}\label{wxmdichildframedtor}
\func{}{\destruct{wxMDIChildFrame}}{\void}
\param{const wxSize\&}{ size = wxDefaultSize}, \param{long}{ style = wxDEFAULT\_FRAME\_STYLE},\rtfsp
\param{const wxString\& }{name = ``frame"}}
-Used in two-step frame construction. See \helpref{wxMDIChildFrame::wxMDIChildFrame}{wxmdichildframeconstr}\rtfsp
+Used in two-step frame construction. See \helpref{wxMDIChildFrame::wxMDIChildFrame}{wxmdichildframector}\rtfsp
for further details.
\membersection{wxMDIChildFrame::Maximize}\label{wxmdichildframemaximize}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxMDIClientWindow::wxMDIClientWindow}\label{wxmdiclientwindowconstr}
+\membersection{wxMDIClientWindow::wxMDIClientWindow}\label{wxmdiclientwindowctor}
\func{}{wxMDIClientWindow}{\void}
\wxheading{See also}
-\helpref{wxMDIParentFrame::wxMDIParentFrame}{wxmdiparentframeconstr},\rtfsp
+\helpref{wxMDIParentFrame::wxMDIParentFrame}{wxmdiparentframector},\rtfsp
\helpref{wxMDIParentFrame::OnCreateClient}{wxmdiparentframeoncreateclient}
-\membersection{wxMDIClientWindow::\destruct{wxMDIClientWindow}}
+\membersection{wxMDIClientWindow::\destruct{wxMDIClientWindow}}\label{wxmdiclientwindowdtor}
\func{}{\destruct{wxMDIClientWindow}}{\void}
\func{bool}{CreateClient}{\param{wxMDIParentFrame* }{parent}, \param{long}{ style = 0}}
-Used in two-step frame construction. See \helpref{wxMDIClientWindow::wxMDIClientWindow}{wxmdiclientwindowconstr}\rtfsp
+Used in two-step frame construction. See \helpref{wxMDIClientWindow::wxMDIClientWindow}{wxmdiclientwindowctor}\rtfsp
for further details.
\section{\class{wxMDIParentFrame}}\label{wxmdiparentframe}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxMDIParentFrame::wxMDIParentFrame}\label{wxmdiparentframeconstr}
+\membersection{wxMDIParentFrame::wxMDIParentFrame}\label{wxmdiparentframector}
\func{}{wxMDIParentFrame}{\void}
\helpref{wxMDIParentFrame::Create}{wxmdiparentframecreate},\rtfsp
\helpref{wxMDIParentFrame::OnCreateClient}{wxmdiparentframeoncreateclient}
-\membersection{wxMDIParentFrame::\destruct{wxMDIParentFrame}}
+\membersection{wxMDIParentFrame::\destruct{wxMDIParentFrame}}\label{wxmdiparentframedtor}
\func{}{\destruct{wxMDIParentFrame}}{\void}
\param{const wxSize\&}{ size = wxDefaultSize}, \param{long}{ style = wxDEFAULT\_FRAME\_STYLE \pipe wxVSCROLL \pipe wxHSCROLL},\rtfsp
\param{const wxString\& }{name = ``frame"}}
-Used in two-step frame construction. See \helpref{wxMDIParentFrame::wxMDIParentFrame}{wxmdiparentframeconstr}\rtfsp
+Used in two-step frame construction. See \helpref{wxMDIParentFrame::wxMDIParentFrame}{wxmdiparentframector}\rtfsp
for further details.
\membersection{wxMDIParentFrame::GetClientSize}\label{wxmdiparentframegetclientsize}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxGenericValidator::wxGenericValidator}\label{wxgenericvalidatorconstr}
+\membersection{wxGenericValidator::wxGenericValidator}\label{wxgenericvalidatorctor}
\func{}{wxGenericValidator}{\param{const wxGenericValidator\&}{ validator}}
should have a lifetime equal to or longer than the validator lifetime (which is usually
determined by the lifetime of the window).}
-\membersection{wxGenericValidator::\destruct{wxGenericValidator}}
+\membersection{wxGenericValidator::\destruct{wxGenericValidator}}\label{wxgenericvalidatordtor}
\func{}{\destruct{wxGenericValidator}}{\void}
projects / wxWidgets.git / commitdiff
