Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

made the alphabetic class order more alphabetic

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@13567 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2002-01-14 16:40:44 +00:00
parent a3590de1a3
commit f3845e889c
24 changed files with 1552 additions and 1759 deletions
Download Patch File Download Diff File Expand all files Collapse all files

164
docs/latex/wx/bitmap.tex
View File

@@ -611,167 +611,3 @@ unequal (a fast test).
Returns TRUE if the bitmaps were unequal, FALSE otherwise.
\section{\class{wxBitmapHandler}}\label{wxbitmaphandler}
\overview{Overview}{wxbitmapoverview}
This is the base class for implementing bitmap file loading/saving, and bitmap creation from data.
It is used within wxBitmap and is not normally seen by the application.
If you wish to extend the capabilities of wxBitmap, derive a class from wxBitmapHandler
and add the handler using \helpref{wxBitmap::AddHandler}{wxbitmapaddhandler} in your
application initialisation.
\wxheading{Derived from}
\helpref{wxObject}{wxobject}
\wxheading{Include files}
<wx/bitmap.h>
\wxheading{See also}
\helpref{wxBitmap}{wxbitmap}, \helpref{wxIcon}{wxicon}, \helpref{wxCursor}{wxcursor}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxBitmapHandler::wxBitmapHandler}\label{wxbitmaphandlerconstr}
\func{}{wxBitmapHandler}{\void}
Default constructor. In your own default constructor, initialise the members
m\_name, m\_extension and m\_type.
\membersection{wxBitmapHandler::\destruct{wxBitmapHandler}}
\func{}{\destruct{wxBitmapHandler}}{\void}
Destroys the wxBitmapHandler object.
\membersection{wxBitmapHandler::Create}
\func{virtual bool}{Create}{\param{wxBitmap* }{bitmap}, \param{void*}{ data}, \param{int}{ type}, \param{int}{ width}, \param{int}{ height}, \param{int}{ depth = -1}}
Creates a bitmap from the given data, which can be of arbitrary type. The wxBitmap object {\it bitmap} is
manipulated by this function.
\wxheading{Parameters}
\docparam{bitmap}{The wxBitmap object.}
\docparam{width}{The width of the bitmap in pixels.}
\docparam{height}{The height of the bitmap in pixels.}
\docparam{depth}{The depth of the bitmap in pixels. If this is -1, the screen depth is used.}
\docparam{data}{Data whose type depends on the value of {\it type}.}
\docparam{type}{A bitmap type identifier - see \helpref{wxBitmapHandler::wxBitmapHandler}{wxbitmapconstr} for a list
of possible values.}
\wxheading{Return value}
TRUE if the call succeeded, FALSE otherwise (the default).
\membersection{wxBitmapHandler::GetName}
\constfunc{wxString}{GetName}{\void}
Gets the name of this handler.
\membersection{wxBitmapHandler::GetExtension}
\constfunc{wxString}{GetExtension}{\void}
Gets the file extension associated with this handler.
\membersection{wxBitmapHandler::GetType}
\constfunc{long}{GetType}{\void}
Gets the bitmap type associated with this handler.
\membersection{wxBitmapHandler::LoadFile}\label{wxbitmaphandlerloadfile}
\func{bool}{LoadFile}{\param{wxBitmap* }{bitmap}, \param{const wxString\&}{ name}, \param{long}{ type}}
Loads a bitmap from a file or resource, putting the resulting data into {\it bitmap}.
\wxheading{Parameters}
\docparam{bitmap}{The bitmap object which is to be affected by this operation.}
\docparam{name}{Either a filename or a Windows resource name.
The meaning of {\it name} is determined by the {\it type} parameter.}
\docparam{type}{See \helpref{wxBitmap::wxBitmap}{wxbitmapconstr} for values this can take.}
\wxheading{Return value}
TRUE if the operation succeeded, FALSE otherwise.
\wxheading{See also}
\helpref{wxBitmap::LoadFile}{wxbitmaploadfile}\\
\helpref{wxBitmap::SaveFile}{wxbitmapsavefile}\\
\helpref{wxBitmapHandler::SaveFile}{wxbitmaphandlersavefile}
\membersection{wxBitmapHandler::SaveFile}\label{wxbitmaphandlersavefile}
\func{bool}{SaveFile}{\param{wxBitmap* }{bitmap}, \param{const wxString\& }{name}, \param{int}{ type}, \param{wxPalette* }{palette = NULL}}
Saves a bitmap in the named file.
\wxheading{Parameters}
\docparam{bitmap}{The bitmap object which is to be affected by this operation.}
\docparam{name}{A filename. The meaning of {\it name} is determined by the {\it type} parameter.}
\docparam{type}{See \helpref{wxBitmap::wxBitmap}{wxbitmapconstr} for values this can take.}
\docparam{palette}{An optional palette used for saving the bitmap.}
\wxheading{Return value}
TRUE if the operation succeeded, FALSE otherwise.
\wxheading{See also}
\helpref{wxBitmap::LoadFile}{wxbitmaploadfile}\\
\helpref{wxBitmap::SaveFile}{wxbitmapsavefile}\\
\helpref{wxBitmapHandler::LoadFile}{wxbitmaphandlerloadfile}
\membersection{wxBitmapHandler::SetName}
\func{void}{SetName}{\param{const wxString\& }{name}}
Sets the handler name.
\wxheading{Parameters}
\docparam{name}{Handler name.}
\membersection{wxBitmapHandler::SetExtension}
\func{void}{SetExtension}{\param{const wxString\& }{extension}}
Sets the handler extension.
\wxheading{Parameters}
\docparam{extension}{Handler extension.}
\membersection{wxBitmapHandler::SetType}
\func{void}{SetType}{\param{long }{type}}
Sets the handler type.
\wxheading{Parameters}
\docparam{name}{Handler type.}

43
docs/latex/wx/classes.tex
View File

@@ -14,14 +14,15 @@
\input bitmap.tex
\input bbutton.tex
\input bmpdatob.tex
\input bmphand.tex
\input propbfva.tex
\input propblva.tex
\input boxsizer.tex
\input brush.tex
\input strmbfrd.tex
\input busycurs.tex
\input busyinfo.tex
\input button.tex
\input strmbfrd.tex
\input calclevt.tex
\input calctrl.tex
\input caret.tex
@@ -47,18 +48,19 @@
\input critsect.tex
\input crtslock.tex
\input csconv.tex
\input custdobj.tex
\input cursor.tex
\input custdobj.tex
\input database.tex
\input dataform.tex
\input dataobj.tex
\input db.tex
\input dobjcomp.tex
\input dobjsmpl.tex
\input datstrm.tex
\input datistrm.tex
\input dataobj.tex
\input datostrm.tex
\input date.tex
\input datespan.tex
\input datetime.tex
\input db.tex
\input dc.tex
\input ddeclint.tex
\input ddeconn.tex
@@ -69,6 +71,7 @@
\input dialup.tex
\input dir.tex
\input dirdlg.tex
\input dirtrav.tex
\input dllload.tex
\input docchfrm.tex
\input docmanag.tex
@@ -81,26 +84,29 @@
\input dropevt.tex
\input dropsrc.tex
\input droptrgt.tex
\input dynlib.tex
\input encconv.tex
\input eraseevt.tex
\input event.tex
\input evthand.tex
\input expr.tex
\input ffile.tex
\input ffilestr.tex
\input file.tex
\input filestrm.tex
\input fildatob.tex
\input filedlg.tex
\input fildrptg.tex
\input filehist.tex
\input strmfile.tex
\input filename.tex
\input propflva.tex
\input filesys.tex
\input filesysh.tex
\input filetype.tex
\input flexsizr.tex
\input fltinstr.tex
\input fltoutst.tex
\input fdrepdlg.tex
\input flexsizr.tex
\input focusevt.tex
\input font.tex
\input fontdlg.tex
@@ -147,9 +153,9 @@
\input htwinprs.tex
\input htwinhnd.tex
\input http.tex
\input idleevt.tex
\input icon.tex
\input iconevt.tex
\input idleevt.tex
\input image.tex
\input imaglist.tex
\input ilayout.tex
@@ -182,8 +188,8 @@
\input fs_mem.tex
\input strmmem.tex
\input menu.tex
\input menuitem.tex
\input menuevt.tex
\input menuitem.tex
\input msgdlg.tex
\input metafile.tex
\input mimetype.tex
@@ -194,10 +200,10 @@
\input mltchdlg.tex
\input mutex.tex
\input mutexlck.tex
\input nbsizer.tex
\input node.tex
\input notebook.tex
\input noteevt.tex
\input nbsizer.tex
\input notifevt.tex
\input object.tex
\input outptstr.tex
@@ -217,8 +223,8 @@
\input print.tex
\input prvtdrpt.tex
\input process.tex
\input progdlg.tex
\input procevt.tex
\input progdlg.tex
\input property.tex
\input propford.tex
\input propforf.tex
@@ -244,8 +250,8 @@
\input proprfva.tex
\input proprlva.tex
\input realpoin.tex
\input rect.tex
\input recrdset.tex
\input rect.tex
\input regex.tex
\input region.tex
\input sashevt.tex
@@ -253,9 +259,9 @@
\input sashwin.tex
\input screendc.tex
\input scrolbar.tex
\input scrolwin.tex
\input scrlwevt.tex
\input scrolevt.tex
\input scrolwin.tex
\input hprovsmp.tex
\input sngchdlg.tex
\input snglinst.tex
@@ -266,6 +272,7 @@
\input sckaddr.tex
\input socket.tex
\input strmsock.tex
\input socksrv.tex
\input spinbutt.tex
\input spinctrl.tex
\input spinevt.tex
@@ -293,6 +300,7 @@
\input tab.tex
\input tabctrl.tex
\input tabevent.tex
\input tabview.tex
\input taskbar.tex
\input tcpclint.tex
\input tcpconn.tex
@@ -300,15 +308,15 @@
\input tempfile.tex
\input text.tex
\input txtdatob.tex
\input txtstrm.tex
\input textdlg.tex
\input txtdrptg.tex
\input timespan.tex
\input valtext.tex
\input textdlg.tex
\input textfile.tex
\input txtstrm.tex
\input valtext.tex
\input thread.tex
\input time.tex
\input timer.tex
\input timespan.tex
\input tipprov.tex
\input tipwin.tex
\input tglbtn.tex
@@ -316,6 +324,7 @@
\input tooltip.tex
\input treectrl.tex
\input treeevt.tex
\input treedata.tex
\input treelay.tex
\input upduievt.tex
\input url.tex

78
docs/latex/wx/datostrm.tex Normal file
View File

@@ -0,0 +1,78 @@
\section{\class{wxDataOutputStream}}\label{wxdataoutputstream}
This class provides functions that write binary data types in a
portable way. Data can be written in either big-endian or litte-endian
format, little-endian being the default on all architectures.
If you want to write data to text files (or streams) use
\helpref{wxTextOutputStream}{wxtextoutputstream} instead.
The << operator is overloaded and you can use this class like a standard
C++ iostream. See \helpref{wxDataInputStream}{wxdatainputstream} for its
usage and caveats.
See also \helpref{wxDataInputStream}{wxdatainputstream}.
\wxheading{Derived from}
None
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxDataOutputStream::wxDataOutputStream}\label{wxdataoutputstreamconstr}
\func{}{wxDataOutputStream}{\param{wxOutputStream\&}{ stream}}
Constructs a datastream object from an output stream. Only write methods will
be available.
\wxheading{Parameters}
\docparam{stream}{The output stream.}
\membersection{wxDataOutputStream::\destruct{wxDataOutputStream}}
\func{}{\destruct{wxDataOutputStream}}{\void}
Destroys the wxDataOutputStream object.
\membersection{wxDataOutputStream::BigEndianOrdered}
\func{void}{BigEndianOrdered}{\param{bool}{ be\_order}}
If {\it be\_order} is TRUE, all data will be written in big-endian
order, e.g. for reading on a Sparc or from Java-Streams (which
always use big-endian order), otherwise data will be written in
little-endian order.
\membersection{wxDataOutputStream::Write8}
\func{void}{Write8}{{\param wxUint8 }{i8}}
Writes the single byte {\it i8} to the stream.
\membersection{wxDataOutputStream::Write16}
\func{void}{Write16}{{\param wxUint16 }{i16}}
Writes the 16 bit integer {\it i16} to the stream.
\membersection{wxDataOutputStream::Write32}
\func{void}{Write32}{{\param wxUint32 }{i32}}
Writes the 32 bit integer {\it i32} to the stream.
\membersection{wxDataOutputStream::WriteDouble}
\func{void}{WriteDouble}{{\param double }{f}}
Writes the double {\it f} to the stream using the IEEE format.
\membersection{wxDataOutputStream::WriteString}
\func{void}{WriteString}{{\param const wxString\& }{string}}
Writes {\it string} to the stream. Actually, this method writes the size of
the string before writing {\it string} itself.

184
docs/latex/wx/datstrm.tex
View File

@@ -1,184 +0,0 @@
% ----------------------------------------------------------------------------
% wxDataInputStream
% ----------------------------------------------------------------------------
\section{\class{wxDataInputStream}}\label{wxdatainputstream}
This class provides functions that read binary data types in a
portable way. Data can be read in either big-endian or litte-endian
format, little-endian being the default on all architectures.
If you want to read data from text files (or streams) use
\helpref{wxTextInputStream}{wxtextinputstream} instead.
The >> operator is overloaded and you can use this class like a standard C++ iostream.
Note, however, that the arguments are the fixed size types wxUint32, wxInt32 etc
and on a typical 32-bit computer, none of these match to the "long" type (wxInt32
is defined as signed int on 32-bit architectures) so that you cannot use long. To avoid
problems (here and elsewhere), make use of the wxInt32, wxUint32, etc types.
For example:
\begin{verbatim}
wxFileInputStream input( "mytext.dat" );
wxDataInputStream store( input );
wxUint8 i1;
float f2;
wxString line;
store >> i1; // read a 8 bit integer.
store >> i1 >> f2; // read a 8 bit integer followed by float.
store >> line; // read a text line
\end{verbatim}
See also \helpref{wxDataOutputStream}{wxdataoutputstream}.
\wxheading{Derived from}
None
\wxheading{Include files}
<wx/datstrm.h>
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxDataInputStream::wxDataInputStream}\label{wxdatainputstreamconstr}
\func{}{wxDataInputStream}{\param{wxInputStream\&}{ stream}}
Constructs a datastream object from an input stream. Only read methods will
be available.
\wxheading{Parameters}
\docparam{stream}{The input stream.}
\membersection{wxDataInputStream::\destruct{wxDataInputStream}}
\func{}{\destruct{wxDataInputStream}}{\void}
Destroys the wxDataInputStream object.
\membersection{wxDataInputStream::BigEndianOrdered}
\func{void}{BigEndianOrdered}{\param{bool}{ be\_order}}
If {\it be\_order} is TRUE, all data will be read in big-endian
order, such as written by programs on a big endian architecture
(e.g. Sparc) or written by Java-Streams (which always use
big-endian order).
\membersection{wxDataInputStream::Read8}
\func{wxUint8}{Read8}{\void}
Reads a single byte from the stream.
\membersection{wxDataInputStream::Read16}
\func{wxUint16}{Read16}{\void}
Reads a 16 bit integer from the stream.
\membersection{wxDataInputStream::Read32}
\func{wxUint32}{Read32}{\void}
Reads a 32 bit integer from the stream.
\membersection{wxDataInputStream::ReadDouble}
\func{double}{ReadDouble}{\void}
Reads a double (IEEE encoded) from the stream.
\membersection{wxDataInputStream::ReadString}
\func{wxString}{ReadString}{\void}
Reads a string from a stream. Actually, this function first reads a long integer
specifying the length of the string (without the last null character) and then
reads the string.
% ----------------------------------------------------------------------------
% wxDataOutputStream
% ----------------------------------------------------------------------------
\section{\class{wxDataOutputStream}}\label{wxdataoutputstream}
This class provides functions that write binary data types in a
portable way. Data can be written in either big-endian or litte-endian
format, little-endian being the default on all architectures.
If you want to write data to text files (or streams) use
\helpref{wxTextOutputStream}{wxtextoutputstream} instead.
The << operator is overloaded and you can use this class like a standard
C++ iostream. See \helpref{wxDataInputStream}{wxdatainputstream} for its
usage and caveats.
See also \helpref{wxDataInputStream}{wxdatainputstream}.
\wxheading{Derived from}
None
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxDataOutputStream::wxDataOutputStream}\label{wxdataoutputstreamconstr}
\func{}{wxDataOutputStream}{\param{wxOutputStream\&}{ stream}}
Constructs a datastream object from an output stream. Only write methods will
be available.
\wxheading{Parameters}
\docparam{stream}{The output stream.}
\membersection{wxDataOutputStream::\destruct{wxDataOutputStream}}
\func{}{\destruct{wxDataOutputStream}}{\void}
Destroys the wxDataOutputStream object.
\membersection{wxDataOutputStream::BigEndianOrdered}
\func{void}{BigEndianOrdered}{\param{bool}{ be\_order}}
If {\it be\_order} is TRUE, all data will be written in big-endian
order, e.g. for reading on a Sparc or from Java-Streams (which
always use big-endian order), otherwise data will be written in
little-endian order.
\membersection{wxDataOutputStream::Write8}
\func{void}{Write8}{{\param wxUint8 }{i8}}
Writes the single byte {\it i8} to the stream.
\membersection{wxDataOutputStream::Write16}
\func{void}{Write16}{{\param wxUint16 }{i16}}
Writes the 16 bit integer {\it i16} to the stream.
\membersection{wxDataOutputStream::Write32}
\func{void}{Write32}{{\param wxUint32 }{i32}}
Writes the 32 bit integer {\it i32} to the stream.
\membersection{wxDataOutputStream::WriteDouble}
\func{void}{WriteDouble}{{\param double }{f}}
Writes the double {\it f} to the stream using the IEEE format.
\membersection{wxDataOutputStream::WriteString}
\func{void}{WriteString}{{\param const wxString\& }{string}}
Writes {\it string} to the stream. Actually, this method writes the size of
the string before writing {\it string} itself.

92
docs/latex/wx/db.tex
View File

@@ -1604,6 +1604,52 @@ Simply initializes all member variables to a cleared state. Called by
the constructor automatically.
\section{\class{wxDbColFor}}\label{wxdbcolfor}
Beginning support for handling international formatting specifically on dates
and floats.
\begin{verbatim}
wxString s_Field; // Formated String for Output
wxString s_Format[7]; // Formated Objects - TIMESTAMP has
the biggest (7)
wxString s_Amount[7]; // Formated Objects - amount of
things that can be formatted
int i_Amount[7]; // Formated Objects -
TT MM YYYY HH MM SS m
int i_Nation; // 0 = timestamp
1 = EU
2 = UK
3 = International
4 = US
int i_dbDataType; // conversion of the 'sqlDataType'
to the generic data type used by
these classes
SWORD i_sqlDataType;
\end{verbatim}
The constructor for this class initializes all the values to zero or NULL.
The destructor does nothing at this time.
Only one function is provided with this class currently:
\membersection{wxDbColFor::Format}\label{wxdbcolforformat}
\func{int }{Format}{\param{int }{Nation}, \param{int }{dbDataType},
\param{SWORD }{sqlDataType}, \param{short }{columnSize},
\param{short }{decimalDigits}}\label{wxdbcolforformat}
Work in progress, and should be inter-related with wxLocale eventually.
\membersection{wxDbColFor::Initialize}\label{wxdbcolforinitialize}
Simply initializes all member variables to a cleared state. Called by
the constructor automatically.
\section{\class{wxDbColInf}}\label{wxdbcolinf}
Used with the \helpref{wxDb::GetColumns}{wxdbgetcolumns} functions for obtaining all retrievable information about a column's definition.
@@ -1652,52 +1698,6 @@ the constructor automatically.
\section{\class{wxDbColFor}}\label{wxdbcolfor}
Beginning support for handling international formatting specifically on dates
and floats.
\begin{verbatim}
wxString s_Field; // Formated String for Output
wxString s_Format[7]; // Formated Objects - TIMESTAMP has
the biggest (7)
wxString s_Amount[7]; // Formated Objects - amount of
things that can be formatted
int i_Amount[7]; // Formated Objects -
TT MM YYYY HH MM SS m
int i_Nation; // 0 = timestamp
1 = EU
2 = UK
3 = International
4 = US
int i_dbDataType; // conversion of the 'sqlDataType'
to the generic data type used by
these classes
SWORD i_sqlDataType;
\end{verbatim}
The constructor for this class initializes all the values to zero or NULL.
The destructor does nothing at this time.
Only one function is provided with this class currently:
\membersection{wxDbColFor::Format}\label{wxdbcolforformat}
\func{int }{Format}{\param{int }{Nation}, \param{int }{dbDataType},
\param{SWORD }{sqlDataType}, \param{short }{columnSize},
\param{short }{decimalDigits}}\label{wxdbcolforformat}
Work in progress, and should be inter-related with wxLocale eventually.
\membersection{wxDbColFor::Initialize}\label{wxdbcolforinitialize}
Simply initializes all member variables to a cleared state. Called by
the constructor automatically.
\section{\class{wxDbConnectInf}}\label{wxdbconnectinf}
This class is used for holding the data necessary for connecting to the ODBC

79
docs/latex/wx/dir.tex
View File

@@ -178,82 +178,3 @@ subdirectories (both flags are included in the value by default).
See also: \helpref{Traverse}{wxdirtraverse}
\section{\class{wxDirTraverser}}\label{wxdirtraverser}
wxDirTraverser is an abstract interface which must be implemented by objects
passed to \helpref{Traverse}{wxdirtraverse} function.
Example of use (this works almost like \helpref{GetAllFiles}{wxdirgetallfiles}):
\begin{verbatim}
class wxDirTraverserSimple : public wxDirTraverser
{
public:
wxDirTraverserSimple(wxArrayString& files) : m_files(files) { }
virtual wxDirTraverseResult OnFile(const wxString& filename)
{
m_files.Add(filename);
return wxDIR_CONTINUE;
}
virtual wxDirTraverseResult OnDir(const wxString& WXUNUSED(dirname))
{
return wxDIR_CONTINUE;
}
private:
wxArrayString& m_files;
};
// get the names of all files in the array
wxArrayString files;
wxDirTraverserSimple traverser(files);
wxDir dir(dirname);
dir.Traverse(traverser);
\end{verbatim}
\wxheading{Derived from}
No base class
\wxheading{Constants}
The elements of {\tt wxDirTraverseResult} are the possible return values of the
callback functions:
{\small
\begin{verbatim}
enum wxDirTraverseResult
{
wxDIR_IGNORE = -1, // ignore this directory but continue with others
wxDIR_STOP, // stop traversing
wxDIR_CONTINUE // continue into this directory
};
\end{verbatim}
}
\wxheading{Include files}
<wx/dir.h>
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxDirTraverser::OnFile}\label{wxdirtraverseronfile}
\func{virtual wxDirTraverseResult}{OnFile}{\param{const wxString& }{filename}}
This function is called for each file. It may return {\tt wxDIR\_STOP} to abort
traversing (for example, if the file being searched is found) or
{\tt wxDIR\_CONTINUE} to proceed.
\membersection{wxDirTraverser::OnDir}\label{wxdirtraverserondir}
\func{virtual wxDirTraverseResult}{OnDir}{\param{const wxString& }{dirname}}
This function is called for each directory. It may return {\tt wxSIR\_STOP}
to abort traversing completely, {\tt wxDIR\_IGNORE} to skip this directory but
continue with others or {\tt wxDIR\_CONTINUE} to enumerate all files and
subdirectories in this directory.

91
docs/latex/wx/dirtrav.tex Normal file
View File

@@ -0,0 +1,91 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Name: dirtrav.tex
%% Purpose: wxDirTraverser documentation
%% Author: Vadim Zeitlin
%% Modified by:
%% Created: 14.01.02 (extracted from dir.tex)
%% RCS-ID: $Id$
%% Copyright: (c) Vadim Zeitlin
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxDirTraverser}}\label{wxdirtraverser}
wxDirTraverser is an abstract interface which must be implemented by objects
passed to \helpref{Traverse}{wxdirtraverse} function.
Example of use (this works almost like \helpref{GetAllFiles}{wxdirgetallfiles}):
\begin{verbatim}
class wxDirTraverserSimple : public wxDirTraverser
{
public:
wxDirTraverserSimple(wxArrayString& files) : m_files(files) { }
virtual wxDirTraverseResult OnFile(const wxString& filename)
{
m_files.Add(filename);
return wxDIR_CONTINUE;
}
virtual wxDirTraverseResult OnDir(const wxString& WXUNUSED(dirname))
{
return wxDIR_CONTINUE;
}
private:
wxArrayString& m_files;
};
// get the names of all files in the array
wxArrayString files;
wxDirTraverserSimple traverser(files);
wxDir dir(dirname);
dir.Traverse(traverser);
\end{verbatim}
\wxheading{Derived from}
No base class
\wxheading{Constants}
The elements of {\tt wxDirTraverseResult} are the possible return values of the
callback functions:
{\small
\begin{verbatim}
enum wxDirTraverseResult
{
wxDIR_IGNORE = -1, // ignore this directory but continue with others
wxDIR_STOP, // stop traversing
wxDIR_CONTINUE // continue into this directory
};
\end{verbatim}
}
\wxheading{Include files}
<wx/dir.h>
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxDirTraverser::OnFile}\label{wxdirtraverseronfile}
\func{virtual wxDirTraverseResult}{OnFile}{\param{const wxString& }{filename}}
This function is called for each file. It may return {\tt wxDIR\_STOP} to abort
traversing (for example, if the file being searched is found) or
{\tt wxDIR\_CONTINUE} to proceed.
\membersection{wxDirTraverser::OnDir}\label{wxdirtraverserondir}
\func{virtual wxDirTraverseResult}{OnDir}{\param{const wxString& }{dirname}}
This function is called for each directory. It may return {\tt wxSIR\_STOP}
to abort traversing completely, {\tt wxDIR\_IGNORE} to skip this directory but
continue with others or {\tt wxDIR\_CONTINUE} to enumerate all files and
subdirectories in this directory.

45
docs/latex/wx/dllload.tex
View File

@@ -145,48 +145,3 @@ FALSE; may also be {\tt NULL}.}
This function unloads the shared library. The handle {\it dllhandle} must have
been returned by \helpref{LoadLibrary}{wxdllloaderloadlibrary} previously.
\section{\class{wxDynamicLibrary}}\label{wxdynamiclibrary}
wxDynamicLibrary is a class representing dynamically loadable library
(Windows DLL, shared library under Unix etc.). It is implemented as a wrapper
to \helpref{wxDllLoader}{wxdllloader}.
\wxheading{See also}
\helpref{wxDllLoader}{wxdllloader}
\membersection{wxDynamicLibrary::wxDynamicLibrary}\label{wxdynamiclibrarywxdynamiclibrary}
\func{}{wxDynamicLibrary}{\void}
\func{}{wxDynamicLibrary}{\param{const wxString\& }{name}}
Constructor. Second form calls \helpref{Load}{wxdynamiclibraryload}.
\membersection{wxDynamicLibrary::IsLoaded}\label{wxdynamiclibraryisloaded}
\constfunc{bool}{IsLoaded}{\void}
Returns TRUE if the library was successfully loaded, FALSE otherwise.
\membersection{wxDynamicLibrary::Load}\label{wxdynamiclibraryload}
\func{bool}{Load}{\param{const wxString\& }{name}}
Loads DLL into memory.
Returns TRUE if the library was successfully loaded, FALSE otherwise.
\membersection{wxDynamicLibrary::Unload}\label{wxdynamiclibraryunload}
\func{void}{Unload}{\void}
Unloads the library from memory.
\membersection{wxDynamicLibrary::GetSymbol}\label{wxdynamiclibrarygetsymbol}
\constfunc{void*}{GetSymbol}{\param{const wxString\& }{name}}
Returns pointer to symbol {\it name} in the library or NULL if the library
contains no such symbol.

57
docs/latex/wx/dynlib.tex Normal file
View File

@@ -0,0 +1,57 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Name: dynlib.tex
%% Purpose: wxDynamicLibrary documentation
%% Author: Vadim Zeitlin
%% Modified by:
%% Created: 14.01.02 (extracted from dllload.tex)
%% RCS-ID: $Id$
%% Copyright: (c) Vadim Zeitlin
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxDynamicLibrary}}\label{wxdynamiclibrary}
wxDynamicLibrary is a class representing dynamically loadable library
(Windows DLL, shared library under Unix etc.). It is implemented as a wrapper
to \helpref{wxDllLoader}{wxdllloader}.
\wxheading{See also}
\helpref{wxDllLoader}{wxdllloader}
\membersection{wxDynamicLibrary::wxDynamicLibrary}\label{wxdynamiclibrarywxdynamiclibrary}
\func{}{wxDynamicLibrary}{\void}
\func{}{wxDynamicLibrary}{\param{const wxString\& }{name}}
Constructor. Second form calls \helpref{Load}{wxdynamiclibraryload}.
\membersection{wxDynamicLibrary::IsLoaded}\label{wxdynamiclibraryisloaded}
\constfunc{bool}{IsLoaded}{\void}
Returns TRUE if the library was successfully loaded, FALSE otherwise.
\membersection{wxDynamicLibrary::Load}\label{wxdynamiclibraryload}
\func{bool}{Load}{\param{const wxString\& }{name}}
Loads DLL into memory.
Returns TRUE if the library was successfully loaded, FALSE otherwise.
\membersection{wxDynamicLibrary::Unload}\label{wxdynamiclibraryunload}
\func{void}{Unload}{\void}
Unloads the library from memory.
\membersection{wxDynamicLibrary::GetSymbol}\label{wxdynamiclibrarygetsymbol}
\constfunc{void*}{GetSymbol}{\param{const wxString\& }{name}}
Returns pointer to symbol {\it name} in the library or NULL if the library
contains no such symbol.

213
docs/latex/wx/ffile.tex Normal file
View File

@@ -0,0 +1,213 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Name: ffile.tex
%% Purpose: wxFFile documentation
%% Author: Vadim Zeitlin
%% Modified by:
%% Created: 14.01.02 (extracted from file.tex)
%% RCS-ID: $Id$
%% Copyright: (c) Vadim Zeitlin
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxFFile}}\label{wxffile}
wxFFile implements buffered file I/O. This is a very small class designed to
minimize the overhead of using it - in fact, there is hardly any overhead at
all, but using it brings you automatic error checking and hides differences
between platforms and compilers. It wraps inside it a {\tt FILE *} handle used
by standard C IO library (also known as {\tt stdio}).
\wxheading{Derived from}
None.
\wxheading{Include files}
<wx/ffile.h>
\twocolwidtha{7cm}
\begin{twocollist}\itemsep=0pt%
\twocolitem{{\bf wxFromStart}}{Count offset from the start of the file}
\twocolitem{{\bf wxFromCurrent}}{Count offset from the current position of the file pointer}
\twocolitem{{\bf wxFromEnd}}{Count offset from the end of the file (backwards)}
\end{twocollist}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxFFile::wxFFile}\label{wxffileconstr}
\func{}{wxFFile}{\void}
Default constructor.
\func{}{wxFFile}{\param{const char*}{ filename}, \param{const char*}{ mode = "r"}}
Opens a file with the given mode. As there is no way to return whether the
operation was successful or not from the constructor you should test the
return value of \helpref{IsOpened}{wxffileisopened} to check that it didn't
fail.
\func{}{wxFFile}{\param{FILE*}{ fp}}
Opens a file with the given file pointer, which has already been opened.
\wxheading{Parameters}
\docparam{filename}{The filename.}
\docparam{mode}{The mode in which to open the file using standard C strings.
Note that you should use {\tt "b"} flag if you use binary files under Windows
or the results might be unexpected due to automatic newline conversion done
for the text files.}
\docparam{fp}{An existing file descriptor, such as stderr.}
\membersection{wxFFile::\destruct{wxFFile}}
\func{}{\destruct{wxFFile}}{\void}
Destructor will close the file.
NB: it is not virtual so you should {\it not} derive from wxFFile!
\membersection{wxFFile::Attach}\label{wxffileattach}
\func{void}{Attach}{\param{FILE*}{ fp}}
Attaches an existing file pointer to the wxFFile object.
The descriptor should be already opened and it will be closed by wxFFile
object.
\membersection{wxFFile::Close}\label{wxffileclose}
\func{bool}{Close}{\void}
Closes the file and returns TRUE on success.
\membersection{wxFFile::Detach}\label{wxffiledetach}
\func{void}{Detach}{\void}
Get back a file pointer from wxFFile object - the caller is responsible for closing the file if this
descriptor is opened. \helpref{IsOpened()}{wxffileisopened} will return FALSE after call to Detach().
\membersection{wxFFile::fp}\label{wxffilefp}
\constfunc{FILE *}{fp}{\void}
Returns the file pointer associated with the file.
\membersection{wxFFile::Eof}\label{wxffileeof}
\constfunc{bool}{Eof}{\void}
Returns TRUE if the an attempt has been made to read {\it past}
the end of the file.
Note that the behaviour of the file descriptor based class
\helpref{wxFile}{wxfile} is different as \helpref{wxFile::Eof}{wxfileeof}
will return TRUE here as soon as the last byte of the file has been
read.
\membersection{wxFFile::Flush}\label{wxffileflush}
\func{bool}{Flush}{\void}
Flushes the file and returns TRUE on success.
\membersection{wxFFile::IsOpened}\label{wxffileisopened}
\constfunc{bool}{IsOpened}{\void}
Returns TRUE if the file has been opened.
\membersection{wxFFile::Length}\label{wxffilelength}
\constfunc{size\_t}{Length}{\void}
Returns the length of the file.
\membersection{wxFFile::Open}\label{wxffileopen}
\func{bool}{Open}{\param{const char*}{ filename}, \param{const char*}{ mode = "r"}}
Opens the file, returning TRUE if successful.
\wxheading{Parameters}
\docparam{filename}{The filename.}
\docparam{mode}{The mode in which to open the file.}
\membersection{wxFFile::Read}\label{wxffileread}
\func{size\_t}{Read}{\param{void*}{ buffer}, \param{off\_t}{ count}}
Reads the specified number of bytes into a buffer, returning the actual number read.
\wxheading{Parameters}
\docparam{buffer}{A buffer to receive the data.}
\docparam{count}{The number of bytes to read.}
\wxheading{Return value}
The number of bytes read.
\membersection{wxFFile::Seek}\label{wxffileseek}
\func{bool}{Seek}{\param{long }{ofs}, \param{wxSeekMode }{mode = wxFromStart}}
Seeks to the specified position and returs TRUE on success.
\wxheading{Parameters}
\docparam{ofs}{Offset to seek to.}
\docparam{mode}{One of {\bf wxFromStart}, {\bf wxFromEnd}, {\bf wxFromCurrent}.}
\membersection{wxFFile::SeekEnd}\label{wxffileseekend}
\func{bool}{SeekEnd}{\param{long }{ofs = 0}}
Moves the file pointer to the specified number of bytes before the end of the file
and returns TRUE on success.
\wxheading{Parameters}
\docparam{ofs}{Number of bytes before the end of the file.}
\membersection{wxFFile::Tell}\label{wxffiletell}
\constfunc{size\_t}{Tell}{\void}
Returns the current position.
\membersection{wxFFile::Write}\label{wxffilewrite}
\func{size\_t}{Write}{\param{const void*}{ buffer}, \param{size\_t}{ count}}
Writes the specified number of bytes from a buffer.
\wxheading{Parameters}
\docparam{buffer}{A buffer containing the data.}
\docparam{count}{The number of bytes to write.}
\wxheading{Return value}
Number of bytes written.
\membersection{wxFFile::Write}\label{wxffilewrites}
\func{bool}{Write}{\param{const wxString\& }{s}, \param{wxMBConv&}{ conv = wxConvLibc}}
Writes the contents of the string to the file, returns TRUE on success.
The second argument is only meaningful in Unicode build of wxWindows when
{\it conv} is used to convert {\it s} to multibyte representation.

150
docs/latex/wx/strmfile.tex → docs/latex/wx/ffilestr.tex
View File

@@ -1,153 +1,3 @@
% -----------------------------------------------------------------------------
% wxFileInputStream
% -----------------------------------------------------------------------------
\section{\class{wxFileInputStream}}\label{wxfileinputstream}
This class represents data read in from a file. There are actually
two such groups of classes: this one is based on \helpref{wxFile}{wxfile}
whereas \helpref{wxFFileInputStream}{wxffileinputstream} is based in
the \helpref{wxFFile}{wxffile} class.
Note that \helpref{wxFile}{wxfile} and \helpref{wxFFile}{wxffile} differ
in one aspect, namely when to report that the end of the file has been
reached. This is documented in \helpref{wxFile::Eof}{wxfileeof} and
\helpref{wxFFile::Eof}{wxffileeof} and the behaviour of the stream
classes reflects this difference, i.e. wxFileInputStream will report
wxSTREAM\_EOF after having read the last byte whereas wxFFileInputStream
will report wxSTREAM\_EOF after trying to read {\it past} the last byte.
\wxheading{Derived from}
\helpref{wxInputStream}{wxinputstream}
\wxheading{Include files}
<wx/wfstream.h>
\wxheading{See also}
\helpref{wxBufferedInputStream}{wxbufferedinputstream}, \helpref{wxFileOutputStream}{wxfileoutputstream}, \helpref{wxFFileOutputStream}{wxffileoutputstream}
% ----------
% Members
% ----------
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxFileInputStream::wxFileInputStream}
\func{}{wxFileInputStream}{\param{const wxString\&}{ ifileName}}
Opens the specified file using its {\it ifilename} name in read-only mode.
\func{}{wxFileInputStream}{\param{wxFile\&}{ file}}
Initializes a file stream in read-only mode using the file I/O object {\it file}.
\func{}{wxFileInputStream}{\param{int}{ fd}}
Initializes a file stream in read-only mode using the specified file descriptor.
\membersection{wxFileInputStream::\destruct{wxFileInputStream}}
\func{}{\destruct{wxFileInputStream}}{\void}
Destructor.
\membersection{wxFileInputStream::Ok}
\constfunc{bool}{Ok}{\void}
Returns TRUE if the stream is initialized and ready.
% -----------------------------------------------------------------------------
% wxFileOutputStream
% -----------------------------------------------------------------------------
\section{\class{wxFileOutputStream}}\label{wxfileoutputstream}
This class represents data written to a file. There are actually
two such groups of classes: this one is based on \helpref{wxFile}{wxfile}
whereas \helpref{wxFFileInputStream}{wxffileinputstream} is based in
the \helpref{wxFFile}{wxffile} class.
Note that \helpref{wxFile}{wxfile} and \helpref{wxFFile}{wxffile} differ
in one aspect, namely when to report that the end of the file has been
reached. This is documented in \helpref{wxFile::Eof}{wxfileeof} and
\helpref{wxFFile::Eof}{wxffileeof} and the behaviour of the stream
classes reflects this difference, i.e. wxFileInputStream will report
wxSTREAM\_EOF after having read the last byte whereas wxFFileInputStream
will report wxSTREAM\_EOF after trying to read {\it past} the last byte.
\wxheading{Derived from}
\helpref{wxOutputStream}{wxoutputstream}
\wxheading{Include files}
<wx/wfstream.h>
\wxheading{See also}
\helpref{wxBufferedOutputStream}{wxbufferedoutputstream}, \helpref{wxFileInputStream}{wxfileinputstream}, \helpref{wxFFileInputStream}{wxffileinputstream}
% ----------
% Members
% ----------
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxFileOutputStream::wxFileOutputStream}
\func{}{wxFileOutputStream}{\param{const wxString\&}{ ofileName}}
Creates a new file with {\it ofilename} name and initializes the stream in
write-only mode.
\func{}{wxFileOutputStream}{\param{wxFile\&}{ file}}
Initializes a file stream in write-only mode using the file I/O object {\it file}.
\func{}{wxFileOutputStream}{\param{int}{ fd}}
Initializes a file stream in write-only mode using the file descriptor {\it fd}.
\membersection{wxFileOutputStream::\destruct{wxFileOutputStream}}
\func{}{\destruct{wxFileOutputStream}}{\void}
Destructor.
\membersection{wxFileOutputStream::Ok}
\constfunc{bool}{Ok}{\void}
Returns TRUE if the stream is initialized and ready.
% -----------------------------------------------------------------------------
% wxFileStream
% -----------------------------------------------------------------------------
\section{\class{wxFileStream}}
\wxheading{Derived from}
\helpref{wxFileOutputStream}{wxfileoutputstream}, \helpref{wxFileInputStream}{wxfileinputstream}
\wxheading{Include files}
<wx/wfstream.h>
\wxheading{See also}
\helpref{wxStreamBuffer}{wxstreambuffer}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxFileStream::wxFileStream}
\func{}{wxFileStream}{\param{const wxString\&}{ iofileName}}
Initializes a new file stream in read-write mode using the specified
{\it iofilename} name.
% -----------------------------------------------------------------------------
% wxFFileInputStream
% -----------------------------------------------------------------------------

212
docs/latex/wx/file.tex
View File

@@ -1,3 +1,14 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Name: file.tex
%% Purpose: wxFile documentation
%% Author: Vadim Zeitlin
%% Modified by:
%% Created: 14.01.02 (extracted from file.tex)
%% RCS-ID: $Id$
%% Copyright: (c) Vadim Zeitlin
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxFile}}\label{wxfile}
A wxFile performs raw file I/O. This is a very small class designed to
@@ -287,204 +298,3 @@ Writes the contents of the string to the file, returns TRUE on success.
The second argument is only meaningful in Unicode build of wxWindows when
{\it conv} is used to convert {\it s} to multibyte representation.
\section{\class{wxFFile}}\label{wxffile}
wxFFile implements buffered file I/O. This is a very small class designed to
minimize the overhead of using it - in fact, there is hardly any overhead at
all, but using it brings you automatic error checking and hides differences
between platforms and compilers. It wraps inside it a {\tt FILE *} handle used
by standard C IO library (also known as {\tt stdio}).
\wxheading{Derived from}
None.
\wxheading{Include files}
<wx/ffile.h>
\twocolwidtha{7cm}
\begin{twocollist}\itemsep=0pt%
\twocolitem{{\bf wxFromStart}}{Count offset from the start of the file}
\twocolitem{{\bf wxFromCurrent}}{Count offset from the current position of the file pointer}
\twocolitem{{\bf wxFromEnd}}{Count offset from the end of the file (backwards)}
\end{twocollist}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxFFile::wxFFile}\label{wxffileconstr}
\func{}{wxFFile}{\void}
Default constructor.
\func{}{wxFFile}{\param{const char*}{ filename}, \param{const char*}{ mode = "r"}}
Opens a file with the given mode. As there is no way to return whether the
operation was successful or not from the constructor you should test the
return value of \helpref{IsOpened}{wxffileisopened} to check that it didn't
fail.
\func{}{wxFFile}{\param{FILE*}{ fp}}
Opens a file with the given file pointer, which has already been opened.
\wxheading{Parameters}
\docparam{filename}{The filename.}
\docparam{mode}{The mode in which to open the file using standard C strings.
Note that you should use {\tt "b"} flag if you use binary files under Windows
or the results might be unexpected due to automatic newline conversion done
for the text files.}
\docparam{fp}{An existing file descriptor, such as stderr.}
\membersection{wxFFile::\destruct{wxFFile}}
\func{}{\destruct{wxFFile}}{\void}
Destructor will close the file.
NB: it is not virtual so you should {\it not} derive from wxFFile!
\membersection{wxFFile::Attach}\label{wxffileattach}
\func{void}{Attach}{\param{FILE*}{ fp}}
Attaches an existing file pointer to the wxFFile object.
The descriptor should be already opened and it will be closed by wxFFile
object.
\membersection{wxFFile::Close}\label{wxffileclose}
\func{bool}{Close}{\void}
Closes the file and returns TRUE on success.
\membersection{wxFFile::Detach}\label{wxffiledetach}
\func{void}{Detach}{\void}
Get back a file pointer from wxFFile object - the caller is responsible for closing the file if this
descriptor is opened. \helpref{IsOpened()}{wxffileisopened} will return FALSE after call to Detach().
\membersection{wxFFile::fp}\label{wxffilefp}
\constfunc{FILE *}{fp}{\void}
Returns the file pointer associated with the file.
\membersection{wxFFile::Eof}\label{wxffileeof}
\constfunc{bool}{Eof}{\void}
Returns TRUE if the an attempt has been made to read {\it past}
the end of the file.
Note that the behaviour of the file descriptor based class
\helpref{wxFile}{wxfile} is different as \helpref{wxFile::Eof}{wxfileeof}
will return TRUE here as soon as the last byte of the file has been
read.
\membersection{wxFFile::Flush}\label{wxffileflush}
\func{bool}{Flush}{\void}
Flushes the file and returns TRUE on success.
\membersection{wxFFile::IsOpened}\label{wxffileisopened}
\constfunc{bool}{IsOpened}{\void}
Returns TRUE if the file has been opened.
\membersection{wxFFile::Length}\label{wxffilelength}
\constfunc{size\_t}{Length}{\void}
Returns the length of the file.
\membersection{wxFFile::Open}\label{wxffileopen}
\func{bool}{Open}{\param{const char*}{ filename}, \param{const char*}{ mode = "r"}}
Opens the file, returning TRUE if successful.
\wxheading{Parameters}
\docparam{filename}{The filename.}
\docparam{mode}{The mode in which to open the file.}
\membersection{wxFFile::Read}\label{wxffileread}
\func{size\_t}{Read}{\param{void*}{ buffer}, \param{off\_t}{ count}}
Reads the specified number of bytes into a buffer, returning the actual number read.
\wxheading{Parameters}
\docparam{buffer}{A buffer to receive the data.}
\docparam{count}{The number of bytes to read.}
\wxheading{Return value}
The number of bytes read.
\membersection{wxFFile::Seek}\label{wxffileseek}
\func{bool}{Seek}{\param{long }{ofs}, \param{wxSeekMode }{mode = wxFromStart}}
Seeks to the specified position and returs TRUE on success.
\wxheading{Parameters}
\docparam{ofs}{Offset to seek to.}
\docparam{mode}{One of {\bf wxFromStart}, {\bf wxFromEnd}, {\bf wxFromCurrent}.}
\membersection{wxFFile::SeekEnd}\label{wxffileseekend}
\func{bool}{SeekEnd}{\param{long }{ofs = 0}}
Moves the file pointer to the specified number of bytes before the end of the file
and returns TRUE on success.
\wxheading{Parameters}
\docparam{ofs}{Number of bytes before the end of the file.}
\membersection{wxFFile::Tell}\label{wxffiletell}
\constfunc{size\_t}{Tell}{\void}
Returns the current position.
\membersection{wxFFile::Write}\label{wxffilewrite}
\func{size\_t}{Write}{\param{const void*}{ buffer}, \param{size\_t}{ count}}
Writes the specified number of bytes from a buffer.
\wxheading{Parameters}
\docparam{buffer}{A buffer containing the data.}
\docparam{count}{The number of bytes to write.}
\wxheading{Return value}
Number of bytes written.
\membersection{wxFFile::Write}\label{wxffilewrites}
\func{bool}{Write}{\param{const wxString\& }{s}, \param{wxMBConv&}{ conv = wxConvLibc}}
Writes the contents of the string to the file, returns TRUE on success.
The second argument is only meaningful in Unicode build of wxWindows when
{\it conv} is used to convert {\it s} to multibyte representation.

146
docs/latex/wx/filestrm.tex Normal file
View File

@@ -0,0 +1,146 @@
\section{\class{wxFileInputStream}}\label{wxfileinputstream}
This class represents data read in from a file. There are actually
two such groups of classes: this one is based on \helpref{wxFile}{wxfile}
whereas \helpref{wxFFileInputStream}{wxffileinputstream} is based in
the \helpref{wxFFile}{wxffile} class.
Note that \helpref{wxFile}{wxfile} and \helpref{wxFFile}{wxffile} differ
in one aspect, namely when to report that the end of the file has been
reached. This is documented in \helpref{wxFile::Eof}{wxfileeof} and
\helpref{wxFFile::Eof}{wxffileeof} and the behaviour of the stream
classes reflects this difference, i.e. wxFileInputStream will report
wxSTREAM\_EOF after having read the last byte whereas wxFFileInputStream
will report wxSTREAM\_EOF after trying to read {\it past} the last byte.
\wxheading{Derived from}
\helpref{wxInputStream}{wxinputstream}
\wxheading{Include files}
<wx/wfstream.h>
\wxheading{See also}
\helpref{wxBufferedInputStream}{wxbufferedinputstream}, \helpref{wxFileOutputStream}{wxfileoutputstream}, \helpref{wxFFileOutputStream}{wxffileoutputstream}
% ----------
% Members
% ----------
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxFileInputStream::wxFileInputStream}
\func{}{wxFileInputStream}{\param{const wxString\&}{ ifileName}}
Opens the specified file using its {\it ifilename} name in read-only mode.
\func{}{wxFileInputStream}{\param{wxFile\&}{ file}}
Initializes a file stream in read-only mode using the file I/O object {\it file}.
\func{}{wxFileInputStream}{\param{int}{ fd}}
Initializes a file stream in read-only mode using the specified file descriptor.
\membersection{wxFileInputStream::\destruct{wxFileInputStream}}
\func{}{\destruct{wxFileInputStream}}{\void}
Destructor.
\membersection{wxFileInputStream::Ok}
\constfunc{bool}{Ok}{\void}
Returns TRUE if the stream is initialized and ready.
% -----------------------------------------------------------------------------
% wxFileOutputStream
% -----------------------------------------------------------------------------
\section{\class{wxFileOutputStream}}\label{wxfileoutputstream}
This class represents data written to a file. There are actually
two such groups of classes: this one is based on \helpref{wxFile}{wxfile}
whereas \helpref{wxFFileInputStream}{wxffileinputstream} is based in
the \helpref{wxFFile}{wxffile} class.
Note that \helpref{wxFile}{wxfile} and \helpref{wxFFile}{wxffile} differ
in one aspect, namely when to report that the end of the file has been
reached. This is documented in \helpref{wxFile::Eof}{wxfileeof} and
\helpref{wxFFile::Eof}{wxffileeof} and the behaviour of the stream
classes reflects this difference, i.e. wxFileInputStream will report
wxSTREAM\_EOF after having read the last byte whereas wxFFileInputStream
will report wxSTREAM\_EOF after trying to read {\it past} the last byte.
\wxheading{Derived from}
\helpref{wxOutputStream}{wxoutputstream}
\wxheading{Include files}
<wx/wfstream.h>
\wxheading{See also}
\helpref{wxBufferedOutputStream}{wxbufferedoutputstream}, \helpref{wxFileInputStream}{wxfileinputstream}, \helpref{wxFFileInputStream}{wxffileinputstream}
% ----------
% Members
% ----------
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxFileOutputStream::wxFileOutputStream}
\func{}{wxFileOutputStream}{\param{const wxString\&}{ ofileName}}
Creates a new file with {\it ofilename} name and initializes the stream in
write-only mode.
\func{}{wxFileOutputStream}{\param{wxFile\&}{ file}}
Initializes a file stream in write-only mode using the file I/O object {\it file}.
\func{}{wxFileOutputStream}{\param{int}{ fd}}
Initializes a file stream in write-only mode using the file descriptor {\it fd}.
\membersection{wxFileOutputStream::\destruct{wxFileOutputStream}}
\func{}{\destruct{wxFileOutputStream}}{\void}
Destructor.
\membersection{wxFileOutputStream::Ok}
\constfunc{bool}{Ok}{\void}
Returns TRUE if the stream is initialized and ready.
% -----------------------------------------------------------------------------
% wxFileStream
% -----------------------------------------------------------------------------
\section{\class{wxFileStream}}
\wxheading{Derived from}
\helpref{wxFileOutputStream}{wxfileoutputstream}, \helpref{wxFileInputStream}{wxfileinputstream}
\wxheading{Include files}
<wx/wfstream.h>
\wxheading{See also}
\helpref{wxStreamBuffer}{wxstreambuffer}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxFileStream::wxFileStream}
\func{}{wxFileStream}{\param{const wxString\&}{ iofileName}}
Initializes a new file stream in read-write mode using the specified
{\it iofilename} name.

165
docs/latex/wx/gridedit.tex
View File

@@ -3,6 +3,67 @@
% grid.h at 11/May/00 18:30:18
%
\section{\class{wxGridCellBoolEditor}}\label{wxgridcellbooleditor}
The editor for boolean data.
\wxheading{Derived from}
\helpref{wxGridCellEditor}{wxgridcelleditor}
\wxheading{See also}
\helpref{wxGridCellEditor}{wxgridcelleditor},\rtfsp
\helpref{wxGridCellFloatEditor}{wxgridcellfloateditor},\rtfsp
\helpref{wxGridCellNumberEditor}{wxgridcellnumbereditor},\rtfsp
\helpref{wxGridCellTextEditor}{wxgridcelltexteditor},\rtfsp
\helpref{wxGridCellChoiceEditor}{wxgridcellchoiceeditor}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxGridCellBoolEditor::wxGridCellBoolEditor}\label{wxgridcellbooleditorconstr}
\func{}{wxGridCellBoolEditor}{}
Default constructor.
\section{\class{wxGridCellChoiceEditor}}\label{wxgridcellchoiceeditor}
The editor for string data allowing to choose from a list of strings.
\wxheading{Derived from}
\helpref{wxGridCellEditor}{wxgridcelleditor}
\wxheading{See also}
\helpref{wxGridCellEditor}{wxgridcelleditor},\rtfsp
\helpref{wxGridCellFloatEditor}{wxgridcellfloateditor},\rtfsp
\helpref{wxGridCellBoolEditor}{wxgridcellbooleditor},\rtfsp
\helpref{wxGridCellTextEditor}{wxgridcelltexteditor},\rtfsp
\helpref{wxGridCellNumberEditor}{wxgridcellnumbereditor}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxGridCellChoiceEditor::wxGridCellChoiceEditor}\label{wxgridcellchoiceeditorconstr}
\func{}{wxGridCellChoiceEditor}{\param{size\_t }{count = 0}, \param{const wxString }{choices[] = NULL}, \param{bool }{allowOthers = FALSE}}
\docparam{count}{Number of strings from which the user can choose.}
\docparam{choices}{An array of strings from which the user can choose.}
\docparam{allowOthers}{If allowOthers if TRUE, the user can type a string not in choices array.}
\membersection{wxGridCellChoiceEditor::SetParameters}\label{wxgridcellchoiceeditorsetparameters}
\func{void}{SetParameters}{\param{const wxString\& }{params}}
Parameters string format is "item1[,item2[...,itemN]]"
\section{\class{wxGridCellEditor}}\label{wxgridcelleditor}
This class is responsible for providing and manipulating
@@ -120,36 +181,41 @@ Create a new object which is the copy of this one.
The dtor is private because only DecRef() can delete us.
\section{\class{wxGridCellTextEditor}}\label{wxgridcelltexteditor}
\section{\class{wxGridCellFloatEditor}}\label{wxgridcellfloateditor}
The editor for string/text data.
The editor for floating point numbers data.
\wxheading{Derived from}
\helpref{wxGridCellTextEditor}{wxgridcelltexteditor}\\
\helpref{wxGridCellEditor}{wxgridcelleditor}
\wxheading{See also}
\helpref{wxGridCellEditor}{wxgridcelleditor},\rtfsp
\helpref{wxGridCellFloatEditor}{wxgridcellfloateditor},\rtfsp
\helpref{wxGridCellBoolEditor}{wxgridcellbooleditor},\rtfsp
\helpref{wxGridCellNumberEditor}{wxgridcellnumbereditor},\rtfsp
\helpref{wxGridCellBoolEditor}{wxgridcellbooleditor},\rtfsp
\helpref{wxGridCellTextEditor}{wxgridcelltexteditor},\rtfsp
\helpref{wxGridCellChoiceEditor}{wxgridcellchoiceeditor}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxGridCellTextEditor::wxGridCellTextEditor}\label{wxgridcelltexteditorconstr}
\membersection{wxGridCellFloatEditor::wxGridCellFloatEditor}\label{wxgridcellfloateditorconstr}
\func{}{wxGridCellTextEditor}{\void}
\func{}{wxGridCellFloatEditor}{\param{int }{width = -1}, \param{int }{precision = -1}}
Default constructor.
\docparam{width}{Minimum number of characters to be shown.}
\docparam{precision}{Number of digits after the decimal dot.}
\membersection{wxGridCellTextEditor::SetParameters}\label{wxgridcelltexteditorsetparameters}
\membersection{wxGridCellFloatEditor::SetParameters}\label{wxgridcellfloateditorsetparameters}
\func{void}{SetParameters}{\param{const wxString\& }{params}}
The parameters string format is "n" where n is a number representing the maximum width.
Parameters string format is "width,precision"
\section{\class{wxGridCellNumberEditor}}\label{wxgridcellnumbereditor}
@@ -203,45 +269,9 @@ otherwise it uses a wxTextCtrl.
Parameters string format is "min,max".
\section{\class{wxGridCellFloatEditor}}\label{wxgridcellfloateditor}
\section{\class{wxGridCellTextEditor}}\label{wxgridcelltexteditor}
The editor for floating point numbers data.
\wxheading{Derived from}
\helpref{wxGridCellTextEditor}{wxgridcelltexteditor}\\
\helpref{wxGridCellEditor}{wxgridcelleditor}
\wxheading{See also}
\helpref{wxGridCellEditor}{wxgridcelleditor},\rtfsp
\helpref{wxGridCellNumberEditor}{wxgridcellnumbereditor},\rtfsp
\helpref{wxGridCellBoolEditor}{wxgridcellbooleditor},\rtfsp
\helpref{wxGridCellTextEditor}{wxgridcelltexteditor},\rtfsp
\helpref{wxGridCellChoiceEditor}{wxgridcellchoiceeditor}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxGridCellFloatEditor::wxGridCellFloatEditor}\label{wxgridcellfloateditorconstr}
\func{}{wxGridCellFloatEditor}{\param{int }{width = -1}, \param{int }{precision = -1}}
\docparam{width}{Minimum number of characters to be shown.}
\docparam{precision}{Number of digits after the decimal dot.}
\membersection{wxGridCellFloatEditor::SetParameters}\label{wxgridcellfloateditorsetparameters}
\func{void}{SetParameters}{\param{const wxString\& }{params}}
Parameters string format is "width,precision"
\section{\class{wxGridCellBoolEditor}}\label{wxgridcellbooleditor}
The editor for boolean data.
The editor for string/text data.
\wxheading{Derived from}
@@ -251,52 +281,23 @@ The editor for boolean data.
\helpref{wxGridCellEditor}{wxgridcelleditor},\rtfsp
\helpref{wxGridCellFloatEditor}{wxgridcellfloateditor},\rtfsp
\helpref{wxGridCellBoolEditor}{wxgridcellbooleditor},\rtfsp
\helpref{wxGridCellNumberEditor}{wxgridcellnumbereditor},\rtfsp
\helpref{wxGridCellTextEditor}{wxgridcelltexteditor},\rtfsp
\helpref{wxGridCellChoiceEditor}{wxgridcellchoiceeditor}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxGridCellBoolEditor::wxGridCellBoolEditor}\label{wxgridcellbooleditorconstr}
\membersection{wxGridCellTextEditor::wxGridCellTextEditor}\label{wxgridcelltexteditorconstr}
\func{}{wxGridCellBoolEditor}{}
\func{}{wxGridCellTextEditor}{\void}
Default constructor.
\section{\class{wxGridCellChoiceEditor}}\label{wxgridcellchoiceeditor}
The editor for string data allowing to choose from a list of strings.
\wxheading{Derived from}
\helpref{wxGridCellEditor}{wxgridcelleditor}
\wxheading{See also}
\helpref{wxGridCellEditor}{wxgridcelleditor},\rtfsp
\helpref{wxGridCellFloatEditor}{wxgridcellfloateditor},\rtfsp
\helpref{wxGridCellBoolEditor}{wxgridcellbooleditor},\rtfsp
\helpref{wxGridCellTextEditor}{wxgridcelltexteditor},\rtfsp
\helpref{wxGridCellNumberEditor}{wxgridcellnumbereditor}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxGridCellChoiceEditor::wxGridCellChoiceEditor}\label{wxgridcellchoiceeditorconstr}
\func{}{wxGridCellChoiceEditor}{\param{size\_t }{count = 0}, \param{const wxString }{choices[] = NULL}, \param{bool }{allowOthers = FALSE}}
\docparam{count}{Number of strings from which the user can choose.}
\docparam{choices}{An array of strings from which the user can choose.}
\docparam{allowOthers}{If allowOthers if TRUE, the user can type a string not in choices array.}
\membersection{wxGridCellChoiceEditor::SetParameters}\label{wxgridcellchoiceeditorsetparameters}
\membersection{wxGridCellTextEditor::SetParameters}\label{wxgridcelltexteditorsetparameters}
\func{void}{SetParameters}{\param{const wxString\& }{params}}
Parameters string format is "item1[,item2[...,itemN]]"
The parameters string format is "n" where n is a number representing the maximum width.

200
docs/latex/wx/gridevt.tex
View File

@@ -1,3 +1,68 @@
\section{\class{wxGridEditorCreatedEvent}}\label{wxgrideditorcreatedevent}
\wxheading{Derived from}
\helpref{wxCommandEvent}{wxcommandevent}\\
\helpref{wxEvent}{wxevent}\\
\helpref{wxObject}{wxobject}
\wxheading{Event handling}
The event handler for the following functions takes a
\helpref{wxGridEditorCreatedEvent}{wxgrideditorcreatedevent} parameter.
\twocolwidtha{7cm}
\begin{twocollist}\itemsep=0pt
\twocolitem{{\bf EVT\_GRID\_EDITOR\_CREATED(func)}}{The editor for a cell was created. Processes a wxEVT\_GRID\_EDITOR\_CREATED.}
\end{twocollist}%
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxGridEditorCreatedEvent::wxGridEditorCreatedEvent}\label{wxgrideditorcreatedeventconstr}
\func{}{wxGridEditorCreatedEvent}{\void}
Default constructor.
\func{}{wxGridEditorCreatedEvent}{\param{int }{id}, \param{wxEventType }{type},
\param{wxObject* }{obj}, \param{int }{row}, \param{int }{col}, \param{wxControl* }{ctrl}}
\membersection{wxGridEditorCreatedEvent::GetCol}\label{wxgrideditorcreatedeventgetcol}
\func{int}{GetCol}{\void}
Returns the column at which the event occurred.
\membersection{wxGridEditorCreatedEvent::GetControl}\label{wxgrideditorcreatedeventgetcontrol}
\func{wxControl*}{GetControl}{\void}
Returns the edit control.
\membersection{wxGridEditorCreatedEvent::GetRow}\label{wxgrideditorcreatedeventgetrow}
\func{int}{GetRow}{\void}
Returns the row at which the event occurred.
\membersection{wxGridEditorCreatedEvent::SetCol}\label{wxgrideditorcreatedeventsetcol}
\func{void}{SetCol}{\param{int }{col}}
Sets the column at which the event occurred.
\membersection{wxGridEditorCreatedEvent::SetControl}\label{wxgrideditorcreatedeventsetcontrol}
\func{void}{SetControl}{\param{wxControl* }{ctrl}}
Sets the edit control.
\membersection{wxGridEditorCreatedEvent::SetRow}\label{wxgrideditorcreatedeventsetrow}
\func{void}{SetRow}{\param{int }{row}}
Sets the row at which the event occurred.
\section{\class{wxGridEvent}}\label{wxgridevent}
This event class contains information about various grid events.
@@ -81,81 +146,6 @@ deselected a cell.
Returns TRUE if the Shift key was down at the time of the event.
\section{\class{wxGridSizeEvent}}\label{wxgridsizeevent}
This event class contains information about a row/column resize event.
\wxheading{Derived from}
\helpref{wxNotifyEvent}{wxnotifyevent}\\
\helpref{wxCommandEvent}{wxcommandevent}\\
\helpref{wxEvent}{wxevent}\\
\helpref{wxObject}{wxobject}
\wxheading{Include files}
<wx/grid.h>
\wxheading{Event handling}
The event handler for the following functions takes a
\helpref{wxGridSizeEvent}{wxgridsizeevent} parameter.
\twocolwidtha{7cm}
\begin{twocollist}\itemsep=0pt
\twocolitem{{\bf EVT\_GRID\_COL\_SIZE(func)}}{The user resized a column by dragging it. Processes a wxEVT\_GRID\_COL\_SIZE.}
\twocolitem{{\bf EVT\_GRID\_ROW\_SIZE(func)}}{The user resized a row by dragging it. Processes a wxEVT\_GRID\_ROW\_SIZE.}
\end{twocollist}%
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxGridSizeEvent::wxGridSizeEvent}\label{wxgridsizeeventconstr}
\func{}{wxGridSizeEvent}{\void}
Default constructor.
\func{}{wxGridSizeEvent}{\param{int }{id}, \param{wxEventType }{type},
\param{wxObject* }{obj}, \param{int }{rowOrCol = -1}, \param{int }{x = -1},
\param{int }{y = -1}, \param{bool }{control = FALSE}, \param{bool }{shift = FALSE},
\param{bool }{alt = FALSE}, \param{bool }{meta = FALSE}}
\membersection{wxGridSizeEvent::AltDown}\label{wxgridsizeeventaltdown}
\func{bool}{AltDown}{\void}
Returns TRUE if the Alt key was down at the time of the event.
\membersection{wxGridSizeEvent::ControlDown}\label{wxgridsizeeventcontroldown}
\func{bool}{ControlDown}{\void}
Returns TRUE if the Control key was down at the time of the event.
\membersection{wxGridSizeEvent::GetPosition}\label{wxgridsizeeventgetposition}
\func{wxPoint}{GetPosition}{\void}
Position in pixels at which the event occurred.
\membersection{wxGridSizeEvent::GetRowOrCol}\label{wxgridsizeeventgetroworcol}
\func{int}{GetRowOrCol}{\void}
Row or column at that was resized.
\membersection{wxGridSizeEvent::MetaDown}\label{wxgridsizeeventmetadown}
\func{bool}{MetaDown}{\void}
Returns TRUE if the Meta key was down at the time of the event.
\membersection{wxGridSizeEvent::ShiftDown}\label{wxgridsizeeventshiftdown}
\func{bool}{ShiftDown}{\void}
Returns TRUE if the Shift key was down at the time of the event.
\section{\class{wxGridRangeSelectEvent}}\label{wxgridrangeselectevent}
\wxheading{Derived from}
@@ -255,68 +245,78 @@ Returns TRUE if the area was selected, FALSE otherwise.
Returns TRUE if the Shift key was down at the time of the event.
\section{\class{wxGridEditorCreatedEvent}}\label{wxgrideditorcreatedevent}
\section{\class{wxGridSizeEvent}}\label{wxgridsizeevent}
This event class contains information about a row/column resize event.
\wxheading{Derived from}
\helpref{wxNotifyEvent}{wxnotifyevent}\\
\helpref{wxCommandEvent}{wxcommandevent}\\
\helpref{wxEvent}{wxevent}\\
\helpref{wxObject}{wxobject}
\wxheading{Include files}
<wx/grid.h>
\wxheading{Event handling}
The event handler for the following functions takes a
\helpref{wxGridEditorCreatedEvent}{wxgrideditorcreatedevent} parameter.
\helpref{wxGridSizeEvent}{wxgridsizeevent} parameter.
\twocolwidtha{7cm}
\begin{twocollist}\itemsep=0pt
\twocolitem{{\bf EVT\_GRID\_EDITOR\_CREATED(func)}}{The editor for a cell was created. Processes a wxEVT\_GRID\_EDITOR\_CREATED.}
\twocolitem{{\bf EVT\_GRID\_COL\_SIZE(func)}}{The user resized a column by dragging it. Processes a wxEVT\_GRID\_COL\_SIZE.}
\twocolitem{{\bf EVT\_GRID\_ROW\_SIZE(func)}}{The user resized a row by dragging it. Processes a wxEVT\_GRID\_ROW\_SIZE.}
\end{twocollist}%
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxGridEditorCreatedEvent::wxGridEditorCreatedEvent}\label{wxgrideditorcreatedeventconstr}
\membersection{wxGridSizeEvent::wxGridSizeEvent}\label{wxgridsizeeventconstr}
\func{}{wxGridEditorCreatedEvent}{\void}
\func{}{wxGridSizeEvent}{\void}
Default constructor.
\func{}{wxGridEditorCreatedEvent}{\param{int }{id}, \param{wxEventType }{type},
\param{wxObject* }{obj}, \param{int }{row}, \param{int }{col}, \param{wxControl* }{ctrl}}
\func{}{wxGridSizeEvent}{\param{int }{id}, \param{wxEventType }{type},
\param{wxObject* }{obj}, \param{int }{rowOrCol = -1}, \param{int }{x = -1},
\param{int }{y = -1}, \param{bool }{control = FALSE}, \param{bool }{shift = FALSE},
\param{bool }{alt = FALSE}, \param{bool }{meta = FALSE}}
\membersection{wxGridEditorCreatedEvent::GetCol}\label{wxgrideditorcreatedeventgetcol}
\membersection{wxGridSizeEvent::AltDown}\label{wxgridsizeeventaltdown}
\func{int}{GetCol}{\void}
\func{bool}{AltDown}{\void}
Returns the column at which the event occurred.
Returns TRUE if the Alt key was down at the time of the event.
\membersection{wxGridEditorCreatedEvent::GetControl}\label{wxgrideditorcreatedeventgetcontrol}
\membersection{wxGridSizeEvent::ControlDown}\label{wxgridsizeeventcontroldown}
\func{wxControl*}{GetControl}{\void}
\func{bool}{ControlDown}{\void}
Returns the edit control.
Returns TRUE if the Control key was down at the time of the event.
\membersection{wxGridEditorCreatedEvent::GetRow}\label{wxgrideditorcreatedeventgetrow}
\membersection{wxGridSizeEvent::GetPosition}\label{wxgridsizeeventgetposition}
\func{int}{GetRow}{\void}
\func{wxPoint}{GetPosition}{\void}
Returns the row at which the event occurred.
Position in pixels at which the event occurred.
\membersection{wxGridEditorCreatedEvent::SetCol}\label{wxgrideditorcreatedeventsetcol}
\membersection{wxGridSizeEvent::GetRowOrCol}\label{wxgridsizeeventgetroworcol}
\func{void}{SetCol}{\param{int }{col}}
\func{int}{GetRowOrCol}{\void}
Sets the column at which the event occurred.
Row or column at that was resized.
\membersection{wxGridEditorCreatedEvent::SetControl}\label{wxgrideditorcreatedeventsetcontrol}
\membersection{wxGridSizeEvent::MetaDown}\label{wxgridsizeeventmetadown}
\func{void}{SetControl}{\param{wxControl* }{ctrl}}
\func{bool}{MetaDown}{\void}
Sets the edit control.
Returns TRUE if the Meta key was down at the time of the event.
\membersection{wxGridEditorCreatedEvent::SetRow}\label{wxgrideditorcreatedeventsetrow}
\membersection{wxGridSizeEvent::ShiftDown}\label{wxgridsizeeventshiftdown}
\func{void}{SetRow}{\param{int }{row}}
\func{bool}{ShiftDown}{\void}
Sets the row at which the event occurred.
Returns TRUE if the Shift key was down at the time of the event.

88
docs/latex/wx/gridrend.tex
View File

@@ -1,49 +1,3 @@
\section{\class{wxGridCellRenderer}}\label{wxgridcellrenderer}
%suppress the stupid gcc warning about the class having private dtor and
%no friends
This class is responsible for actually drawing the cell
in the grid. You may pass it to the wxGridCellAttr (below) to change the
format of one given cell or to wxGrid::SetDefaultRenderer() to change the
view of all cells. This is an abstract class, and you will normally use one of the
predefined derived classes or derive your own class from it.
\wxheading{Derived from}
wxGridCellWorker
\wxheading{See also}
\helpref{wxGridCellStringRenderer}{wxgridcellstringrenderer},\rtfsp
\helpref{wxGridCellNumberRenderer}{wxgridcellnumberrenderer},\rtfsp
\helpref{wxGridCellFloatRenderer}{wxgridcellfloatrenderer},\rtfsp
\helpref{wxGridCellBoolRenderer}{wxgridcellboolrenderer}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxGridCellRenderer::Draw}\label{wxgridcellrendererdraw}
\func{void}{Draw}{\param{wxGrid\& }{grid}, \param{wxGridCellAttr\& }{attr}, \param{wxDC\& }{dc}, \param{const wxRect\& }{rect}, \param{int }{row}, \param{int }{col}, \param{bool }{isSelected}}
Draw the given cell on the provided DC inside the given rectangle
using the style specified by the attribute and the default or selected
state corresponding to the isSelected value.
This pure virtual function has a default implementation which will
prepare the DC using the given attribute: it will draw the rectangle
with the background colour from attr and set the text colour and font.
\membersection{wxGridCellRenderer::GetBestSize}\label{wxgridcellrenderergetbestsize}
\func{wxSize}{GetBestSize}{\param{wxGrid\& }{grid}, \param{wxGridCellAttr\& }{attr}, \param{wxDC\& }{dc}, \param{int }{row}, \param{int }{col}}
Get the preferred size of the cell for its contents.
\membersection{wxGridCellRenderer::Clone}\label{wxgridcellrendererclone}
\constfunc{wxGridCellRenderer*}{Clone}{\void}
\section{\class{wxGridCellBoolRenderer}}\label{wxgridcellboolrenderer}
This class may be used to format boolean data in a cell.
@@ -151,6 +105,48 @@ This class may be used to format integer data in a cell.
Default constructor
\section{\class{wxGridCellRenderer}}\label{wxgridcellrenderer}
This class is responsible for actually drawing the cell
in the grid. You may pass it to the wxGridCellAttr (below) to change the
format of one given cell or to wxGrid::SetDefaultRenderer() to change the
view of all cells. This is an abstract class, and you will normally use one of the
predefined derived classes or derive your own class from it.
\wxheading{Derived from}
wxGridCellWorker
\wxheading{See also}
\helpref{wxGridCellStringRenderer}{wxgridcellstringrenderer},\rtfsp
\helpref{wxGridCellNumberRenderer}{wxgridcellnumberrenderer},\rtfsp
\helpref{wxGridCellFloatRenderer}{wxgridcellfloatrenderer},\rtfsp
\helpref{wxGridCellBoolRenderer}{wxgridcellboolrenderer}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxGridCellRenderer::Draw}\label{wxgridcellrendererdraw}
\func{void}{Draw}{\param{wxGrid\& }{grid}, \param{wxGridCellAttr\& }{attr}, \param{wxDC\& }{dc}, \param{const wxRect\& }{rect}, \param{int }{row}, \param{int }{col}, \param{bool }{isSelected}}
Draw the given cell on the provided DC inside the given rectangle
using the style specified by the attribute and the default or selected
state corresponding to the isSelected value.
This pure virtual function has a default implementation which will
prepare the DC using the given attribute: it will draw the rectangle
with the background colour from attr and set the text colour and font.
\membersection{wxGridCellRenderer::GetBestSize}\label{wxgridcellrenderergetbestsize}
\func{wxSize}{GetBestSize}{\param{wxGrid\& }{grid}, \param{wxGridCellAttr\& }{attr}, \param{wxDC\& }{dc}, \param{int }{row}, \param{int }{col}}
Get the preferred size of the cell for its contents.
\membersection{wxGridCellRenderer::Clone}\label{wxgridcellrendererclone}
\constfunc{wxGridCellRenderer*}{Clone}{\void}
\section{\class{wxGridCellStringRenderer}}\label{wxgridcellstringrenderer}

54
docs/latex/wx/log.tex
View File

@@ -524,6 +524,33 @@ Suspends logging.
Resumes logging.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% wxLogPassThrough %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxLogPassThrough}}\label{wxlogpassthrough}
A special version of \helpref{wxLogChain}{wxlogchain} which uses itself as the
new log target. Maybe more clearly, it means that this is a log target which
forwards the log messages to the previously installed one in addition to
processing them itself.
Unlike \helpref{wxLogChain}{wxlogchain} which is usually used directly as is,
this class must be derived from to implement \helpref{DoLog}{wxlogdolog}
and/or \helpref{DoLogString}{wxlogdologstring} methods.
\wxheading{Derived from}
\helpref{wxLogChain}{wxlogchain}
\wxheading{Include files}
<wx/log.h>
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxLogPassThrough::wxLogPassThrough}\label{wxlogpassthroughctor}
Default ctor installs this object as the current active log target.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% wxLogStderr %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxLogStderr}}\label{wxlogstderr}
@@ -699,30 +726,3 @@ prevent this from happening.
Called right before the log frame is going to be deleted: will
always be called unlike \helpref{OnFrameClose()}{wxlogwindowonframeclose}.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% wxLogPassThrough %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxLogPassThrough}}\label{wxlogpassthrough}
A special version of \helpref{wxLogChain}{wxlogchain} which uses itself as the
new log target. Maybe more clearly, it means that this is a log target which
forwards the log messages to the previously installed one in addition to
processing them itself.
Unlike \helpref{wxLogChain}{wxlogchain} which is usually used directly as is,
this class must be derived from to implement \helpref{DoLog}{wxlogdolog}
and/or \helpref{DoLogString}{wxlogdologstring} methods.
\wxheading{Derived from}
\helpref{wxLogChain}{wxlogchain}
\wxheading{Include files}
<wx/log.h>
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxLogPassThrough::wxLogPassThrough}\label{wxlogpassthroughctor}
Default ctor installs this object as the current active log target.

118
docs/latex/wx/pagedlg.tex
View File

@@ -1,3 +1,62 @@
\section{\class{wxPageSetupDialog}}\label{wxpagesetupdialog}
This class represents the page setup common dialog. The page setup dialog is standard from
Windows 95 on, replacing the print setup dialog (which is retained in Windows and wxWindows
for backward compatibility). On Windows 95 and NT 4.0 and above, the page setup dialog is
native to the windowing system, otherwise it is emulated.
The page setup dialog contains controls for paper size (A4, A5 etc.), orientation (landscape
or portrait), and controls for setting left, top, right and bottom margin sizes in millimetres.
When the dialog has been closed, you need to query the \helpref{wxPageSetupDialogData}{wxpagesetupdialogdata} object
associated with the dialog.
Note that the OK and Cancel buttons do not destroy the dialog; this must be done by the
application.
\wxheading{Derived from}
\helpref{wxDialog}{wxdialog}\\
\helpref{wxWindow}{wxwindow}\\
\helpref{wxEvtHandler}{wxevthandler}\\
\helpref{wxObject}{wxobject}
\wxheading{Include files}
<wx/printdlg.h>
\wxheading{See also}
\helpref{wxPrintDialog}{wxprintdialog}, \helpref{wxPageSetupDialogData}{wxpagesetupdialogdata}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxPageSetupDialog::wxPageSetupDialog}
\func{}{wxPageSetupDialog}{\param{wxWindow* }{parent}, \param{wxPageSetupDialogData* }{data = NULL}}
Constructor. Pass a parent window, and optionally a pointer to a block of page setup
data, which will be copied to the print dialog's internal data.
\membersection{wxPageSetupDialog::\destruct{wxPageSetupDialog}}
\func{}{\destruct{wxPageSetupDialog}}{\void}
Destructor.
\membersection{wxPageSetupDialog::GetPageSetupData}\label{wxpagesetupdialoggetpagesetupdata}
\func{wxPageSetupDialogData\&}{GetPageSetupData}{\void}
Returns the \helpref{page setup data}{wxpagesetupdialogdata} associated with the dialog.
\membersection{wxPageSetupDialog::ShowModal}\label{wxpagesetupdialogshowmodal}
\func{int}{ShowModal}{\void}
Shows the dialog, returning wxID\_OK if the user pressed OK, and wxID\_CANCEL
otherwise.
\section{\class{wxPageSetupDialogData}}\label{wxpagesetupdialogdata}
This class holds a variety of information related to \helpref{wxPageSetupDialog}{wxpagesetupdialog}.
@@ -230,62 +289,3 @@ Assigns print data to this object.
Assigns page setup data to this object.
\section{\class{wxPageSetupDialog}}\label{wxpagesetupdialog}
This class represents the page setup common dialog. The page setup dialog is standard from
Windows 95 on, replacing the print setup dialog (which is retained in Windows and wxWindows
for backward compatibility). On Windows 95 and NT 4.0 and above, the page setup dialog is
native to the windowing system, otherwise it is emulated.
The page setup dialog contains controls for paper size (A4, A5 etc.), orientation (landscape
or portrait), and controls for setting left, top, right and bottom margin sizes in millimetres.
When the dialog has been closed, you need to query the \helpref{wxPageSetupDialogData}{wxpagesetupdialogdata} object
associated with the dialog.
Note that the OK and Cancel buttons do not destroy the dialog; this must be done by the
application.
\wxheading{Derived from}
\helpref{wxDialog}{wxdialog}\\
\helpref{wxWindow}{wxwindow}\\
\helpref{wxEvtHandler}{wxevthandler}\\
\helpref{wxObject}{wxobject}
\wxheading{Include files}
<wx/printdlg.h>
\wxheading{See also}
\helpref{wxPrintDialog}{wxprintdialog}, \helpref{wxPageSetupDialogData}{wxpagesetupdialogdata}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxPageSetupDialog::wxPageSetupDialog}
\func{}{wxPageSetupDialog}{\param{wxWindow* }{parent}, \param{wxPageSetupDialogData* }{data = NULL}}
Constructor. Pass a parent window, and optionally a pointer to a block of page setup
data, which will be copied to the print dialog's internal data.
\membersection{wxPageSetupDialog::\destruct{wxPageSetupDialog}}
\func{}{\destruct{wxPageSetupDialog}}{\void}
Destructor.
\membersection{wxPageSetupDialog::GetPageSetupData}\label{wxpagesetupdialoggetpagesetupdata}
\func{wxPageSetupDialogData\&}{GetPageSetupData}{\void}
Returns the \helpref{page setup data}{wxpagesetupdialogdata} associated with the dialog.
\membersection{wxPageSetupDialog::ShowModal}\label{wxpagesetupdialogshowmodal}
\func{int}{ShowModal}{\void}
Shows the dialog, returning wxID\_OK if the user pressed OK, and wxID\_CANCEL
otherwise.

133
docs/latex/wx/socket.tex
View File

@@ -1218,136 +1218,3 @@ it possible to use the same event handler for different sockets.
Returns the socket event type.
% ---------------------------------------------------------------------------
% CLASS: wxSocketServer
% ---------------------------------------------------------------------------
\section{\class{wxSocketServer}}\label{wxsocketserver}
\wxheading{Derived from}
\helpref{wxSocketBase}{wxsocketbase}
\wxheading{Include files}
<wx/socket.h>
% ---------------------------------------------------------------------------
% Members
% ---------------------------------------------------------------------------
\latexignore{\rtfignore{\wxheading{Members}}}
%
% wxSocketServer
%
\membersection{wxSocketServer::wxSocketServer}\label{wxsocketserverconstr}
\func{}{wxSocketServer}{\param{wxSockAddress\&}{ address}, \param{wxSocketFlags}{ flags = wxSOCKET\_NONE}}
Constructs a new server and tries to bind to the specified {\it address}.
Before trying to accept new connections, test whether it succeeded with
\helpref{wxSocketBase::Ok}{wxsocketbaseok}.
\wxheading{Parameters}
\docparam{address}{Specifies the local address for the server (e.g. port number).}
\docparam{flags}{Socket flags (See \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags})}
%
% ~wxSocketServer
%
\membersection{wxSocketServer::\destruct{wxSocketServer}}
\func{}{\destruct{wxSocketServer}}{\void}
Destructor (it doesn't close the accepted connections).
%
% Accept
%
\membersection{wxSocketServer::Accept}\label{wxsocketserveraccept}
\func{wxSocketBase *}{Accept}{\param{bool}{ wait = TRUE}}
Accepts an incoming connection request, and creates a new
\helpref{wxSocketBase}{wxsocketbase} object which represents
the server-side of the connection.
If {\it wait} is TRUE and there are no pending connections to be
accepted, it will wait for the next incoming connection to
arrive. {\bf Warning:} This will block the GUI.
If {\it wait} is FALSE, it will try to accept a pending connection
if there is one, but it will always return immediately without blocking
the GUI. If you want to use Accept in this way, you can either check for
incoming connections with \helpref{WaitForAccept}{wxsocketserverwaitforaccept}
or catch {\bf wxSOCKET\_CONNECTION} events, then call Accept once you know
that there is an incoming connection waiting to be accepted.
\wxheading{Return value}
Returns an opened socket connection, or NULL if an error occurred or
if the {\it wait} parameter was FALSE and there were no pending
connections.
\wxheading{See also}
\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept},
\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
\helpref{wxSocketBase::Notify}{wxsocketbasenotify},
\helpref{wxSocketServer::AcceptWith}{wxsocketserveracceptwith}
%
% AcceptWith
%
\membersection{wxSocketServer::AcceptWith}\label{wxsocketserveracceptwith}
\func{bool}{AcceptWith}{\param{wxSocketBase\&}{ socket}, \param{bool}{ wait = TRUE}}
Accept an incoming connection using the specified socket object.
\wxheading{Parameters}
\docparam{socket}{Socket to be initialized}
\wxheading{Return value}
Returns TRUE on success, or FALSE if an error occurred or if the
{\it wait} parameter was FALSE and there were no pending
connections.
\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept},
\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
\helpref{wxSocketBase::Notify}{wxsocketbasenotify},
\helpref{wxSocketServer::Accept}{wxsocketserveraccept}
%
% WaitForAccept
%
\membersection{wxSocketServer::WaitForAccept}\label{wxsocketserverwaitforaccept}
\func{bool}{WaitForAccept}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}}
This function waits for an incoming connection. Use it if you want to call
\helpref{Accept}{wxsocketserveraccept} or \helpref{AcceptWith}{wxsocketserveracceptwith}
with {\it wait} set to FALSE, to detect when an incoming connection is waiting
to be accepted.
\wxheading{Parameters}
\docparam{seconds}{Number of seconds to wait.
If -1, it will wait for the default timeout,
as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.}
\docparam{millisecond}{Number of milliseconds to wait.}
\wxheading{Return value}
Returns TRUE if an incoming connection arrived, FALSE if the timeout elapsed.
\wxheading{See also}
\helpref{wxSocketServer::Accept}{wxsocketserveraccept},
\helpref{wxSocketServer::AcceptWith}{wxsocketserveracceptwith},
\helpref{wxSocketBase::InterruptWait}{wxsocketbaseinterruptwait}

145
docs/latex/wx/socksrv.tex Normal file
View File

@@ -0,0 +1,145 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Name: socket.tex
%% Purpose: wxSocket docs
%% Author: Guillermo Rodriguez Garcia <guille@iies.es>
%% Modified by:
%% Created: 14.01.02 (extracted from socket.tex)
%% RCS-ID: $Id$
%% Copyright: (c) wxWindows team
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% ---------------------------------------------------------------------------
% CLASS: wxSocketServer
% ---------------------------------------------------------------------------
\section{\class{wxSocketServer}}\label{wxsocketserver}
\wxheading{Derived from}
\helpref{wxSocketBase}{wxsocketbase}
\wxheading{Include files}
<wx/socket.h>
% ---------------------------------------------------------------------------
% Members
% ---------------------------------------------------------------------------
\latexignore{\rtfignore{\wxheading{Members}}}
%
% wxSocketServer
%
\membersection{wxSocketServer::wxSocketServer}\label{wxsocketserverconstr}
\func{}{wxSocketServer}{\param{wxSockAddress\&}{ address}, \param{wxSocketFlags}{ flags = wxSOCKET\_NONE}}
Constructs a new server and tries to bind to the specified {\it address}.
Before trying to accept new connections, test whether it succeeded with
\helpref{wxSocketBase::Ok}{wxsocketbaseok}.
\wxheading{Parameters}
\docparam{address}{Specifies the local address for the server (e.g. port number).}
\docparam{flags}{Socket flags (See \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags})}
%
% ~wxSocketServer
%
\membersection{wxSocketServer::\destruct{wxSocketServer}}
\func{}{\destruct{wxSocketServer}}{\void}
Destructor (it doesn't close the accepted connections).
%
% Accept
%
\membersection{wxSocketServer::Accept}\label{wxsocketserveraccept}
\func{wxSocketBase *}{Accept}{\param{bool}{ wait = TRUE}}
Accepts an incoming connection request, and creates a new
\helpref{wxSocketBase}{wxsocketbase} object which represents
the server-side of the connection.
If {\it wait} is TRUE and there are no pending connections to be
accepted, it will wait for the next incoming connection to
arrive. {\bf Warning:} This will block the GUI.
If {\it wait} is FALSE, it will try to accept a pending connection
if there is one, but it will always return immediately without blocking
the GUI. If you want to use Accept in this way, you can either check for
incoming connections with \helpref{WaitForAccept}{wxsocketserverwaitforaccept}
or catch {\bf wxSOCKET\_CONNECTION} events, then call Accept once you know
that there is an incoming connection waiting to be accepted.
\wxheading{Return value}
Returns an opened socket connection, or NULL if an error occurred or
if the {\it wait} parameter was FALSE and there were no pending
connections.
\wxheading{See also}
\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept},
\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
\helpref{wxSocketBase::Notify}{wxsocketbasenotify},
\helpref{wxSocketServer::AcceptWith}{wxsocketserveracceptwith}
%
% AcceptWith
%
\membersection{wxSocketServer::AcceptWith}\label{wxsocketserveracceptwith}
\func{bool}{AcceptWith}{\param{wxSocketBase\&}{ socket}, \param{bool}{ wait = TRUE}}
Accept an incoming connection using the specified socket object.
\wxheading{Parameters}
\docparam{socket}{Socket to be initialized}
\wxheading{Return value}
Returns TRUE on success, or FALSE if an error occurred or if the
{\it wait} parameter was FALSE and there were no pending
connections.
\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept},
\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
\helpref{wxSocketBase::Notify}{wxsocketbasenotify},
\helpref{wxSocketServer::Accept}{wxsocketserveraccept}
%
% WaitForAccept
%
\membersection{wxSocketServer::WaitForAccept}\label{wxsocketserverwaitforaccept}
\func{bool}{WaitForAccept}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}}
This function waits for an incoming connection. Use it if you want to call
\helpref{Accept}{wxsocketserveraccept} or \helpref{AcceptWith}{wxsocketserveracceptwith}
with {\it wait} set to FALSE, to detect when an incoming connection is waiting
to be accepted.
\wxheading{Parameters}
\docparam{seconds}{Number of seconds to wait.
If -1, it will wait for the default timeout,
as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.}
\docparam{millisecond}{Number of milliseconds to wait.}
\wxheading{Return value}
Returns TRUE if an incoming connection arrived, FALSE if the timeout elapsed.
\wxheading{See also}
\helpref{wxSocketServer::Accept}{wxsocketserveraccept},
\helpref{wxSocketServer::AcceptWith}{wxsocketserveracceptwith},
\helpref{wxSocketBase::InterruptWait}{wxsocketbaseinterruptwait}

354
docs/latex/wx/tab.tex
View File

@@ -240,357 +240,3 @@ use wxTabView::SetSelectedTab for that).
Sets the width and height for this tab.
\section{\class{wxTabView}}\label{wxtabview}
Responsible for drawing tabs onto a window, and dealing with input.
Please note that the preferred class for programming tabbed windows is \helpref{wxNotebook}{wxnotebook}.
This class is retained for backward compatibility.
\wxheading{Derived from}
\helpref{wxObject}{wxobject}
\wxheading{Include files}
<wx/tab.h>
\wxheading{See also}
\helpref{wxTabView overview}{wxtabviewoverview}, \helpref{wxPanelTabView}{wxpaneltabview}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxTabView::wxTabView}
\func{}{wxTabView}{\param{long }{style = wxTAB\_STYLE\_DRAW\_BOX \pipe wxTAB\_STYLE\_COLOUR\_INTERIOR}}
Constructor.
{\it style} may be a bit list of the following:
\begin{twocollist}\itemsep=0pt
\twocolitem{wxTAB\_STYLE\_DRAW\_BOX}{Draw a box around the view area. Most commonly used for dialogs.}
\twocolitem{wxTAB\_STYLE\_COLOUR\_INTERIOR}{Draw tab backgrounds in the specified colour. Omitting this style
will ensure that the tab background matches the dialog background.}
\end{twocollist}
\membersection{wxTabView::AddTab}\label{wxtabviewaddtab}
\func{wxTabControl *}{AddTab}{\param{int}{ id}, \param{const wxString\& }{label}, \param{wxTabControl *}{existingTab=NULL}}
Adds a tab to the view.
{\it id} is the application-chosen identifier for the tab, which will be used in subsequent tab operations.
{\it label} is the label to give the tab.
{\it existingTab} maybe NULL to specify a new tab, or non-NULL to indicate that an existing tab should be used.
A new layer (row) is started when the current layer has been filled up with tabs.
\membersection{wxTabView::CalculateTabWidth}\label{wxtabviewcalculatetabwidth}
\func{int}{CalculateTabWidth}{\param{int}{ noTabs}, \param{bool}{ adjustView = FALSE}}
The application can specify the tab width using this function, in terms
of the number of tabs per layer (row) which will fit the view area, which
should have been set previously with SetViewRect.
{\it noTabs} is the number of tabs which should take up the full width
of the view area.
{\it adjustView} can be set to TRUE in order to readjust the view width
to exactly fit the given number of tabs.
The new tab width is returned.
\membersection{wxTabView::ClearTabs}
\func{void}{ClearTabs}{\param{bool }{deleteTabs=TRUE}}
Clears the tabs, deleting them if {\it deleteTabs} is TRUE.
\membersection{wxTabView::Draw}
\func{void}{Draw}{\param{wxDC\& }{dc}}
Draws the tabs and (optionally) a box around the view area.
\membersection{wxTabView::FindTabControlForId}
\func{wxTabControl *}{FindTabControlForId}{\param{int}{ id}}
Finds the wxTabControl corresponding to {\it id}.
\membersection{wxTabView::FindTabControlForPosition}
\func{wxTabControl *}{FindTabControlForPosition}{\param{int}{ layer}, \param{int}{ position}}
Finds the wxTabControl at layer {\it layer}, position in layer {\it position}, both starting from
zero. Note that tabs change layer as they are selected or deselected.
\membersection{wxTabView::GetBackgroundBrush}
\func{wxBrush *}{GetBackgroundBrush}{\void}
Returns the brush used to draw in the background colour. It is set when
SetBackgroundColour is called.
\membersection{wxTabView::GetBackgroundColour}
\func{wxColour}{GetBackgroundColour}{\void}
Returns the colour used for each tab background. By default, this is
light grey. To ensure a match with the dialog or panel background, omit
the wxTAB\_STYLE\_COLOUR\_INTERIOR flag from the wxTabView constructor.
\membersection{wxTabView::GetBackgroundPen}
\func{wxPen *}{GetBackgroundPen}{\void}
Returns the pen used to draw in the background colour. It is set when
SetBackgroundColour is called.
\membersection{wxTabView::GetHighlightColour}
\func{wxColour}{GetHighlightColour}{\void}
Returns the colour used for bright highlights on the left side of `3D' surfaces. By default, this is white.
\membersection{wxTabView::GetHighlightPen}
\func{wxPen *}{GetHighlightPen}{\void}
Returns the pen used to draw 3D effect highlights. This is set when
SetHighlightColour is called.
\membersection{wxTabView::GetHorizontalTabOffset}
\func{int}{GetHorizontalTabOffset}{\void}
Returns the horizontal spacing by which each tab layer is offset from the one below.
\membersection{wxTabView::GetNumberOfLayers}
\func{int}{GetNumberOfLayers}{\void}
Returns the number of layers (rows of tabs).
\membersection{wxTabView::GetSelectedTabFont}
\func{wxFont *}{GetSelectedTabFont}{\void}
Returns the font to be used for the selected tab label.
\membersection{wxTabView::GetShadowColour}
\func{wxColour}{GetShadowColour}{\void}
Returns the colour used for shadows on the right-hand side of `3D' surfaces. By default, this is dark grey.
\membersection{wxTabView::GetTabHeight}
\func{int}{GetTabHeight}{\void}
Returns the tab default height.
\membersection{wxTabView::GetTabFont}
\func{wxFont *}{GetTabFont}{\void}
Returns the tab label font.
\membersection{wxTabView::GetTabSelectionHeight}
\func{int}{GetTabSelectionHeight}{\void}
Returns the height to be used for the currently selected tab; normally a few pixels
higher than the other tabs.
\membersection{wxTabView::GetTabStyle}
\func{long}{GetTabStyle}{\void}
Returns the tab style. See constructor documentation for details of valid styles.
\membersection{wxTabView::GetTabWidth}
\func{int}{GetTabWidth}{\void}
Returns the tab default width.
\membersection{wxTabView::GetTextColour}
\func{wxColour}{GetTextColour}{\void}
Returns the colour used to draw label text. By default, this is
black.
\membersection{wxTabView::GetTopMargin}
\func{int}{GetTopMargin}{\void}
Returns the height between the top of the view area and the bottom of the first
row of tabs.
\membersection{wxTabView::GetShadowPen}
\func{wxPen *}{GetShadowPen}{\void}
Returns the pen used to draw 3D effect shadows. This is set when
SetShadowColour is called.
\membersection{wxTabView::GetViewRect}
\func{wxRectangle}{GetViewRect}{\void}
Returns the rectangle specifying the view area (above which tabs are
placed).
\membersection{wxTabView::GetVerticalTabTextSpacing}
\func{int}{GetVerticalTabTextSpacing}{\void}
Returns the vertical spacing between the top of an unselected tab, and the tab label.
\membersection{wxTabView::GetWindow}
\func{wwxWindow *}{GetWindow}{\void}
Returns the window for the view.
\membersection{wxTabView::OnCreateTabControl}
\func{wxTabControl *}{OnCreateTabControl}{\void}
Creates a new tab control. By default, this returns a wxTabControl object, but the application may wish
to define a derived class, in which case the tab view should be subclassed and this function overridden.
\membersection{wxTabView::LayoutTabs}
\func{void}{LayoutTabs}{\void}
Recalculates the positions of the tabs, and adjusts the layer of the selected tab if necessary.
You may want to call this function if the view width has changed (for example, from an OnSize handler).
\membersection{wxTabView::OnEvent}
\func{bool}{OnEvent}{\param{wxMouseEvent\& }{event}}
Processes mouse events sent from the panel or dialog. Returns TRUE if the event was processed,
FALSE otherwise.
\membersection{wxTabView::OnTabActivate}
\func{void}{OnTabActivate}{\param{int}{ activateId}, \param{int}{ deactivateId}}
Called when a tab is activated, with the new active tab id, and the former active tab id.
\membersection{wxTabView::OnTabPreActivate}
\func{bool}{OnTabPreActivate}{\param{int}{ activateId}, \param{int}{ deactivateId}}
Called just before a tab is activated, with the new active tab id, and the former active tab id.
If the function returns FALSE, the tab is not activated.
\membersection{wxTabView::SetBackgroundColour}
\func{void}{SetBackgroundColour}{\param{const wxColour\&}{ col}}
Sets the colour to be used for each tab background. By default, this is
light grey. To ensure a match with the dialog or panel background, omit
the wxTAB\_STYLE\_COLOUR\_INTERIOR flag from the wxTabView constructor.
\membersection{wxTabView::SetHighlightColour}
\func{void}{SetHighlightColour}{\param{const wxColour\&}{ col}}
Sets the colour to be used for bright highlights on the left side of `3D' surfaces. By default, this is white.
\membersection{wxTabView::SetHorizontalTabOffset}
\func{void}{SetHorizontalTabOffset}{\param{int}{ offset}}
Sets the horizontal spacing by which each tab layer is offset from the one below.
\membersection{wxTabView::SetSelectedTabFont}
\func{void}{SetSelectedTabFont}{\param{wxFont *}{font}}
Sets the font to be used for the selected tab label.
\membersection{wxTabView::SetShadowColour}
\func{void}{SetShadowColour}{\param{const wxColour\&}{ col}}
Sets the colour to be used for shadows on the right-hand side of `3D' surfaces. By default, this is dark grey.
\membersection{wxTabView::SetTabFont}
\func{void}{SetTabFont}{\param{wxFont *}{font}}
Sets the tab label font.
\membersection{wxTabView::SetTabStyle}
\func{void}{SetTabStyle}{\param{long}{ tabStyle}}
Sets the tab style. See constructor documentation for details of valid styles.
\membersection{wxTabView::SetTabSize}
\func{void}{SetTabSize}{\param{int}{ width}, \param{int}{ height}}
Sets the tab default width and height.
\membersection{wxTabView::SetTabSelectionHeight}
\func{void}{SetTabSelectionHeight}{\param{int}{ height}}
Sets the height to be used for the currently selected tab; normally a few pixels
higher than the other tabs.
\membersection{wxTabView::SetTabSelection}
\func{void}{SetTabSelection}{\param{int}{ sel}, \param{bool}{ activateTool=TRUE}}
Sets the selected tab, calling the application's OnTabActivate function.
If {\it activateTool} is FALSE, OnTabActivate will not be called.
\membersection{wxTabView::SetTextColour}
\func{void}{SetTextColour}{\param{const wxColour\&}{ col}}
Sets the colour to be used to draw label text. By default, this is
black.
\membersection{wxTabView::SetTopMargin}
\func{void}{SetTopMargin}{\param{int}{ margin}}
Sets the height between the top of the view area and the bottom of the first
row of tabs.
\membersection{wxTabView::SetVerticalTabTextSpacing}
\func{void}{SetVerticalTabTextSpacing}{\param{int}{ spacing}}
Sets the vertical spacing between the top of an unselected tab, and the tab label.
\membersection{wxTabView::SetViewRect}\label{wxtabviewsetviewrect}
\func{void}{SetViewRect}{\param{const wxRectangle\& }{rect}}
Sets the rectangle specifying the view area (above which tabs are
placed). This must be set by the application.
\membersection{wxTabView::SetWindow}
\func{void}{SetWindow}{\param{wxWindow *}{window}}
Set the window that the tab view will use for drawing onto.

355
docs/latex/wx/tabview.tex Normal file
View File

@@ -0,0 +1,355 @@
\section{\class{wxTabView}}\label{wxtabview}
Responsible for drawing tabs onto a window, and dealing with input.
Please note that the preferred class for programming tabbed windows is \helpref{wxNotebook}{wxnotebook}.
This class is retained for backward compatibility.
\wxheading{Derived from}
\helpref{wxObject}{wxobject}
\wxheading{Include files}
<wx/tab.h>
\wxheading{See also}
\helpref{wxTabView overview}{wxtabviewoverview}, \helpref{wxPanelTabView}{wxpaneltabview}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxTabView::wxTabView}
\func{}{wxTabView}{\param{long }{style = wxTAB\_STYLE\_DRAW\_BOX \pipe wxTAB\_STYLE\_COLOUR\_INTERIOR}}
Constructor.
{\it style} may be a bit list of the following:
\begin{twocollist}\itemsep=0pt
\twocolitem{wxTAB\_STYLE\_DRAW\_BOX}{Draw a box around the view area. Most commonly used for dialogs.}
\twocolitem{wxTAB\_STYLE\_COLOUR\_INTERIOR}{Draw tab backgrounds in the specified colour. Omitting this style
will ensure that the tab background matches the dialog background.}
\end{twocollist}
\membersection{wxTabView::AddTab}\label{wxtabviewaddtab}
\func{wxTabControl *}{AddTab}{\param{int}{ id}, \param{const wxString\& }{label}, \param{wxTabControl *}{existingTab=NULL}}
Adds a tab to the view.
{\it id} is the application-chosen identifier for the tab, which will be used in subsequent tab operations.
{\it label} is the label to give the tab.
{\it existingTab} maybe NULL to specify a new tab, or non-NULL to indicate that an existing tab should be used.
A new layer (row) is started when the current layer has been filled up with tabs.
\membersection{wxTabView::CalculateTabWidth}\label{wxtabviewcalculatetabwidth}
\func{int}{CalculateTabWidth}{\param{int}{ noTabs}, \param{bool}{ adjustView = FALSE}}
The application can specify the tab width using this function, in terms
of the number of tabs per layer (row) which will fit the view area, which
should have been set previously with SetViewRect.
{\it noTabs} is the number of tabs which should take up the full width
of the view area.
{\it adjustView} can be set to TRUE in order to readjust the view width
to exactly fit the given number of tabs.
The new tab width is returned.
\membersection{wxTabView::ClearTabs}
\func{void}{ClearTabs}{\param{bool }{deleteTabs=TRUE}}
Clears the tabs, deleting them if {\it deleteTabs} is TRUE.
\membersection{wxTabView::Draw}
\func{void}{Draw}{\param{wxDC\& }{dc}}
Draws the tabs and (optionally) a box around the view area.
\membersection{wxTabView::FindTabControlForId}
\func{wxTabControl *}{FindTabControlForId}{\param{int}{ id}}
Finds the wxTabControl corresponding to {\it id}.
\membersection{wxTabView::FindTabControlForPosition}
\func{wxTabControl *}{FindTabControlForPosition}{\param{int}{ layer}, \param{int}{ position}}
Finds the wxTabControl at layer {\it layer}, position in layer {\it position}, both starting from
zero. Note that tabs change layer as they are selected or deselected.
\membersection{wxTabView::GetBackgroundBrush}
\func{wxBrush *}{GetBackgroundBrush}{\void}
Returns the brush used to draw in the background colour. It is set when
SetBackgroundColour is called.
\membersection{wxTabView::GetBackgroundColour}
\func{wxColour}{GetBackgroundColour}{\void}
Returns the colour used for each tab background. By default, this is
light grey. To ensure a match with the dialog or panel background, omit
the wxTAB\_STYLE\_COLOUR\_INTERIOR flag from the wxTabView constructor.
\membersection{wxTabView::GetBackgroundPen}
\func{wxPen *}{GetBackgroundPen}{\void}
Returns the pen used to draw in the background colour. It is set when
SetBackgroundColour is called.
\membersection{wxTabView::GetHighlightColour}
\func{wxColour}{GetHighlightColour}{\void}
Returns the colour used for bright highlights on the left side of `3D' surfaces. By default, this is white.
\membersection{wxTabView::GetHighlightPen}
\func{wxPen *}{GetHighlightPen}{\void}
Returns the pen used to draw 3D effect highlights. This is set when
SetHighlightColour is called.
\membersection{wxTabView::GetHorizontalTabOffset}
\func{int}{GetHorizontalTabOffset}{\void}
Returns the horizontal spacing by which each tab layer is offset from the one below.
\membersection{wxTabView::GetNumberOfLayers}
\func{int}{GetNumberOfLayers}{\void}
Returns the number of layers (rows of tabs).
\membersection{wxTabView::GetSelectedTabFont}
\func{wxFont *}{GetSelectedTabFont}{\void}
Returns the font to be used for the selected tab label.
\membersection{wxTabView::GetShadowColour}
\func{wxColour}{GetShadowColour}{\void}
Returns the colour used for shadows on the right-hand side of `3D' surfaces. By default, this is dark grey.
\membersection{wxTabView::GetTabHeight}
\func{int}{GetTabHeight}{\void}
Returns the tab default height.
\membersection{wxTabView::GetTabFont}
\func{wxFont *}{GetTabFont}{\void}
Returns the tab label font.
\membersection{wxTabView::GetTabSelectionHeight}
\func{int}{GetTabSelectionHeight}{\void}
Returns the height to be used for the currently selected tab; normally a few pixels
higher than the other tabs.
\membersection{wxTabView::GetTabStyle}
\func{long}{GetTabStyle}{\void}
Returns the tab style. See constructor documentation for details of valid styles.
\membersection{wxTabView::GetTabWidth}
\func{int}{GetTabWidth}{\void}
Returns the tab default width.
\membersection{wxTabView::GetTextColour}
\func{wxColour}{GetTextColour}{\void}
Returns the colour used to draw label text. By default, this is
black.
\membersection{wxTabView::GetTopMargin}
\func{int}{GetTopMargin}{\void}
Returns the height between the top of the view area and the bottom of the first
row of tabs.
\membersection{wxTabView::GetShadowPen}
\func{wxPen *}{GetShadowPen}{\void}
Returns the pen used to draw 3D effect shadows. This is set when
SetShadowColour is called.
\membersection{wxTabView::GetViewRect}
\func{wxRectangle}{GetViewRect}{\void}
Returns the rectangle specifying the view area (above which tabs are
placed).
\membersection{wxTabView::GetVerticalTabTextSpacing}
\func{int}{GetVerticalTabTextSpacing}{\void}
Returns the vertical spacing between the top of an unselected tab, and the tab label.
\membersection{wxTabView::GetWindow}
\func{wwxWindow *}{GetWindow}{\void}
Returns the window for the view.
\membersection{wxTabView::OnCreateTabControl}
\func{wxTabControl *}{OnCreateTabControl}{\void}
Creates a new tab control. By default, this returns a wxTabControl object, but the application may wish
to define a derived class, in which case the tab view should be subclassed and this function overridden.
\membersection{wxTabView::LayoutTabs}
\func{void}{LayoutTabs}{\void}
Recalculates the positions of the tabs, and adjusts the layer of the selected tab if necessary.
You may want to call this function if the view width has changed (for example, from an OnSize handler).
\membersection{wxTabView::OnEvent}
\func{bool}{OnEvent}{\param{wxMouseEvent\& }{event}}
Processes mouse events sent from the panel or dialog. Returns TRUE if the event was processed,
FALSE otherwise.
\membersection{wxTabView::OnTabActivate}
\func{void}{OnTabActivate}{\param{int}{ activateId}, \param{int}{ deactivateId}}
Called when a tab is activated, with the new active tab id, and the former active tab id.
\membersection{wxTabView::OnTabPreActivate}
\func{bool}{OnTabPreActivate}{\param{int}{ activateId}, \param{int}{ deactivateId}}
Called just before a tab is activated, with the new active tab id, and the former active tab id.
If the function returns FALSE, the tab is not activated.
\membersection{wxTabView::SetBackgroundColour}
\func{void}{SetBackgroundColour}{\param{const wxColour\&}{ col}}
Sets the colour to be used for each tab background. By default, this is
light grey. To ensure a match with the dialog or panel background, omit
the wxTAB\_STYLE\_COLOUR\_INTERIOR flag from the wxTabView constructor.
\membersection{wxTabView::SetHighlightColour}
\func{void}{SetHighlightColour}{\param{const wxColour\&}{ col}}
Sets the colour to be used for bright highlights on the left side of `3D' surfaces. By default, this is white.
\membersection{wxTabView::SetHorizontalTabOffset}
\func{void}{SetHorizontalTabOffset}{\param{int}{ offset}}
Sets the horizontal spacing by which each tab layer is offset from the one below.
\membersection{wxTabView::SetSelectedTabFont}
\func{void}{SetSelectedTabFont}{\param{wxFont *}{font}}
Sets the font to be used for the selected tab label.
\membersection{wxTabView::SetShadowColour}
\func{void}{SetShadowColour}{\param{const wxColour\&}{ col}}
Sets the colour to be used for shadows on the right-hand side of `3D' surfaces. By default, this is dark grey.
\membersection{wxTabView::SetTabFont}
\func{void}{SetTabFont}{\param{wxFont *}{font}}
Sets the tab label font.
\membersection{wxTabView::SetTabStyle}
\func{void}{SetTabStyle}{\param{long}{ tabStyle}}
Sets the tab style. See constructor documentation for details of valid styles.
\membersection{wxTabView::SetTabSize}
\func{void}{SetTabSize}{\param{int}{ width}, \param{int}{ height}}
Sets the tab default width and height.
\membersection{wxTabView::SetTabSelectionHeight}
\func{void}{SetTabSelectionHeight}{\param{int}{ height}}
Sets the height to be used for the currently selected tab; normally a few pixels
higher than the other tabs.
\membersection{wxTabView::SetTabSelection}
\func{void}{SetTabSelection}{\param{int}{ sel}, \param{bool}{ activateTool=TRUE}}
Sets the selected tab, calling the application's OnTabActivate function.
If {\it activateTool} is FALSE, OnTabActivate will not be called.
\membersection{wxTabView::SetTextColour}
\func{void}{SetTextColour}{\param{const wxColour\&}{ col}}
Sets the colour to be used to draw label text. By default, this is
black.
\membersection{wxTabView::SetTopMargin}
\func{void}{SetTopMargin}{\param{int}{ margin}}
Sets the height between the top of the view area and the bottom of the first
row of tabs.
\membersection{wxTabView::SetVerticalTabTextSpacing}
\func{void}{SetVerticalTabTextSpacing}{\param{int}{ spacing}}
Sets the vertical spacing between the top of an unselected tab, and the tab label.
\membersection{wxTabView::SetViewRect}\label{wxtabviewsetviewrect}
\func{void}{SetViewRect}{\param{const wxRectangle\& }{rect}}
Sets the rectangle specifying the view area (above which tabs are
placed). This must be set by the application.
\membersection{wxTabView::SetWindow}
\func{void}{SetWindow}{\param{wxWindow *}{window}}
Set the window that the tab view will use for drawing onto.

72
docs/latex/wx/treectrl.tex
View File

@@ -826,75 +826,3 @@ This function either behaves the same as \helpref{Unselect}{wxtreectrlunselect}
if the control doesn't have wxTR\_MULTIPLE style, or removes the selection from
all items if it does have this style.
\section{\class{wxTreeItemData}}\label{wxtreeitemdata}
wxTreeItemData is some (arbitrary) user class associated with some item. The
main advantage of having this class (compared to the old untyped interface) is
that wxTreeItemData's are destroyed automatically by the tree and, as this
class has virtual dtor, it means that the memory will be automatically
freed. We don't just use wxObject instead of wxTreeItemData because
the size of this class is critical: in any real application, each tree leaf
will have wxTreeItemData associated with it and number of leaves may be
quite big.
Because the objects of this class are deleted by the tree, they should
always be allocated on the heap.
\wxheading{Derived from}
wxTreeItemId
\wxheading{Include files}
<wx/treectrl.h>
\wxheading{See also}
\helpref{wxTreeCtrl}{wxtreectrl}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxTreeItemData::wxTreeItemData}\label{wxtreeitemdataconstr}
\func{}{wxTreeItemData}{\void}
Default constructor.
\pythonnote{The wxPython version of this constructor optionally
accepts any Python object as a parameter. This object is then
associated with the tree item using the wxTreeItemData as a
container.
In addition, the following methods are added in wxPython for accessing
the object:
\indented{2cm}{\begin{twocollist}\itemsep=0pt
\twocolitem{{\bf GetData()}}{Returns a reference to the Python Object}
\twocolitem{{\bf SetData(obj)}}{Associates a new Python Object with the
wxTreeItemData}
\end{twocollist}}
}
\perlnote{In wxPerl the constructor accepts as parameter an optional scalar,
and stores it as client data. You may retrieve this data by calling
{\bf GetData()}, and set it by callling {\bf SetData( data ).}
}
\membersection{wxTreeItemData::\destruct{wxTreeItemData}}
\func{void}{\destruct{wxTreeItemData}}{\void}
Virtual destructor.
\membersection{wxTreeItemData::GetId}\label{wxtreeitemdatagetid}
\func{const wxTreeItem\&}{GetId}{\void}
Returns the item associated with this node.
\membersection{wxTreeItemData::SetId}\label{wxtreeitemdatasetid}
\func{void}{SetId}{\param{const wxTreeItemId\&}{ id}}
Sets the item associated with this node.

73
docs/latex/wx/treedata.tex Normal file
View File

@@ -0,0 +1,73 @@
\section{\class{wxTreeItemData}}\label{wxtreeitemdata}
wxTreeItemData is some (arbitrary) user class associated with some item. The
main advantage of having this class (compared to the old untyped interface) is
that wxTreeItemData's are destroyed automatically by the tree and, as this
class has virtual dtor, it means that the memory will be automatically
freed. We don't just use wxObject instead of wxTreeItemData because
the size of this class is critical: in any real application, each tree leaf
will have wxTreeItemData associated with it and number of leaves may be
quite big.
Because the objects of this class are deleted by the tree, they should
always be allocated on the heap.
\wxheading{Derived from}
wxTreeItemId
\wxheading{Include files}
<wx/treectrl.h>
\wxheading{See also}
\helpref{wxTreeCtrl}{wxtreectrl}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxTreeItemData::wxTreeItemData}\label{wxtreeitemdataconstr}
\func{}{wxTreeItemData}{\void}
Default constructor.
\pythonnote{The wxPython version of this constructor optionally
accepts any Python object as a parameter. This object is then
associated with the tree item using the wxTreeItemData as a
container.
In addition, the following methods are added in wxPython for accessing
the object:
\indented{2cm}{\begin{twocollist}\itemsep=0pt
\twocolitem{{\bf GetData()}}{Returns a reference to the Python Object}
\twocolitem{{\bf SetData(obj)}}{Associates a new Python Object with the
wxTreeItemData}
\end{twocollist}}
}
\perlnote{In wxPerl the constructor accepts as parameter an optional scalar,
and stores it as client data. You may retrieve this data by calling
{\bf GetData()}, and set it by callling {\bf SetData( data ).}
}
\membersection{wxTreeItemData::\destruct{wxTreeItemData}}
\func{void}{\destruct{wxTreeItemData}}{\void}
Virtual destructor.
\membersection{wxTreeItemData::GetId}\label{wxtreeitemdatagetid}
\func{const wxTreeItem\&}{GetId}{\void}
Returns the item associated with this node.
\membersection{wxTreeItemData::SetId}\label{wxtreeitemdatasetid}
\func{void}{SetId}{\param{const wxTreeItemId\&}{ id}}
Sets the item associated with this node.