\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxAcceleratorEntry::wxAcceleratorEntry}\label{wxacceleratorentryconstr}
+\membersection{wxAcceleratorEntry::wxAcceleratorEntry}\label{wxacceleratorentryctor}
\func{}{wxAcceleratorEntry}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxAcceleratorTable::wxAcceleratorTable}\label{wxacceleratortableconstr}
+\membersection{wxAcceleratorTable::wxAcceleratorTable}\label{wxacceleratortablector}
\func{}{wxAcceleratorTable}{\void}
Wx::AcceleratorEntry objects or references to 3-element arrays
( flags, keyCode, cmd ), like the parameters of Wx::AcceleratorEntry::new.}
-\membersection{wxAcceleratorTable::\destruct{wxAcceleratorTable}}
+\membersection{wxAcceleratorTable::\destruct{wxAcceleratorTable}}\label{wxacceleratortabledtor}
\func{}{\destruct{wxAcceleratorTable}}{\void}
Returns true if the accelerator table is valid.
-\membersection{wxAcceleratorTable::operator $=$}
+\membersection{wxAcceleratorTable::operator $=$}\label{wxacceleratortableassign}
\func{wxAcceleratorTable\& }{operator $=$}{\param{const wxAcceleratorTable\& }{accel}}
Returns reference to this object.
-\membersection{wxAcceleratorTable::operator $==$}
+\membersection{wxAcceleratorTable::operator $==$}\label{wxacceleratortableequal}
\func{bool}{operator $==$}{\param{const wxAcceleratorTable\& }{accel}}
Returns true if the accelerator tables were effectively equal, false otherwise.
-\membersection{wxAcceleratorTable::operator $!=$}
+\membersection{wxAcceleratorTable::operator $!=$}\label{wxacceleratortablenotequal}
\func{bool}{operator $!=$}{\param{const wxAcceleratorTable\& }{accel}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxActivateEvent::wxActivateEvent}
+\membersection{wxActivateEvent::wxActivateEvent}\label{wxactivateeventctor}
\func{}{wxActivateEvent}{\param{WXTYPE }{eventType = 0}, \param{bool}{ active = true}, \param{int }{id = 0}}
Constructor.
-\membersection{wxActivateEvent::m\_active}
+\membersection{wxActivateEvent::m\_active}\label{wxactivateeventmactive}
\member{bool}{m\_active}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxApp::wxApp}
+\membersection{wxApp::wxApp}\label{wxappctor}
\func{void}{wxApp}{\void}
Constructor. Called implicitly with a definition of a wxApp object.
-\membersection{wxApp::\destruct{wxApp}}
+\membersection{wxApp::\destruct{wxApp}}\label{wxappdtor}
\func{void}{\destruct{wxApp}}{\void}
\helpref{OnInitCmdLine}{wxapponinitcmdline}
-\membersection{wxApp::OnExceptionInMainLoop}{wxapponexceptioninmainloop}
+\membersection{wxApp::OnExceptionInMainLoop}\label{wxapponexceptioninmainloop}
\func{virtual bool}{OnExceptionInMainLoop}{\void}
\latexignore{\rtfignore{\wxheading{Function groups}}}
-\membersection{Macros for template array definition}
+\membersection{Macros for template array definition}\label{arraymacros}
To use an array you must first define the array class. This is done with the
help of the macros in this section. The class of array elements must be (at
WX_DEFINE_ARRAY_PTR(double *, MyArrayOfDoublePointers);
\end{verbatim}
-\membersection{Constructors and destructors}
+\membersection{Constructors and destructors}\label{arrayconstructorsdestructors}
Array classes are 100\% C++ objects and as such they have the appropriate copy
constructors and assignment operators. Copying wxArray just copies the elements
\helpref{Alloc}{wxarrayalloc}\\
\helpref{Shrink}{wxarrayshrink}
-\membersection{Number of elements and simple item access}
+\membersection{Number of elements and simple item access}\label{arrayelementsaccess}
Functions in this section return the total number of array elements and allow to
retrieve them - possibly using just the C array indexing $[]$ operator which
\helpref{Item}{wxarrayitem}\\
\helpref{Last}{wxarraylast}
-\membersection{Adding items}
+\membersection{Adding items}\label{arrayadding}
\helpref{Add}{wxarrayadd}\\
\helpref{Insert}{wxarrayinsert}\\
\helpref{SetCount}{wxarraysetcount}\\
\helpref{WX\_APPEND\_ARRAY}{wxappendarray}
-\membersection{Removing items}
+\membersection{Removing items}\label{arrayremoving}
\helpref{WX\_CLEAR\_ARRAY}{wxcleararray}\\
\helpref{Empty}{wxarrayempty}\\
\helpref{RemoveAt}{wxarrayremoveat}\\
\helpref{Remove}{wxarrayremove}
-\membersection{Searching and sorting}
+\membersection{Searching and sorting}\label{arraysearchingandsorting}
\helpref{Index}{wxarrayindex}\\
\helpref{Sort}{wxarraysort}
possible as of wxWidgets 2.3.3, the set of wxArtProvider bitmaps is too
small).
-\membersection{Identifying art resources}
+\membersection{Identifying art resources}\label{artprovideridentifying}
Every bitmap is known to wxArtProvider under an unique ID that is used by when
requesting a resource from it. The ID is represented by wxArtID type and can
icons, so wxArtProvider may return {\tt wxNullBitmap} or {\tt wxNullIcon}.
Default theme is typically installed in {\tt /usr/share/icons/hicolor}.
-\membersection{Clients}
+\membersection{Clients}\label{artproviderclients}
Client is the entity that calls wxArtProvider's GetBitmap or GetIcon
function. It is represented by wxClientID type and can have one of these
Same as \helpref{wxArtProvider::GetBitmap}{wxartprovidergetbitmap}, but
return a wxIcon object (or wxNullIcon on failure).
-\membersection{wxArtProvider::PopProvider}\label{wxartproviderpopprovider}
+\membersection{wxArtProvider::PopProvider}\label{wxartproviderctor}
\func{static bool}{PopProvider}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxBitmapButton::wxBitmapButton}\label{wxbitmapbuttonconstr}
+\membersection{wxBitmapButton::wxBitmapButton}\label{wxbitmapbuttonctor}
\func{}{wxBitmapButton}{\void}
\helpref{wxBitmapButton::Create}{wxbitmapbuttoncreate}, \helpref{wxValidator}{wxvalidator}
-\membersection{wxBitmapButton::\destruct{wxBitmapButton}}
+\membersection{wxBitmapButton::\destruct{wxBitmapButton}}\label{wxbitmapbuttondtor}
\func{}{\destruct{wxBitmapButton}}{\void}
\param{const wxPoint\& }{pos}, \param{const wxSize\& }{size = wxDefaultSize},\rtfsp
\param{long}{ style = 0}, \param{const wxValidator\& }{validator}, \param{const wxString\& }{name = ``button"}}
-Button creation function for two-step creation. For more details, see \helpref{wxBitmapButton::wxBitmapButton}{wxbitmapbuttonconstr}.
+Button creation function for two-step creation. For more details, see \helpref{wxBitmapButton::wxBitmapButton}{wxbitmapbuttonctor}.
\membersection{wxBitmapButton::GetBitmapDisabled}\label{wxbitmapbuttongetbitmapdisabled}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxBitmap::wxBitmap}\label{wxbitmapconstr}
+\membersection{wxBitmap::wxBitmap}\label{wxbitmapctor}
\func{}{wxBitmap}{\void}
\end{itemize}
}
-\membersection{wxBitmap::\destruct{wxBitmap}}
+\membersection{wxBitmap::\destruct{wxBitmap}}\label{wxbitmapdtor}
\func{}{\destruct{wxBitmap}}{\void}
\helpref{wxBitmapHandler}{wxbitmaphandler}
-\membersection{wxBitmap::CleanUpHandlers}
+\membersection{wxBitmap::CleanUpHandlers}\label{wxbitmapcleanuphandlers}
\func{static void}{CleanUpHandlers}{\void}
\docparam{data}{Data whose type depends on the value of {\it type}.}
-\docparam{type}{A bitmap type identifier - see \helpref{wxBitmap::wxBitmap}{wxbitmapconstr} for a list
+\docparam{type}{A bitmap type identifier - see \helpref{wxBitmap::wxBitmap}{wxbitmapctor} for a list
of possible values.}
\wxheading{Return value}
\wxheading{See also}
-\helpref{wxBitmap::wxBitmap}{wxbitmapconstr}
+\helpref{wxBitmap::wxBitmap}{wxbitmapctor}
-\membersection{wxBitmap::FindHandler}
+\membersection{wxBitmap::FindHandler}\label{wxbitmapfindhandler}
\func{static wxBitmapHandler*}{FindHandler}{\param{const wxString\& }{name}}
\helpref{wxBitmapHandler}{wxbitmaphandler}
-\membersection{wxBitmap::GetDepth}
+\membersection{wxBitmap::GetDepth}\label{wxbitmapgetdepth}
\constfunc{int}{GetDepth}{\void}
Gets the colour depth of the bitmap. A value of 1 indicates a
monochrome bitmap.
-\membersection{wxBitmap::GetHandlers}
+\membersection{wxBitmap::GetHandlers}\label{wxbitmapgethandlers}
\func{static wxList\&}{GetHandlers}{\void}
Returns a sub bitmap of the current one as long as the rect belongs entirely to
the bitmap. This function preserves bit depth and mask information.
-\membersection{wxBitmap::InitStandardHandlers}
+\membersection{wxBitmap::InitStandardHandlers}\label{wxbitmapinitstandardhandlers}
\func{static void}{InitStandardHandlers}{\void}
\helpref{wxBitmapHandler}{wxbitmaphandler}
-\membersection{wxBitmap::InsertHandler}
+\membersection{wxBitmap::InsertHandler}\label{wxbitmapinserthandler}
\func{static void}{InsertHandler}{\param{wxBitmapHandler*}{ handler}}
Returns true if bitmap data is present.
-\membersection{wxBitmap::RemoveHandler}
+\membersection{wxBitmap::RemoveHandler}\label{wxbitmapremovehandler}
\func{static bool}{RemoveHandler}{\param{const wxString\& }{name}}
\helpref{wxBitmap::GetMask}{wxbitmapgetmask}, \helpref{wxMask}{wxmask}
%% VZ: this function is an implementation detail and shouldn't be documented
-%%\membersection{wxBitmap::SetOk}
+%%\membersection{wxBitmap::SetOk}\label{wxbitmapsetok}
%%
%%\func{void}{SetOk}{\param{int }{isOk}}
%%
\helpref{wxPalette}{wxpalette}
-\membersection{wxBitmap::SetWidth}
+\membersection{wxBitmap::SetWidth}\label{wxbitmapsetwidth}
\func{void}{SetWidth}{\param{int }{width}}
\docparam{width}{Bitmap width in pixels.}
-\membersection{wxBitmap::operator $=$}
+\membersection{wxBitmap::operator $=$}\label{wxbitmapassign}
\func{wxBitmap\& }{operator $=$}{\param{const wxBitmap\& }{bitmap}}
Returns 'this' object.
-\membersection{wxBitmap::operator $==$}
+\membersection{wxBitmap::operator $==$}\label{wxbitmapequal}
\func{bool}{operator $==$}{\param{const wxBitmap\& }{bitmap}}
Returns true if the bitmaps were effectively equal, false otherwise.
-\membersection{wxBitmap::operator $!=$}
+\membersection{wxBitmap::operator $!=$}\label{wxbitmapnotequal}
\func{bool}{operator $!=$}{\param{const wxBitmap\& }{bitmap}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxBitmapHandler::wxBitmapHandler}\label{wxbitmaphandlerconstr}
+\membersection{wxBitmapHandler::wxBitmapHandler}\label{wxbitmaphandlerctor}
\func{}{wxBitmapHandler}{\void}
Default constructor. In your own default constructor, initialise the members
m\_name, m\_extension and m\_type.
-\membersection{wxBitmapHandler::\destruct{wxBitmapHandler}}
+\membersection{wxBitmapHandler::\destruct{wxBitmapHandler}}\label{wxbitmaphandlerdtor}
\func{}{\destruct{wxBitmapHandler}}{\void}
Destroys the wxBitmapHandler object.
-\membersection{wxBitmapHandler::Create}
+\membersection{wxBitmapHandler::Create}\label{wxbitmaphandlercreate}
\func{virtual bool}{Create}{\param{wxBitmap* }{bitmap}, \param{void*}{ data}, \param{int}{ type}, \param{int}{ width}, \param{int}{ height}, \param{int}{ depth = -1}}
\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
+\docparam{type}{A bitmap type identifier - see \helpref{wxBitmapHandler::wxBitmapHandler}{wxbitmapctor} for a list
of possible values.}
\wxheading{Return value}
true if the call succeeded, false otherwise (the default).
-\membersection{wxBitmapHandler::GetName}
+\membersection{wxBitmapHandler::GetName}\label{wxbitmaphandlergetname}
\constfunc{wxString}{GetName}{\void}
Gets the name of this handler.
-\membersection{wxBitmapHandler::GetExtension}
+\membersection{wxBitmapHandler::GetExtension}\label{wxbitmaphandlergetextension}
\constfunc{wxString}{GetExtension}{\void}
Gets the file extension associated with this handler.
-\membersection{wxBitmapHandler::GetType}
+\membersection{wxBitmapHandler::GetType}\label{wxbitmaphandlergettype}
\constfunc{long}{GetType}{\void}
\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.}
+\docparam{type}{See \helpref{wxBitmap::wxBitmap}{wxbitmapctor} for values this can take.}
\wxheading{Return value}
\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{type}{See \helpref{wxBitmap::wxBitmap}{wxbitmapctor} for values this can take.}
\docparam{palette}{An optional palette used for saving the bitmap.}
\helpref{wxBitmap::SaveFile}{wxbitmapsavefile}\\
\helpref{wxBitmapHandler::LoadFile}{wxbitmaphandlerloadfile}
-\membersection{wxBitmapHandler::SetName}
+\membersection{wxBitmapHandler::SetName}\label{wxbitmaphandlersetname}
\func{void}{SetName}{\param{const wxString\& }{name}}
\docparam{name}{Handler name.}
-\membersection{wxBitmapHandler::SetExtension}
+\membersection{wxBitmapHandler::SetExtension}\label{wxbitmaphandlersetextension}
\func{void}{SetExtension}{\param{const wxString\& }{extension}}
\docparam{extension}{Handler extension.}
-\membersection{wxBitmapHandler::SetType}
+\membersection{wxBitmapHandler::SetType}\label{wxbitmaphandlersettype}
\func{void}{SetType}{\param{long }{type}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxBrush::wxBrush}
+\membersection{wxBrush::wxBrush}\label{wxbrushctor}
\func{}{wxBrush}{\void}
\helpref{wxBrushList}{wxbrushlist}, \helpref{wxColour}{wxcolour}, \helpref{wxColourDatabase}{wxcolourdatabase}
-\membersection{wxBrush::\destruct{wxBrush}}
+\membersection{wxBrush::\destruct{wxBrush}}\label{wxbrushdtor}
\func{void}{\destruct{wxBrush}}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxBusyCursor::wxBusyCursor}
+\membersection{wxBusyCursor::wxBusyCursor}\label{wxbusycursorctor}
\func{}{wxBusyCursor}{\param{wxCursor*}{ cursor = wxHOURGLASS\_CURSOR}}
Constructs a busy cursor object, calling \helpref{wxBeginBusyCursor}{wxbeginbusycursor}.
-\membersection{wxBusyCursor::\destruct{wxBusyCursor}}
+\membersection{wxBusyCursor::\destruct{wxBusyCursor}}\label{wxbusycursordtor}
\func{}{\destruct{wxBusyCursor}}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxBusyInfo::wxBusyInfo}
+\membersection{wxBusyInfo::wxBusyInfo}\label{wxbusyinfoctor}
\func{}{wxBusyInfo}{\param{const wxString\&}{ msg}, \param{wxParent }{*parent = NULL}}
{\bf NB:} If {\it parent} is not {\tt NULL} you must ensure that it is not
closed while the busy info is shown.
-\membersection{wxBusyInfo::\destruct{wxBusyInfo}}
+\membersection{wxBusyInfo::\destruct{wxBusyInfo}}\label{wxbusyinfodtor}
\func{}{\destruct{wxBusyInfo}}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxButton::wxButton}\label{wxbuttonconstr}
+\membersection{wxButton::wxButton}\label{wxbuttonctor}
\func{}{wxButton}{\void}
\helpref{wxButton::Create}{wxbuttoncreate}, \helpref{wxValidator}{wxvalidator}
-\membersection{wxButton::\destruct{wxButton}}
+\membersection{wxButton::\destruct{wxButton}}\label{wxbuttondtor}
\func{}{\destruct{wxButton}}{\void}
\param{long}{ style = 0}, \param{const wxValidator\& }{validator}, \param{const wxString\& }{name = ``button"}}
Button creation function for two-step creation. For more details, see
-\helpref{wxButton::wxButton}{wxbuttonconstr}.
+\helpref{wxButton::wxButton}{wxbuttonctor}.
\membersection{wxButton::GetLabel}\label{wxbuttongetlabel}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxCalculateLayoutEvent::wxCalculateLayoutEvent}
+\membersection{wxCalculateLayoutEvent::wxCalculateLayoutEvent}\label{wxcalculatelayouteventctor}
\func{}{wxCalculateLayoutEvent}{\param{wxWindowID }{id = 0}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxCalendarEvent::GetDate}{wxcalendareventgetdate}
+\membersection{wxCalendarEvent::GetDate}\label{wxcalendareventgetdate}
\constfunc{const wxDateTime\&}{GetDate}{\void}
Returns the date. This function may be called for all event types except
{\tt EVT\_CALENDAR\_WEEKDAY\_CLICKED} one for which it doesn't make sense.
-\membersection{wxCalendarEvent::GetWeekDay}{wxcalendareventgetweekday}
+\membersection{wxCalendarEvent::GetWeekDay}\label{wxcalendareventgetweekday}
\constfunc{wxDateTime::WeekDay}{GetWeekDay}{\void}
{\tt EVT\_CALENDAR\_WEEKDAY\_CLICKED} handler. It doesn't make sense to call
this function in other handlers.
-\membersection{wxCalendarEvent::SetDate}{wxcalendareventsetdate}
+\membersection{wxCalendarEvent::SetDate}\label{wxcalendareventsetdate}
\func{void}{SetDate}{\param{const wxDateTime\&}{ date}}
Sets the date.
-\membersection{wxCalendarEvent::SetWeekDay}{wxcalendareventsetweekday}
+\membersection{wxCalendarEvent::SetWeekDay}\label{wxcalendareventsetweekday}
\func{void}{SetWeekDay}{\param{wxDateTime::WeekDay}{ day}}
\twocolwidtha{6cm}
\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxClient}{wxddeclient}}{Represents a client}
-\twocolitem{\helpref{wxConnection}{wxddeconnection}}{Represents the connection between a client and a server}
-\twocolitem{\helpref{wxServer}{wxddeserver}}{Represents a server}
+\twocolitem{\helpref{wxClient}{wxclient}, \helpref{wxDDEClient}{wxddeclient}}{Represents a client}
+\twocolitem{\helpref{wxConnection}{wxconnection}, \helpref{wxDDEConnection}{wxddeconnection}}{Represents the connection between a client and a server}
+\twocolitem{\helpref{wxServer}{wxserver}, \helpref{wxDDEServer}{wxddeserver}}{Represents a server}
%\twocolitem{\helpref{wxSocketHandler}{wxsockethandler}}{Represents a socket handler}
\end{twocollist}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxCheckBox::wxCheckBox}\label{wxcheckboxconstr}
+\membersection{wxCheckBox::wxCheckBox}\label{wxcheckboxctor}
\func{}{wxCheckBox}{\void}
\helpref{wxCheckBox::Create}{wxcheckboxcreate}, \helpref{wxValidator}{wxvalidator}
-\membersection{wxCheckBox::\destruct{wxCheckBox}}
+\membersection{wxCheckBox::\destruct{wxCheckBox}}\label{wxcheckboxdtor}
\func{}{\destruct{wxCheckBox}}{\void}
\param{const wxSize\& }{size = wxDefaultSize}, \param{long}{ style = 0},\rtfsp
\param{const wxValidator\& }{val}, \param{const wxString\& }{name = ``checkBox"}}
-Creates the checkbox for two-step construction. See \helpref{wxCheckBox::wxCheckBox}{wxcheckboxconstr}\rtfsp
+Creates the checkbox for two-step construction. See \helpref{wxCheckBox::wxCheckBox}{wxcheckboxctor}\rtfsp
for details.
\membersection{wxCheckBox::GetValue}\label{wxcheckboxgetvalue}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxCheckListBox::wxCheckListBox}\label{wxchecklistboxconstr}
+\membersection{wxCheckListBox::wxCheckListBox}\label{wxchecklistboxctor}
\func{}{wxCheckListBox}{\void}
\perlnote{In wxPerl there is just an array reference in place of {\tt n}
and {\tt choices}.}
-\membersection{wxCheckListBox::\destruct{wxCheckListBox}}
+\membersection{wxCheckListBox::\destruct{wxCheckListBox}}\label{wxchecklistboxdtor}
\func{void}{\destruct{wxCheckListBox}}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxChoice::wxChoice}\label{wxchoiceconstr}
+\membersection{wxChoice::wxChoice}\label{wxchoicector}
\func{}{wxChoice}{\void}
\perlnote{In wxPerl there is just an array reference in place of {\tt n}
and {\tt choices}.}
-\membersection{wxChoice::\destruct{wxChoice}}
+\membersection{wxChoice::\destruct{wxChoice}}\label{wxchoicedtor}
\func{}{\destruct{wxChoice}}{\void}
\param{const wxArrayString\& }{choices},\rtfsp
\param{long}{ style = 0}, \param{const wxString\& }{name = ``choice"}}
-Creates the choice for two-step construction. See \helpref{wxChoice::wxChoice}{wxchoiceconstr}.
+Creates the choice for two-step construction. See \helpref{wxChoice::wxChoice}{wxchoicector}.
\membersection{wxChoice::Delete}\label{wxchoicedelete}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxClassInfo::wxClassInfo}\label{wxclassinfoconstr}
+\membersection{wxClassInfo::wxClassInfo}\label{wxclassinfoctor}
\func{}{wxClassInfo}{\param{wxChar * }{className}, \param{wxChar * }{baseClass1}, \param{wxChar * }{baseClass2},
\param{int}{ size}, \param{wxObjectConstructorFn }{fn}}
Creates an object of the appropriate kind. Returns NULL if the class has not been declared
dynamically creatable (typically, it is an abstract class).
-\membersection{wxClassInfo::FindClass}
+\membersection{wxClassInfo::FindClass}\label{wxclassinfofindclass}
\func{static wxClassInfo *}{FindClass}{\param{wxChar * }{name}}
Finds the wxClassInfo object for a class of the given string name.
-\membersection{wxClassInfo::GetBaseClassName1}
+\membersection{wxClassInfo::GetBaseClassName1}\label{wxclassinfogetbaseclassname1}
\constfunc{wxChar *}{GetBaseClassName1}{\void}
Returns the name of the first base class (NULL if none).
-\membersection{wxClassInfo::GetBaseClassName2}
+\membersection{wxClassInfo::GetBaseClassName2}\label{wxclassinfogetbaseclassname2}
\constfunc{wxChar *}{GetBaseClassName2}{\void}
Returns the name of the second base class (NULL if none).
-\membersection{wxClassInfo::GetClassName}
+\membersection{wxClassInfo::GetClassName}\label{wxclassinfogetclassname}
\constfunc{wxChar *}{GetClassName}{\void}
Returns the string form of the class name.
-\membersection{wxClassInfo::GetSize}
+\membersection{wxClassInfo::GetSize}\label{wxclassinfogetsize}
\constfunc{int}{GetSize}{\void}
Returns the size of the class.
-\membersection{wxClassInfo::InitializeClasses}
+\membersection{wxClassInfo::InitializeClasses}\label{wxclassinfoinitializeclasses}
\func{static void}{InitializeClasses}{\void}
\input datespan.tex
\input datetime.tex
\input db.tex
+\input ddeclint.tex
+\input ddeconn.tex
+\input ddeservr.tex
\input debugcxt.tex
\input delgrend.tex
\input dc.tex
\input tabctrl.tex
\input tabevent.tex
\input taskbar.tex
+\input tcpclint.tex
+\input tcpconn.tex
+\input tcpservr.tex
\input tempfile.tex
\input text.tex
\input txtdatob.tex
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxClientDC::wxClientDC}
+\membersection{wxClientDC::wxClientDC}\label{wxclientdcctor}
\func{}{wxClientDC}{\param{wxWindow*}{ window}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxClipboard::wxClipboard}
+\membersection{wxClipboard::wxClipboard}\label{wxclipboardctor}
\func{}{wxClipboard}{\void}
Constructor.
-\membersection{wxClipboard::\destruct{wxClipboard}}
+\membersection{wxClipboard::\destruct{wxClipboard}}\label{wxclipboarddtor}
\func{}{\destruct{wxClipboard}}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxCloseEvent::wxCloseEvent}
+\membersection{wxCloseEvent::wxCloseEvent}\label{wxcloseeventctor}
\func{}{wxCloseEvent}{\param{WXTYPE}{ commandEventType = 0}, \param{int}{ id = 0}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxCommandEvent::m\_clientData}
+\membersection{wxCommandEvent::m\_clientData}\label{wxcommandeventmclientdata}
\member{void*}{m\_clientData}
Contains a pointer to client data for listboxes and choices, if the event
was a selection. Beware, this is not implemented anyway...
-\membersection{wxCommandEvent::m\_commandInt}
+\membersection{wxCommandEvent::m\_commandInt}\label{wxcommandeventmcommandint}
\member{int}{m\_commandInt}
radiobox selection (only if the event was a selection, not a
deselection), or a boolean value representing the value of a checkbox.
-\membersection{wxCommandEvent::m\_commandString}
+\membersection{wxCommandEvent::m\_commandString}\label{wxcommandeventmcommandstring}
\member{wxString}{m\_commandString}
Contains a string corresponding to a listbox or choice selection.
-\membersection{wxCommandEvent::m\_extraLong}
+\membersection{wxCommandEvent::m\_extraLong}\label{wxcommandeventmextralong}
\member{long}{m\_extraLong}
multiple-selection boxes, and in this case the index and string values
are indeterminate and the listbox must be examined by the application.
-\membersection{wxCommandEvent::wxCommandEvent}
+\membersection{wxCommandEvent::wxCommandEvent}\label{wxcommandeventctor}
\func{}{wxCommandEvent}{\param{WXTYPE}{ commandEventType = 0}, \param{int}{ id = 0}}
Constructor.
-\membersection{wxCommandEvent::Checked}
+\membersection{wxCommandEvent::Checked}\label{wxcommandeventchecked}
\constfunc{bool}{Checked}{\void}
Deprecated, use \helpref{IsChecked}{wxcommandeventischecked} instead.
-\membersection{wxCommandEvent::GetClientData}
+\membersection{wxCommandEvent::GetClientData}\label{wxcommandeventgetclientdata}
\func{void*}{GetClientData}{\void}
Returns client data pointer for a listbox or choice selection event
(not valid for a deselection).
-\membersection{wxCommandEvent::GetClientObject}
+\membersection{wxCommandEvent::GetClientObject}\label{wxcommandeventgetclientobject}
\func{wxClientData *}{GetClientObject}{\void}
Returns client object pointer for a listbox or choice selection event
(not valid for a deselection).
-\membersection{wxCommandEvent::GetExtraLong}
+\membersection{wxCommandEvent::GetExtraLong}\label{wxcommandeventgetextralong}
\func{long}{GetExtraLong}{\void}
Returns the {\bf m\_extraLong} member.
-\membersection{wxCommandEvent::GetInt}
+\membersection{wxCommandEvent::GetInt}\label{wxcommandeventgetint}
\func{int}{GetInt}{\void}
Returns the {\bf m\_commandInt} member.
-\membersection{wxCommandEvent::GetSelection}
+\membersection{wxCommandEvent::GetSelection}\label{wxcommandeventgetselection}
\func{int}{GetSelection}{\void}
Returns item index for a listbox or choice selection event (not valid for
a deselection).
-\membersection{wxCommandEvent::GetString}
+\membersection{wxCommandEvent::GetString}\label{wxcommandeventgetstring}
\func{wxString}{GetString}{\void}
just has become checked or unchecked (and thus only makes sense for checkable
menu items).
-\membersection{wxCommandEvent::IsSelection}
+\membersection{wxCommandEvent::IsSelection}\label{wxcommandeventisselection}
\func{bool}{IsSelection}{\void}
For a listbox or similar event, returns true if it is a selection, false if it
is a deselection.
-\membersection{wxCommandEvent::SetClientData}
+\membersection{wxCommandEvent::SetClientData}\label{wxcommandeventsetclientdata}
\func{void}{SetClientData}{\param{void*}{ clientData}}
Sets the client data for this event.
-\membersection{wxCommandEvent::SetClientObject}
+\membersection{wxCommandEvent::SetClientObject}\label{wxcommandeventsetclientobject}
\func{void}{SetClientObject}{\param{wxClientData*}{ clientObject}}
The client object must be owned and deleted by another object (e.g. a control)
that has longer life time than the event object.
-\membersection{wxCommandEvent::SetExtraLong}
+\membersection{wxCommandEvent::SetExtraLong}\label{wxcommandeventsetextralong}
\func{void}{SetExtraLong}{\param{int}{ extraLong}}
Sets the {\bf m\_extraLong} member.
-\membersection{wxCommandEvent::SetInt}
+\membersection{wxCommandEvent::SetInt}\label{wxcommandeventsetint}
\func{void}{SetInt}{\param{int}{ intCommand}}
Sets the {\bf m\_commandInt} member.
-\membersection{wxCommandEvent::SetString}
+\membersection{wxCommandEvent::SetString}\label{wxcommandeventsetstring}
\func{void}{SetString}{\param{const wxString\&}{ string}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxCommandProcessor::wxCommandProcessor}
+\membersection{wxCommandProcessor::wxCommandProcessor}\label{wxcommandprocessorctor}
\func{}{wxCommandProcessor}{\param{int}{ maxCommands = $-1$}}
commands stored to it, otherwise (and by default) the list of commands can grow
arbitrarily.
-\membersection{wxCommandProcessor::\destruct{wxCommandProcessor}}
+\membersection{wxCommandProcessor::\destruct{wxCommandProcessor}}\label{wxcommandprocessordtor}
\func{}{\destruct{wxCommandProcessor}}{\void}
Destructor.
-\membersection{wxCommandProcessor::CanUndo}
+\membersection{wxCommandProcessor::CanUndo}\label{wxcommandprocessorcanundo}
\func{virtual bool}{CanUndo}{\void}
Returns true if the currently-active command can be undone, false otherwise.
-\membersection{wxCommandProcessor::ClearCommands}
+\membersection{wxCommandProcessor::ClearCommands}\label{wxcommandprocessorclearcommands}
\func{virtual void}{ClearCommands}{\void}
Deletes all the commands in the list and sets the current command pointer to NULL.
-\membersection{wxCommandProcessor::Redo}
+\membersection{wxCommandProcessor::Redo}\label{wxcommandprocessorredo}
\func{virtual bool}{Redo}{\void}
Executes (redoes) the current command (the command that has just been undone if any).
-\membersection{wxCommandProcessor::GetCommands}
+\membersection{wxCommandProcessor::GetCommands}\label{wxcommandprocessorgetcommands}
\constfunc{wxList\&}{GetCommands}{\void}
Returns the list of commands.
-\membersection{wxCommandProcessor::GetMaxCommands}
+\membersection{wxCommandProcessor::GetMaxCommands}\label{wxcommandprocessorgetmaxcommands}
\constfunc{int}{GetMaxCommands}{\void}
Returns the maximum number of commands that the command processor stores.
-\membersection{wxCommandProcessor::GetEditMenu}
+\membersection{wxCommandProcessor::GetEditMenu}\label{wxcommandprocessorgeteditmenu}
\constfunc{wxMenu*}{GetEditMenu}{\void}
Returns the string that will be shown for the undo menu item.
-\membersection{wxCommandProcessor::Initialize}
+\membersection{wxCommandProcessor::Initialize}\label{wxcommandprocessorinitialize}
\func{virtual void}{Initialize}{\void}
last in the list (if any), and updating the edit menu (if one has been
specified).
-\membersection{wxCommandProcessor::SetEditMenu}
+\membersection{wxCommandProcessor::SetEditMenu}\label{wxcommandprocessorseteditmenu}
\func{void}{SetEditMenu}{\param{wxMenu* }{menu}}
destroyed and command operations may still be performed, or the command
processor may try to access an invalid pointer.
-\membersection{wxCommandProcessor::SetMenuStrings}
+\membersection{wxCommandProcessor::SetMenuStrings}\label{wxcommandprocessorsetmenustrings}
\func{void}{SetMenuStrings}{\void}
Sets the string that will be appended to the Undo menu item.
-\membersection{wxCommandProcessor::Submit}
+\membersection{wxCommandProcessor::Submit}\label{wxcommandprocessorsubmit}
\func{virtual bool}{Submit}{\param{wxCommand *}{command}, \param{bool}{ storeIt = true}}
{\it storeIt} indicates whether the successful command should be stored
in the history list.
-\membersection{wxCommandProcessor::Undo}
+\membersection{wxCommandProcessor::Undo}\label{wxcommandprocessorundo}
\func{virtual bool}{Undo}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxColourDialog::wxColourDialog}\label{wxcolourdialogwxcolourdialog}
+\membersection{wxColourDialog::wxColourDialog}\label{wxcolourdialogctor}
\func{}{wxColourDialog}{\param{wxWindow* }{parent}, \param{wxColourData* }{data = NULL}}
\helpref{wxColourData}{wxcolourdata}
-\membersection{wxColourDialog::\destruct{wxColourDialog}}
+\membersection{wxColourDialog::\destruct{wxColourDialog}}\label{wxcolourdialogdtor}
\func{}{\destruct{wxColourDialog}}{\void}
Destructor.
-\membersection{wxColourDialog::Create}
+\membersection{wxColourDialog::Create}\label{wxcolourdialogcreate}
\func{bool}{Create}{\param{wxWindow* }{parent}, \param{wxColourData* }{data = NULL}}
-Same as \helpref{constructor}{wxcolourdialogwxcolourdialog}.
+Same as \helpref{constructor}{wxcolourdialogctor}.
-\membersection{wxColourDialog::GetColourData}
+\membersection{wxColourDialog::GetColourData}\label{wxcolourdialoggetcolourdata}
\func{wxColourData\&}{GetColourData}{\void}
Returns the \helpref{colour data}{wxcolourdata} associated with the colour dialog.
-\membersection{wxColourDialog::ShowModal}
+\membersection{wxColourDialog::ShowModal}\label{wxcolourdialogshowmodal}
\func{int}{ShowModal}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxColourData::wxColourData}\label{wxcolourdataconstr}
+\membersection{wxColourData::wxColourData}\label{wxcolourdatactor}
\func{}{wxColourData}{\void}
to black, and the {\it choose full} setting to true.
-\membersection{wxColourData::\destruct{wxColourData}}
+\membersection{wxColourData::\destruct{wxColourData}}\label{wxcolourdatadtor}
\func{}{\destruct{wxColourData}}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxComboBox::wxComboBox}\label{wxcomboboxconstr}
+\membersection{wxComboBox::wxComboBox}\label{wxcomboboxctor}
\func{}{wxComboBox}{\void}
\perlnote{In wxPerl there is just an array reference in place of {\tt n}
and {\tt choices}.}
-\membersection{wxComboBox::\destruct{wxComboBox}}
+\membersection{wxComboBox::\destruct{wxComboBox}}\label{wxcomboboxdtor}
\func{}{\destruct{wxComboBox}}{\void}
\param{long}{ style = 0}, \param{const wxValidator\& }{validator = wxDefaultValidator}, \param{const wxString\& }{name = ``comboBox"}}
Creates the combobox for two-step construction. Derived classes
-should call or replace this function. See \helpref{wxComboBox::wxComboBox}{wxcomboboxconstr}\rtfsp
+should call or replace this function. See \helpref{wxComboBox::wxComboBox}{wxcomboboxctor}\rtfsp
for further details.
\membersection{wxComboBox::Copy}\label{wxcomboboxcopy}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxCommand::wxCommand}
+\membersection{wxCommand::wxCommand}\label{wxcommandctor}
\func{}{wxCommand}{\param{bool}{ canUndo = false}, \param{const wxString\& }{name = NULL}}
{\it name} must be supplied for the command processor to display the command name
in the application's edit menu.
-\membersection{wxCommand::\destruct{wxCommand}}
+\membersection{wxCommand::\destruct{wxCommand}}\label{wxcommanddtor}
\func{}{\destruct{wxCommand}}{\void}
Destructor.
-\membersection{wxCommand::CanUndo}
+\membersection{wxCommand::CanUndo}\label{wxcommandcanundo}
\func{bool}{CanUndo}{\void}
Returns true if the command can be undone, false otherwise.
-\membersection{wxCommand::Do}
+\membersection{wxCommand::Do}\label{wxcommanddo}
\func{bool}{Do}{\void}
Returning false will indicate to the command processor that the action is
not undoable and should not be added to the command history.
-\membersection{wxCommand::GetName}
+\membersection{wxCommand::GetName}\label{wxcommandgetname}
\func{wxString}{GetName}{\void}
Returns the command name.
-\membersection{wxCommand::Undo}
+\membersection{wxCommand::Undo}\label{wxcommandundo}
\func{bool}{Undo}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxCondition::wxCondition}\label{wxconditionconstr}
+\membersection{wxCondition::wxCondition}\label{wxconditionctor}
\func{}{wxCondition}{\param{wxMutex\& }{mutex}}
Use \helpref{IsOk}{wxconditionisok} to check if the object was successfully
intiialized.
-\membersection{wxCondition::\destruct{wxCondition}}
+\membersection{wxCondition::\destruct{wxCondition}}\label{wxconditiondtor}
\func{}{\destruct{wxCondition}}{\void}
\helpref{DontCreateOnDemand}{wxconfigbasedontcreateondemand}
-\membersection{Constructor and destructor}
+\membersection{Constructor and destructor}\label{congigconstructordestructor}
\helpref{wxConfigBase}{wxconfigbasector}\\
\helpref{\destruct{wxConfigBase}}{wxconfigbasedtor}
-\membersection{Path management}
+\membersection{Path management}\label{configpathmanagement}
As explained in \helpref{config overview}{wxconfigoverview}, the config classes
support a file system-like hierarchy of keys (files) and groups (directories).
\helpref{GetPath}{wxconfigbasegetpath}
-\membersection{Enumeration}
+\membersection{Enumeration}\label{configenumeration}
The functions in this section allow to enumerate all entries and groups in the
config file. All functions here return false when there are no more items.
\helpref{GetNumberOfGroups}{wxconfigbasegetnumberofgroups}
-\membersection{Tests of existence}
+\membersection{Tests of existence}\label{configtestsofexistence}
\helpref{HasGroup}{wxconfigbasehasgroup}\\
\helpref{HasEntry}{wxconfigbasehasentry}\\
\helpref{GetEntryType}{wxconfigbasegetentrytype}
-\membersection{Miscellaneous functions}
+\membersection{Miscellaneous functions}\label{configmiscellaneous}
\helpref{GetAppName}{wxconfigbasegetappname}\\
\helpref{GetVendorName}{wxconfigbasegetvendorname}\\
\helpref{SetUmask}{wxfileconfigsetumask}
-\membersection{Key access}
+\membersection{Key access}\label{configkeyaccess}
These function are the core of wxConfigBase class: they allow you to read and
write config file data. All {\it Read} function take a default value which
\helpref{Flush}{wxconfigbaseflush}
-\membersection{Rename entries/groups}
+\membersection{Rename entries/groups}\label{configrenaming}
The functions in this section allow to rename entries or subgroups of the
current group. They will return false on error. typically because either the
\helpref{RenameGroup}{wxconfigbaserenamegroup}
-\membersection{Delete entries/groups}
+\membersection{Delete entries/groups}\label{configdeleting}
The functions in this section delete entries and/or groups of entries from the
config file. {\it DeleteAll()} is especially useful if you want to erase all
\helpref{DeleteAll}{wxconfigbasedeleteall}
-\membersection{Options}
+\membersection{Options}\label{configoptions}
Some aspects of wxConfigBase behaviour can be changed during run-time. The
first of them is the expansion of environment variables in the string values
% -----------
% ctor & dtor
% -----------
-\membersection{wxCountingOutputStream::wxCountingOutputStream}
+\membersection{wxCountingOutputStream::wxCountingOutputStream}\label{wxcountingoutputstreamctor}
\func{}{wxCountingOutputStream}{\void}
Creates a wxCountingOutputStream object.
-\membersection{wxCountingOutputStream::\destruct{wxCountingOutputStream}}
+\membersection{wxCountingOutputStream::\destruct{wxCountingOutputStream}}\label{wxcountingoutputstreamdtor}
\func{}{\destruct{wxCountingOutputStream}}{\void}
Destructor.
-\membersection{wxCountingOutputStream::GetSize}
+\membersection{wxCountingOutputStream::GetSize}\label{wxcountingoutputstreamgetsize}
\constfunc{size\_t}{GetSize}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxContextHelp::wxContextHelp}
+\membersection{wxContextHelp::wxContextHelp}\label{wxcontexthelpctor}
\func{}{wxContextHelp}{\param{wxWindow*}{ window = NULL}, \param{bool}{ doNow = true}}
If {\it window} is NULL, the top window is used.
-\membersection{wxContextHelp::\destruct{wxContextHelp}}
+\membersection{wxContextHelp::\destruct{wxContextHelp}}\label{wxcontexthelpdtor}
\func{}{\destruct{wxContextHelp}}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxDataOutputStream::wxDataOutputStream}\label{wxdataoutputstreamconstr}
+\membersection{wxDataOutputStream::wxDataOutputStream}\label{wxdataoutputstreamctor}
\func{}{wxDataOutputStream}{\param{wxOutputStream\&}{ stream}}
{\it conv} before you destroy this wxDataOutputStream instance! It is
recommended to use default value (UTF-8).}
-\membersection{wxDataOutputStream::\destruct{wxDataOutputStream}}
+\membersection{wxDataOutputStream::\destruct{wxDataOutputStream}}\label{wxdataoutputstreamdtor}
\func{}{\destruct{wxDataOutputStream}}{\void}
Destroys the wxDataOutputStream object.
-\membersection{wxDataOutputStream::BigEndianOrdered}
+\membersection{wxDataOutputStream::BigEndianOrdered}\label{wxdataoutputstreambigendianorder}
\func{void}{BigEndianOrdered}{\param{bool}{ be\_order}}
always use big-endian order), otherwise data will be written in
little-endian order.
-\membersection{wxDataOutputStream::Write8}
+\membersection{wxDataOutputStream::Write8}\label{wxdataoutputstreamwrite8}
\func{void}{Write8}{{\param wxUint8 }{i8}}
Writes an array of bytes to the stream. The amount of bytes to write is
specified with the {\it size} variable.
-\membersection{wxDataOutputStream::Write16}
+\membersection{wxDataOutputStream::Write16}\label{wxdataoutputstreamwrite16}
\func{void}{Write16}{{\param wxUint16 }{i16}}
Writes an array of 16 bit unsigned integer to the stream. The amount of
16 bit unsigned integer to write is specified with the {\it size} variable.
-\membersection{wxDataOutputStream::Write32}
+\membersection{wxDataOutputStream::Write32}\label{wxdataoutputstreamwrite32}
\func{void}{Write32}{{\param wxUint32 }{i32}}
Writes an array of 32 bit unsigned integer to the stream. The amount of
32 bit unsigned integer to write is specified with the {\it size} variable.
-\membersection{wxDataOutputStream::Write64}
+\membersection{wxDataOutputStream::Write64}\label{wxdataoutputstreamwrite64}
\func{void}{Write64}{{\param wxUint64 }{i64}}
Writes an array of 64 bit unsigned integer to the stream. The amount of
64 bit unsigned integer to write is specified with the {\it size} variable.
-\membersection{wxDataOutputStream::WriteDouble}
+\membersection{wxDataOutputStream::WriteDouble}\label{wxdataoutputstreamwritedouble}
\func{void}{WriteDouble}{{\param double }{f}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxDDEClient::wxDDEClient}
+\membersection{wxDDEClient::wxDDEClient}\label{wxddeclientctor}
\func{}{wxDDEClient}{\void}
The advantage of deriving your own connection class is that it will
enable you to intercept messages initiated by the server, such
-as \helpref{wxDDEConnection::OnAdvise}{wxddeconnectiononadvise}. You may also want to
+as \helpref{wxDDEConnection::OnAdvise}{wxconnectiononadvise}. You may also want to
store application-specific data in instances of the new class.
-\membersection{wxDDEClient::ValidHost}
+\membersection{wxDDEClient::ValidHost}\label{wxddeclientvalidhost}
\func{bool}{ValidHost}{\param{const wxString\& }{host}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxDDEConnection::wxDDEConnection}
+\membersection{wxDDEConnection::wxDDEConnection}\label{wxddeconnectionctor}
\func{}{wxDDEConnection}{\void}
a buffer and size of the buffer for the connection object to use in
transactions.
-\membersection{wxDDEConnection::Advise}
+\membersection{wxDDEConnection::Advise}\label{wxddeconnectionadvise}
\func{bool}{Advise}{\param{const wxString\& }{item}, \param{char* }{data}, \param{int}{ size = -1}, \param{wxIPCFormat}{ format = wxCF\_TEXT}}
connection's \helpref{wxDDEConnection::OnAdvise}{wxddeconnectiononadvise}
member to be called. Returns true if successful.
-\membersection{wxDDEConnection::Execute}
+\membersection{wxDDEConnection::Execute}\label{wxddeconnectionexecute}
\func{bool}{Execute}{\param{char* }{data}, \param{int}{ size = -1}, \param{wxIPCFormat}{ format = wxCF\_TEXT}}
server connection's \helpref{wxDDEConnection::OnExecute}{wxddeconnectiononexecute} member to be
called. Returns true if successful.
-\membersection{wxDDEConnection::Disconnect}
+\membersection{wxDDEConnection::Disconnect}\label{wxddeconnectiondisconnect}
\func{bool}{Disconnect}{\void}
\helponly{\insertatlevel{2}{\wxheading{Members}}}
-\membersection{wxFileConfig::wxFileConfig}{wxfileconfigctorstream}
+\membersection{wxFileConfig::wxFileConfig}\label{wxfileconfigctor}
\func{}{wxFileConfig}{\param{wxInputStream\& }{is}, \param{wxMBConv\& }{conv = wxConvUTF8}}
\helpref{Save}{wxfileconfigsave}
-\membersection{wxFileConfig::Save}{wxfileconfigsave}
+\membersection{wxFileConfig::Save}\label{wxfileconfigsave}
\func{bool}{Save}{\param{wxOutputStream\& }{os}, \param{wxMBConv\& }{conv = wxConvUTF8}}
A wxImage cannot (currently) be drawn directly to a \helpref{wxDC}{wxdc}. Instead,
a platform-specific \helpref{wxBitmap}{wxbitmap} object must be created from it using
-the \helpref{wxBitmap::wxBitmap(wxImage,int depth)}{wxbitmapconstr} constructor.
+the \helpref{wxBitmap::wxBitmap(wxImage,int depth)}{wxbitmapctor} constructor.
This bitmap can then
be drawn in a device context, using \helpref{wxDC::DrawBitmap}{wxdcdrawbitmap}.
\constfunc{wxBitmap}{ConvertToBitmap}{\void}
-Deprecated, use equivalent \helpref{wxBitmap constructor}{wxbitmapconstr}
+Deprecated, use equivalent \helpref{wxBitmap constructor}{wxbitmapctor}
(which takes wxImage and depth as its arguments) instead.
\membersection{wxImage::ConvertToMono}\label{wxbitmapconverttomono}
-\section{\class{wxClient}}\label{wxddeclient}
+\section{\class{wxClient}}\label{wxclient}
A wxClient object represents the client part of a client-server
DDE-like (Dynamic Data Exchange) conversation. The actual
wxClient. The custom wxConnection class will intercept
communications in a `conversation' with a server, and the custom
wxClient is required so that a user-overridden
-\helpref{wxClient::OnMakeConnection}{wxddeclientonmakeconnection}
+\helpref{wxClient::OnMakeConnection}{wxclientonmakeconnection}
member can return a wxConnection of the required class, when a
connection is made. Look at the IPC sample and the
\helpref{Interprocess communications overview}{ipcoverview} for
\wxheading{See also}
-\helpref{wxServer}{wxddeserver},
-\helpref{wxConnection}{wxddeconnection}, \helpref{Interprocess communications overview}{ipcoverview}
+\helpref{wxServer}{wxserver},
+\helpref{wxConnection}{wxconnection}, \helpref{Interprocess communications overview}{ipcoverview}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxClient::wxClient}
+\membersection{wxClient::wxClient}\label{wxclientctor}
\func{}{wxClient}{\void}
Constructs a client object.
-\membersection{wxClient::MakeConnection}\label{wxddeclientmakeconnection}
+\membersection{wxClient::MakeConnection}\label{wxclientmakeconnection}
\func{wxConnectionBase *}{MakeConnection}{\param{const wxString\& }{host}, \param{const wxString\& }{service}, \param{const wxString\& }{topic}}
server allows a connection, a wxConnection object will be
returned. The type of wxConnection returned can be altered by
overriding the
-\helpref{wxClient::OnMakeConnection}{wxddeclientonmakeconnection}
+\helpref{wxClient::OnMakeConnection}{wxclientonmakeconnection}
member to return your own derived connection object.
Under Unix, the service name may be either an integer port
insecure for IPC as there is absolutely no access control for
them, use Unix domain sockets whenever possible!
-\membersection{wxClient::OnMakeConnection}\label{wxddeclientonmakeconnection}
+\membersection{wxClient::OnMakeConnection}\label{wxclientonmakeconnection}
\func{wxConnectionBase *}{OnMakeConnection}{\void}
-Called by \helpref{wxClient::MakeConnection}{wxddeclientmakeconnection}, by
+Called by \helpref{wxClient::MakeConnection}{wxclientmakeconnection}, by
default this simply returns a new wxConnection object. Override
this method to return a wxConnection descendant customised for the
application.
The advantage of deriving your own connection class is that it
will enable you to intercept messages initiated by the server,
-such as \helpref{wxConnection::OnAdvise}{wxddeconnectiononadvise}. You
+such as \helpref{wxConnection::OnAdvise}{wxconnectiononadvise}. You
may also want to store application-specific data in instances of
the new class.
-\membersection{wxClient::ValidHost}
+\membersection{wxClient::ValidHost}\label{wxclientvalidhost}
\func{bool}{ValidHost}{\param{const wxString\& }{host}}
-\section{\class{wxConnection}}\label{wxddeconnection}
+\section{\class{wxConnection}}\label{wxconnection}
A wxConnection object represents the connection between a client
and a server. It is created by making a connection using a\rtfsp
-\helpref{wxClient}{wxddeclient} object, or by the acceptance of a
-connection by a\rtfsp \helpref{wxServer}{wxddeserver} object. The
+\helpref{wxClient}{wxclient} object, or by the acceptance of a
+connection by a\rtfsp \helpref{wxServer}{wxserver} object. The
bulk of a DDE-like (Dynamic Data Exchange) conversation is
controlled by calling members in a {\bf wxConnection} object or
by overriding its members. The actual DDE-based implementation
\wxheading{See also}
-\helpref{wxClient}{wxddeclient}, \helpref{wxServer}{wxddeserver},
+\helpref{wxClient}{wxclient}, \helpref{wxServer}{wxserver},
\helpref{Interprocess communications overview}{ipcoverview}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxConnection::wxConnection}
+\membersection{wxConnection::wxConnection}\label{wxconnectionctor}
\func{}{wxConnection}{\void}
object will be provided on requesting (or accepting) a
connection. However, if the user defines his or her own derived
connection object, the \helpref{wxServer::OnAcceptConnection}{wxserveronacceptconnection}\rtfsp
-and/or \helpref{wxClient::OnMakeConnection}{wxddeclientonmakeconnection}
+and/or \helpref{wxClient::OnMakeConnection}{wxclientonmakeconnection}
members should be replaced by functions which construct the new
connection object.
not large enough. The programmer-supplied buffer is included
mainly for backwards compatibility.
-\membersection{wxConnection::Advise}\label{wxddeconnectionadvise}
+\membersection{wxConnection::Advise}\label{wxconnectionadvise}
\func{bool}{Advise}{\param{const wxString\& }{item}, \param{char* }{data}, \param{int}{ size = -1}, \param{wxIPCFormat}{ format = wxCF\_TEXT}}
Called by the server application to advise the client of a change
in the data associated with the given item. Causes the client
-connection's \helpref{wxConnection::OnAdvise}{wxddeconnectiononadvise} member
+connection's \helpref{wxConnection::OnAdvise}{wxconnectiononadvise} member
to be called. Returns true if successful.
-\membersection{wxConnection::Execute}\label{wxddeconnectionexecute}
+\membersection{wxConnection::Execute}\label{wxconnectionexecute}
\func{bool}{Execute}{\param{char* }{data}, \param{int}{ size = -1}, \param{wxIPCFormat}{ format = wxCF\_TEXT}}
Called by the client application to execute a command on the
server. Can also be used to transfer arbitrary data to the server
-(similar to \helpref{wxConnection::Poke}{wxddeconnectionpoke} in
-that respect). Causes the server connection's \helpref{wxConnection::OnExecute}{wxddeconnectiononexecute}
+(similar to \helpref{wxConnection::Poke}{wxconnectionpoke} in
+that respect). Causes the server connection's \helpref{wxConnection::OnExecute}{wxconnectiononexecute}
member to be called. Returns true if successful.
-\membersection{wxConnection::Disconnect}
+\membersection{wxConnection::Disconnect}\label{wxconnectiondisconnect}
\func{bool}{Disconnect}{\void}
Called by the client or server application to disconnect from the
-other program; it causes the \helpref{wxConnection::OnDisconnect}{wxddeconnectionondisconnect}
+other program; it causes the \helpref{wxConnection::OnDisconnect}{wxconnectionondisconnect}
message to be sent to the corresponding connection object in the
other program. Returns true if successful or already disconnected.
The application that calls {\bf Disconnect} must explicitly delete
its side of the connection.
-\membersection{wxConnection::OnAdvise}\label{wxddeconnectiononadvise}
+\membersection{wxConnection::OnAdvise}\label{wxconnectiononadvise}
\func{virtual bool}{OnAdvise}{\param{const wxString\& }{topic}, \param{const wxString\& }{item}, \param{char* }{data}, \param{int}{ size}, \param{wxIPCFormat}{ format}}
Message sent to the client application when the server notifies
it of a change in the data associated with the given item, using
-\helpref{Advise}{wxddeconnectionadvise}.
+\helpref{Advise}{wxconnectionadvise}.
-\membersection{wxConnection::OnDisconnect}\label{wxddeconnectionondisconnect}
+\membersection{wxConnection::OnDisconnect}\label{wxconnectionondisconnect}
\func{virtual bool}{OnDisconnect}{\void}
(finally calling the inherited method as well) so that they know
the connection object is no longer available.
-\membersection{wxConnection::OnExecute}\label{wxddeconnectiononexecute}
+\membersection{wxConnection::OnExecute}\label{wxconnectiononexecute}
\func{virtual bool}{OnExecute}{\param{const wxString\& }{topic}, \param{char* }{data}, \param{int}{ size}, \param{wxIPCFormat}{ format}}
Message sent to the server application when the client notifies
-it to execute the given data, using \helpref{Execute}{wxddeconnectionexecute}.
+it to execute the given data, using \helpref{Execute}{wxconnectionexecute}.
Note that there is no item associated with this message.
-\membersection{wxConnection::OnPoke}\label{wxddeconnectiononpoke}
+\membersection{wxConnection::OnPoke}\label{wxconnectiononpoke}
\func{virtual bool}{OnPoke}{\param{const wxString\& }{topic}, \param{const wxString\& }{item}, \param{char* }{data}, \param{int}{ size}, \param{wxIPCFormat}{ format}}
Message sent to the server application when the client notifies it to
accept the given data.
-\membersection{wxConnection::OnRequest}\label{wxddeconnectiononrequest}
+\membersection{wxConnection::OnRequest}\label{wxconnectiononrequest}
\func{virtual char*}{OnRequest}{\param{const wxString\& }{topic}, \param{const wxString\& }{item}, \param{int *}{size}, \param{wxIPCFormat}{ format}}
Message sent to the server application when the client calls
-\helpref{wxConnection::Request}{wxddeconnectionrequest}. The
-server's \helpref{OnRequest}{wxddeconnectiononrequest} method
+\helpref{wxConnection::Request}{wxconnectionrequest}. The
+server's \helpref{OnRequest}{wxconnectiononrequest} method
should respond by returning a character string, or NULL to
indicate no data, and setting *size. The character string must of
course persist after the call returns.
-\membersection{wxConnection::OnStartAdvise}\label{wxddeconnectiononstartadvise}
+\membersection{wxConnection::OnStartAdvise}\label{wxconnectiononstartadvise}
\func{virtual bool}{OnStartAdvise}{\param{const wxString\& }{topic}, \param{const wxString\& }{item}}
wishes to start an `advise loop' for the given topic and item. The
server can refuse to participate by returning false.
-\membersection{wxConnection::OnStopAdvise}\label{wxddeconnectiononstopadvise}
+\membersection{wxConnection::OnStopAdvise}\label{wxconnectiononstopadvise}
\func{virtual bool}{OnStopAdvise}{\param{const wxString\& }{topic}, \param{const wxString\& }{item}}
server can refuse to stop the advise loop by returning false, although
this doesn't have much meaning in practice.
-\membersection{wxConnection::Poke}\label{wxddeconnectionpoke}
+\membersection{wxConnection::Poke}\label{wxconnectionpoke}
\func{bool}{Poke}{\param{const wxString\& }{item}, \param{char* }{data}, \param{int}{ size = -1}, \param{wxIPCFormat}{ format = wxCF\_TEXT}}
Called by the client application to poke data into the server.
Can be used to transfer arbitrary data to the server. Causes the
-server connection's \helpref{wxConnection::OnPoke}{wxddeconnectiononpoke} member to
+server connection's \helpref{wxConnection::OnPoke}{wxconnectiononpoke} member to
be called. If size is -1 the size is computed from the string
length of data.
Returns true if successful.
-\membersection{wxConnection::Request}\label{wxddeconnectionrequest}
+\membersection{wxConnection::Request}\label{wxconnectionrequest}
\func{char*}{Request}{\param{const wxString\& }{item}, \param{int *}{size}, \param{wxIPCFormat}{ format = wxIPC\_TEXT}}
Called by the client application to request data from the server.
-Causes the server connection's \helpref{wxConnection::OnRequest}{wxddeconnectiononrequest}
+Causes the server connection's \helpref{wxConnection::OnRequest}{wxconnectiononrequest}
member to be called. Size may be NULL or a pointer to a variable
to receive the size of the requested item.
connection's buffer) if successful, NULL otherwise. This buffer
does not need to be deleted.
-\membersection{wxConnection::StartAdvise}\label{wxddeconnectionstartadvise}
+\membersection{wxConnection::StartAdvise}\label{wxconnectionstartadvise}
\func{bool}{StartAdvise}{\param{const wxString\& }{item}}
Called by the client application to ask if an advise loop can be
started with the server. Causes the server connection's
-\helpref{wxConnection::OnStartAdvise}{wxddeconnectiononstartadvise}\rtfsp
+\helpref{wxConnection::OnStartAdvise}{wxconnectiononstartadvise}\rtfsp
member to be called. Returns true if the server okays it, false
otherwise.
-\membersection{wxConnection::StopAdvise}\label{wxddeconnectionstopadvise}
+\membersection{wxConnection::StopAdvise}\label{wxconnectionstopadvise}
\func{bool}{StopAdvise}{\param{const wxString\& }{item}}
Called by the client application to ask if an advise loop can be
-stopped. Causes the server connection's \helpref{wxConnection::OnStopAdvise}{wxddeconnectiononstopadvise}
+stopped. Causes the server connection's \helpref{wxConnection::OnStopAdvise}{wxconnectiononstopadvise}
member to be called. Returns true if the server okays it, false
otherwise.
-\section{\class{wxServer}}\label{wxddeserver}
+\section{\class{wxServer}}\label{wxserver}
A wxServer object represents the server part of a client-server
DDE-like (Dynamic Data Exchange) conversation. The actual
\wxheading{See also}
-\helpref{wxClient}{wxddeclient},
+\helpref{wxClient}{wxclient},
\helpref{wxConnection}{wxddeconnection}, \helpref{IPC
overview}{ipcoverview}
\section{Stock items}\label{stockitems}
Window IDs for which stock buttons are created
-(see \helpref{wxButton constructor}{wxbuttonconstr}):
+(see \helpref{wxButton constructor}{wxbuttonctor}):
\begin{twocollist}\itemsep=0pt
\twocolitem{wxID\_ADD}{"Add"}
% ----------
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxBufferedOutputStream::wxBufferedOutputStream}
+\membersection{wxBufferedOutputStream::wxBufferedOutputStream}\label{wxbufferedoutputstreamctor}
\func{}{wxBufferedOutputStream}{\param{const wxOutputStream\&}{ parent}}
Creates a buffered stream using a buffer of a default size of 1024 bytes for cashing
the stream {\it parent}.
-\membersection{wxBufferedOutputStream::\destruct{wxBufferedOutputStream}}
+\membersection{wxBufferedOutputStream::\destruct{wxBufferedOutputStream}}\label{wxbufferedoutputstreamdtor}
\func{}{\destruct{wxBufferedOutputStream}}{\void}
Destructor. Calls Sync() and destroys the internal buffer.
-\membersection{wxBufferedOutputStream::SeekO}
+\membersection{wxBufferedOutputStream::SeekO}\label{wxbufferedoutputstreamseeko}
\func{off\_t}{SeekO}{\param{off\_t}{ pos}, \param{wxSeekMode}{ mode}}
Calls Sync() and changes the stream position.
-\membersection{wxBufferedOutputStream::Sync}
+\membersection{wxBufferedOutputStream::Sync}\label{wxbufferedoutputstreamsync}
\func{void}{Sync}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxTCPClient::wxTCPClient}
+\membersection{wxTCPClient::wxTCPClient}\label{wxtcpclientctor}
\func{}{wxTCPClient}{\void}
as \helpref{wxTCPConnection::OnAdvise}{wxtcpconnectiononadvise}. You may also want to
store application-specific data in instances of the new class.
-\membersection{wxTCPClient::ValidHost}
+\membersection{wxTCPClient::ValidHost}\label{wxtcpclientvalidhost}
\func{bool}{ValidHost}{\param{const wxString\& }{host}}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxTCPConnection::wxTCPConnection}
+\membersection{wxTCPConnection::wxTCPConnection}\label{wxtcpconnectionctor}
\func{}{wxTCPConnection}{\void}
a buffer and size of the buffer for the connection object to use in
transactions.
-\membersection{wxTCPConnection::Advise}
+\membersection{wxTCPConnection::Advise}\label{wxtcpconnectionadvise}
\func{bool}{Advise}{\param{const wxString\& }{item}, \param{char* }{data}, \param{int}{ size = -1}, \param{wxIPCFormat}{ format = wxCF\_TEXT}}
connection's \helpref{wxTCPConnection::OnAdvise}{wxtcpconnectiononadvise}
member to be called. Returns true if successful.
-\membersection{wxTCPConnection::Execute}
+\membersection{wxTCPConnection::Execute}\label{wxtcpconnectionexecute}
\func{bool}{Execute}{\param{char* }{data}, \param{int}{ size = -1}, \param{wxIPCFormat}{ format = wxCF\_TEXT}}
server connection's \helpref{wxTCPConnection::OnExecute}{wxtcpconnectiononexecute} member to be
called. Returns true if successful.
-\membersection{wxTCPConnection::Disconnect}
+\membersection{wxTCPConnection::Disconnect}\label{wxtcpconnectiondisconnect}
\func{bool}{Disconnect}{\void}
\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxTCPServer::wxTCPServer}
+\membersection{wxTCPServer::wxTCPServer}\label{wxtcpserverctor}
\func{}{wxTCPServer}{\void}
Constructs a server object.
-\membersection{wxTCPServer::Create}
+\membersection{wxTCPServer::Create}\label{wxtcpservercreate}
\func{bool}{Create}{\param{const wxString\& }{service}}
\section{Interprocess communication overview}\label{ipcoverview}
-Classes: \helpref{wxServer}{wxddeserver},
+Classes: \helpref{wxServer}{wxserver},
\helpref{wxConnection}{wxddeconnection},
-\helpref{wxClient}{wxddeclient}
+\helpref{wxClient}{wxclient}
%\helpref{wxTCPServer}{wxtcpserver}, \helpref{wxTCPConnection}{wxtcpconnection},
%\helpref{wxTCPClient}{wxtcpclient}
create and return an instance of the derived connection class.
\item Create an instance of your client object.
\item When appropriate, create a new connection using
-\helpref{wxClient::MakeConnection}{wxddeclientmakeconnection},
+\helpref{wxClient::MakeConnection}{wxclientmakeconnection},
with arguments host name (processed in Unix only, use `localhost'
for local computer), service name, and topic name for this
connection. The client object will call
projects / wxWidgets.git / commitdiff
