+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Name: socket.tex
+%% Purpose: wxSocket docs
+%% Author: Guillermo Rodriguez Garcia <guille@iies.es>
+%% Modified by:
+%% Created: 1999
+%% RCS-ID: $Id$
+%% Copyright: (c) wxWindows team
+%% Licence: wxWindows licence
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
\section{\class{wxSocketBase}}\label{wxsocketbase}
+wxSocketBase is the base class for all socket-related objects, and it
+defines all basic IO functionality.
+
\wxheading{Derived from}
\helpref{wxEvtHandler}{wxevthandler}
\twocolitem{{\bf wxSOCKET\_WOULDBLOCK}}{The socket is non-blocking and the operation would block.}
\twocolitem{{\bf wxSOCKET\_TIMEDOUT}}{The timeout for this operation expired.}
\twocolitem{{\bf wxSOCKET\_MEMERR}}{Memory exhausted.}
-\end{twocollist}%
+\end{twocollist}
\wxheading{wxSocket events}
\twocolwidtha{7cm}
\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf wxSOCKET\_INPUT}}{Some data has arrived to the socket.}
+\twocolitem{{\bf wxSOCKET\_INPUT}}{There is data available for reading.}
\twocolitem{{\bf wxSOCKET\_OUTPUT}}{The socket is ready to be written to.}
-\twocolitem{{\bf wxSOCKET\_CONNECTION}}{Incoming connection arrival (server), or connection establishment (client).}
+\twocolitem{{\bf wxSOCKET\_CONNECTION}}{Incoming connection (server), or connection establishment (client).}
\twocolitem{{\bf wxSOCKET\_LOST}}{The connection has been closed.}
-\twocolitem{{\bf wxSOCKET\_MAX\_EVENT}}{This should never happen but the compiler may complain about it.}
-\end{twocollist}%
+\end{twocollist}
A brief note on how to use these events:
-The {\bf wxSOCKET\_INPUT} event will be issued when the incoming queue
-was empty and new data arrives, but NOT if new data arrives when there
-was data waiting in the incoming queue.
-
-The {\bf wxSOCKET\_OUTPUT} event is issued when a socket is first connected
-with Connect or accepted with Accept, and then, only after an output operation
-fails because the output buffer was full, and buffer space becomes available
-again.
-
-The {\bf wxSOCKET\_CONNECTION} event is issued when a connection request
-completes (client) or when a new connection arrives at the pending
-connections queue (server).
+The {\bf wxSOCKET\_INPUT} event will be issued whenever there is data
+available for reading. This will be the case if the input queue was
+empty and new data arrives, or if the application has read some data
+yet there is still more data available. This means that the application
+does not need to read all available data in response to a
+{\bf wxSOCKET\_INPUT} event, as more events will be produced as
+necessary.
+
+The {\bf wxSOCKET\_OUTPUT} event is issued when a socket is first
+connected with \helpref{Connect}{wxsocketclientconnect} or accepted
+with \helpref{Accept}{wxsocketserveraccept}. After that, new
+events will be generated only after an output operation fails
+with {\bf wxSOCKET\_WOULDBLOCK} and buffer space becomes available
+again. This means that the application should assume that it
+can write data to the socket until an {\bf wxSOCKET\_WOULDBLOCK}
+error occurs; after this, whenever the socket becomes writable
+again the application will be notified with another
+{\bf wxSOCKET\_OUTPUT} event.
+
+The {\bf wxSOCKET\_CONNECTION} event is issued when a delayed connection
+request completes succesfully (client) or when a new connection arrives
+at the incoming queue (server).
The {\bf wxSOCKET\_LOST} event is issued when a close indication is
received for the socket. This means that the connection broke down or
-that it was closed by the peer.
+that it was closed by the peer. Also, this event will be issued if
+a delayed connection request fails.
-% ---------------------------------------------------------------------------
-% Event handling
-% ---------------------------------------------------------------------------
\wxheading{Event handling}
-To process events from a socket, use the following event handler macro to direct
-input to member functions that take a \helpref{wxSocketEvent}{wxsocketevent} argument.
+To process events coming from a socket object, use the following event
+handler macro to direct events to member functions that take a
+\helpref{wxSocketEvent}{wxsocketevent} argument.
\twocolwidtha{7cm}%
\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf EVT\_SOCKET(id, func)}}{A socket event occured.}
-\end{twocollist}%
+\twocolitem{{\bf EVT\_SOCKET(id, func)}}{Process a wxEVT\_SOCKET event.}
+\end{twocollist}
-% ---------------------------------------------------------------------------
-% See also ...
-% ---------------------------------------------------------------------------
\wxheading{See also}
\helpref{wxSocketEvent}{wxsocketevent},
\helpref{wxSocketClient}{wxsocketclient},
-\helpref{wxSocketServer}{wxsocketserver}
+\helpref{wxSocketServer}{wxsocketserver},
+\helpref{Sockets sample}{samplesockets}
% ---------------------------------------------------------------------------
-% Members
+% Function groups
% ---------------------------------------------------------------------------
-\latexignore{\rtfignore{\wxheading{Members}}}
-\membersection{wxSocketBase::wxSocketBase}
+\latexignore{\rtfignore{\wxheading{Function groups}}}
-\func{}{wxSocketBase}{\void}
+\membersection{Construction and destruction}
-Default constructor. Don't use it; use \helpref{wxSocketClient}{wxsocketclient}
-or \helpref{wxSocketServer}{wxsocketserver}.
+\helpref{wxSocketBase}{wxsocketbaseconstruct}\\
+\helpref{\destruct{wxSocketBase}}{wxsocketbasedestruct}
-\membersection{wxSocketBase::\destruct{wxSocketBase}}
+\membersection{Socket state}
-\func{}{\destruct{wxSocketBase}}{\void}
+Functions to retrieve current state and miscellaneous info.
-Destroys the wxSocketBase object.
+\helpref{Error}{wxsocketbaseerror}\\
+\helpref{GetLocal}{wxsocketbasegetlocal}\\
+\helpref{GetPeer}{wxsocketbasegetpeer}
+\helpref{IsConnected}{wxsocketbaseisconnected}\\
+\helpref{IsData}{wxsocketbaseisdata}\\
+\helpref{IsDisconnected}{wxsocketbaseisdisconnected}\\
+\helpref{LastCount}{wxsocketbaselastcount}\\
+\helpref{LastError}{wxsocketbaselasterror}\\
+\helpref{Ok}{wxsocketbaseok}\\
+\helpref{SaveState}{wxsocketbasesavestate}\\
+\helpref{RestoreState}{wxsocketbaserestorestate}
-% ---------------------------------------------------------------------------
-% State functions
-% ---------------------------------------------------------------------------
+\membersection{Basic IO}
-%
-% SetFlags
-%
+Functions that perform basic IO functionality.
-\membersection{wxSocketBase::SetFlags}\label{wxsocketbasesetflags}
+\helpref{Close}{wxsocketbaseclose}\\
+\helpref{Discard}{wxsocketbasediscard}\\
+\helpref{Peek}{wxsocketbasepeek}\\
+\helpref{Read}{wxsocketbaseread}\\
+\helpref{ReadMsg}{wxsocketbasereadmsg}\\
+\helpref{Unread}{wxsocketbaseunread}\\
+\helpref{Write}{wxsocketbasewrite}\\
+\helpref{WriteMsg}{wxsocketbasewritemsg}
-\func{void}{SetFlags}{\param{wxSocketBase::wxSockFlags}{ flags}}
+Functions that perform a timed wait on a certain IO condition.
-\twocolwidtha{7cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf wxSOCKET\_NONE}}{Normal functionnality.}
-\twocolitem{{\bf wxSOCKET\_NOWAIT}}{Get the available data in the input queue and return immediately.}
-\twocolitem{{\bf wxSOCKET\_WAITALL}}{Wait for all required data unless an error occurs.}
-\twocolitem{{\bf wxSOCKET\_BLOCK}}{Block the GUI (do not wxYield) while reading/writing data.}
-\end{twocollist}
+\helpref{Wait}{wxsocketbasewait}\\
+\helpref{WaitForRead}{wxsocketbasewaitforread}\\
+\helpref{WaitForWrite}{wxsocketbasewaitforwrite}\\
+\helpref{WaitForLost}{wxsocketbasewaitforlost}
-A brief overview on how to use these flags follows.
+Functions that allow applications to customize socket IO as needed.
-If no flag is specified (this is the same as {\bf wxSOCKET\_NONE}),
-IO calls will return after some data has been read or written, even
-when the transfer might not be complete. This is the same as issuing
-exactly one blocking low-level call to recv() or send(). Note that
-blocking here refers to when the function returns, not to whether
-the GUI blocks during this time.
+\helpref{SetFlags}{wxsocketbasesetflags}\\
+\helpref{SetTimeout}{wxsocketbasesettimeout}
-If {\bf wxSOCKET\_NOWAIT} is specified, IO calls will return immediately.
-Read operations will retrieve only available data. Write operations will
-write as much data as possible, depending on how much space is available
-in the output buffer. This is the same as issuing exactly one nonblocking
-low-level call to recv() or send(). Note that nonblocking here refers to
-when the function returns, not to whether the GUI blocks during this time.
+\membersection{Handling socket events}
-If {\bf wxSOCKET\_WAITALL} is specified, IO calls won't return until ALL
-the data has been read or written (or until an error occurs), blocking if
-necessary, and issuing several low level calls if necessary. This is the
-same as having a loop which makes as many blocking low-level calls to
-recv() or send() as needed so as to transfer all the data. Note that
-"blocking" here refers to when the function returns, not to whether
-the GUI blocks during this time.
+Functions that allow applications to receive socket events.
-The {\bf wxSOCKET\_BLOCK} controls whether the GUI blocks during IO
-operations. If this flag is not used, then the application must take
-extra care to avoid unwanted reentrance.
+\helpref{Notify}{wxsocketbasenotify}\\
+\helpref{SetNotify}{wxsocketbasesetnotify}\\
+\helpref{SetEventHandler}{wxsocketbaseseteventhandler}
-So:
+Callback functions are also available, but they are provided for backwards
+compatibility only. Their use is discouraged in favour of events, and should
+be considered deprecated.
-{\bf wxSOCKET\_NONE} will try to read SOME data, no matter how much.
+\helpref{Callback}{wxsocketbasecallback}\\
+\helpref{CallbackData}{wxsocketbasecallbackdata}
-{\bf wxSOCKET\_NOWAIT} will always return immediately, even if it cannot
-read or write ANY data.
-{\bf wxSOCKET\_WAITALL} will only return when it has read or written ALL
-the data.
+% ---------------------------------------------------------------------------
+% Members here
+% ---------------------------------------------------------------------------
-{\bf wxSOCKET\_BLOCK} has nothing to do with the previous flags and
-it control whether the GUI blocks.
+\helponly{\insertatlevel{2}{
-%
-% SetNotify
-%
-\membersection{wxSocketBase::SetNotify}\label{wxsocketbasesetnotify}
+\wxheading{Members}
-\func{void}{SetNotify}{\param{wxSocketEventFlags}{ flags}}
+}}
-SetNotify specifies which socket events are to be sent to the event handler.
-The {\it flags} parameter is a combination of flags ORed toghether. The
-following flags can be used:
+\membersection{wxSocketBase::wxSocketBase}\label{wxsocketbaseconstruct}
-\twocolwidtha{7cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf wxSOCKET\_INPUT\_FLAG}}{to receive wxSOCKET\_INPUT}
-\twocolitem{{\bf wxSOCKET\_OUTPUT\_FLAG}}{to receive wxSOCKET\_OUTPUT}
-\twocolitem{{\bf wxSOCKET\_CONNECTION\_FLAG}}{to receive wxSOCKET\_CONNECTION}
-\twocolitem{{\bf wxSOCKET\_LOST\_FLAG}}{to receive wxSOCKET\_LOST}
-\end{twocollist}%
+\func{}{wxSocketBase}{\void}
-For example:
+Default constructor. Don't use it directly; instead, use
+\helpref{wxSocketClient}{wxsocketclient} to construct a socket client, or
+\helpref{wxSocketServer}{wxsocketserver} to construct a socket server.
+
+\membersection{wxSocketBase::\destruct{wxSocketBase}}\label{wxsocketbasedestruct}
+
+\func{}{\destruct{wxSocketBase}}{\void}
+
+Destructor.
+
+%
+% Callback
+%
+\membersection{wxSocketBase::Callback}\label{wxsocketbasecallback}
+
+\func{wxSocketBase::wxSockCbk}{Callback}{\param{wxSocketBase::wxSockCbk}{ callback}}
+
+You can setup a callback function to be called when an event occurs.
+The function will be called only for those events for which notification
+has been enabled with \helpref{Notify}{wxsocketbasenotify} and
+\helpref{SetNotify}{wxsocketbasesetnotify}. The prototype of the
+callback must be as follows:
\begin{verbatim}
- sock.SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
+void SocketCallback(wxSocketBase& sock, wxSocketNotify evt, char *cdata);
\end{verbatim}
-In this example, the user will be notified about incoming socket data and
-whenever the connection is closed.
+The first parameter is a reference to the socket object in which the
+event occured. The second parameter tells you which event occured.
+(See \helpref{wxSocket events}{wxsocketbase}). The third parameter
+is the user data you specified using
+\helpref{CallbackData}{wxsocketbasecallbackdata}.
-For more information on socket events see \helpref{wxSocket events}{wxsocketbase}.
+Note that events are preferred over callbacks where possible.
+
+\wxheading{Return value}
+
+A pointer to the previous callback.
+
+\wxheading{See also}
+
+\helpref{wxSocketBase::CallbackData}{wxsocketbasecallbackdata},
+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
+\helpref{wxSocketBase::Notify}{wxsocketbasenotify}
%
-% SetTimeout
+% CallbackData
%
-\membersection{wxSocketBase::SetTimeout}{wxsocketbasesettimeout}
+\membersection{wxSocketBase::CallbackData}\label{wxsocketbasecallbackdata}
-\func{void}{SetTimeout}{\param{int }{seconds}}
+\func{char *}{CallbackData}{\param{char *}{cdata}}
-This function sets the default socket timeout in seconds. This
-timeout applies to IO calls and also to Wait functions if you
-don't specify a wait interval. If you never use SetTimeout, the
-default timeout will be 10 minutes.
+This function sets the the user data which will be passed to a
+callback function set via \helpref{Callback}{wxsocketbasecallback}.
+
+Note that events are preferred over callbacks where possible.
+
+\wxheading{Return value}
+
+A pointer to the previous user data.
+
+\helpref{wxSocketBase::Callback}{wxsocketbasecallback},
+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
+\helpref{wxSocketBase::Notify}{wxsocketbasenotify}
%
-% Notify
+% Close
%
-\membersection{wxSocketBase::Notify}\label{wxsocketbasenotify}
+\membersection{wxSocketBase::Close}\label{wxsocketbaseclose}
-\func{void}{Notify}{\param{bool}{ notify}}
+\func{void}{Close}{\void}
-Notify will enable (notify is TRUE) or disable (notify is FALSE) the propagation
-of socket events.
+This function shuts down the socket, disabling further transmission and
+reception of data; it also disables events for the socket and frees the
+associated system resources. If you destroy a socket, Close is automatically
+called.
+
+\wxheading{Remark/Warning}
+
+Although Close immediately disables events for the socket, it is possible
+that event messages may be waiting in the application's event queue. The
+application must therefore be prepared to handle socket event messages
+even after calling Close.
-%
-% Ok
%
+% Discard
+%
+\membersection{wxSocketBase::Discard}\label{wxsocketbasediscard}
-\membersection{wxSocketBase::Ok}\label{wxsocketbaseok}
+\func{wxSocketBase\&}{Discard}{\void}
-\constfunc{bool}{Ok}{\void}
+This function simply deletes all bytes in the incoming queue. This function
+always returns immediately and its operation is not affected by IO flags.
-Returns TRUE if the socket is initialized and ready and FALSE in other
-cases.
+Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually discarded.
+
+If you use \helpref{Error}{wxsocketbaseerror}, it will always return FALSE.
+%
+% Error
+%
\membersection{wxSocketBase::Error}\label{wxsocketbaseerror}
\constfunc{bool}{Error}{\void}
Returns TRUE if an error occured in the last IO operation.
-The following operations update the Error() status:
-Read, Write, ReadMsg, WriteMsg, Peek, Unread, Discard.
+Use this function to check for an error condition after one of the
+following calls: Discard, Peek, Read, ReadMsg, Unread, Write, WriteMsg.
+
+%
+% GetLocal
+%
+\membersection{wxSocketBase::GetLocal}\label{wxsocketbasegetlocal}
+
+\constfunc{bool}{GetLocal}{\param{wxSockAddress\& }{addr\_man}}
+
+This function returns the local address field of the socket. The local
+address field contains the complete local address of the socket (local
+address, local port, ...).
+
+\wxheading{Return value}
+
+It returns TRUE if no errors happened, FALSE otherwise.
+
+%
+% GetPeer
+%
+\membersection{wxSocketBase::GetPeer}\label{wxsocketbasegetpeer}
+
+\constfunc{bool}{GetPeer}{\param{wxSockAddress\& }{addr\_man}}
+
+This function returns the peer address field of the socket. The peer
+address field contains the complete peer host address of the socket
+(address, port, ...).
+
+\wxheading{Return value}
-\membersection{wxSocketBase::IsConnected}\label{wxsocketbaseconnected}
+It returns TRUE if no errors happened, FALSE otherwise.
+
+%
+% IsConnected
+%
+\membersection{wxSocketBase::IsConnected}\label{wxsocketbaseisconnected}
\constfunc{bool}{IsConnected}{\void}
Returns TRUE if the socket is connected.
+%
+% IsData
+%
\membersection{wxSocketBase::IsData}\label{wxsocketbaseisdata}
\constfunc{bool}{IsData}{\void}
-Returns TRUE if there is data available to be read.
+Returns TRUE if the socket is readable. This might mean that
+queued data is available for reading or, for streamed sockets, that
+the connection has been closed, so that a \helpref{Read}{wxsocketbaseread},
+\helpref{ReadMsg}{wxsocketbasereadmsg} or \helpref{Peek}{wxsocketbasepeek}
+operation is guaranteed to complete immediately (unless the
+{\bf wxSOCKET\_WAITALL} flag is set).
-\membersection{wxSocketBase::IsDisconnected}\label{wxsocketbasedisconnected}
+\membersection{wxSocketBase::IsDisconnected}\label{wxsocketbaseisdisconnected}
+%
+% IsDisconnected
+%
\constfunc{bool}{IsDisconnected}{\void}
-Returns TRUE if the socket is disconnected.
-
-\membersection{wxSocketBase::IsNoWait}\label{wxsocketbasenowait}
-
-\constfunc{bool}{IsNoWait}{\void}
-
-Returns TRUE if the socket mustn't wait.
+Returns TRUE if the socket is not connected.
\membersection{wxSocketBase::LastCount}\label{wxsocketbaselastcount}
+%
+% LastCount
+%
\constfunc{wxUint32}{LastCount}{\void}
Returns the number of bytes read or written by the last IO call.
-The following operations update the LastCount() value:
-Read, Write, ReadMsg, WriteMsg, Peek, Unread, Discard.
+Use this function to get the number of bytes actually transferred
+after using one of the following IO calls: Discard, Peek, Read,
+ReadMsg, Unread, Write, WriteMsg.
+%
+% LastError
+%
\membersection{wxSocketBase::LastError}\label{wxsocketbaselasterror}
\constfunc{wxSocketError}{LastError}{\void}
Please note that this function merely returns the last error code,
but it should not be used to determine if an error has occured (this
-is because successful operations do not change tha LastError value).
-Use Error, instead of LastError, to determine if the last IO call
-failed. If Error returns TRUE, use LastError to discover the
-cause of the error.
+is because successful operations do not change the LastError value).
+Use \helpref{Error}{wxsocketbaseerror} first, in order to determine
+if the last IO call failed. If this returns TRUE, use LastError
+to discover the cause of the error.
-% ---------------------------------------------------------------------------
-% IO calls
-% ---------------------------------------------------------------------------
%
-% Peek
+% Notify
%
-\membersection{wxSocketBase::Peek}\label{wxsocketbasepeek}
+\membersection{wxSocketBase::Notify}\label{wxsocketbasenotify}
-\func{wxSocketBase\&}{Peek}{\param{char *}{ buffer}, \param{wxUint32}{ nbytes}}
+\func{void}{Notify}{\param{bool}{ notify}}
+
+According to the {\it notify} value, this function enables
+or disables socket events. If {\it notify} is TRUE, the events
+configured with \helpref{SetNotify}{wxsocketbasesetnotify} will
+be sent to the application. If {\it notify} is FALSE; no events
+will be sent.
-This function peeks a buffer of {\it nbytes} bytes from the socket. Peeking a buffer
-doesn't delete it from the system socket in-queue.
+%
+% Ok
+%
+\membersection{wxSocketBase::Ok}\label{wxsocketbaseok}
-Use LastCount to verify the number of bytes actually peeked.
+\constfunc{bool}{Ok}{\void}
-Use Error to determine if the operation succeeded.
+Returns TRUE if the socket is initialized and ready and FALSE in other
+cases.
-\wxheading{Parameters}
+%
+% RestoreState
+%
+\membersection{wxSocketBase::RestoreState}\label{wxsocketbaserestorestate}
-\docparam{buffer}{Buffer where to put peeked data.}
+\func{void}{RestoreState}{\void}
-\docparam{nbytes}{Number of bytes.}
+This function restores the previous state of the socket, as saved
+with \helpref{SaveState}{wxsocketbasesavestate}
-\wxheading{Return value}
+Calls to SaveState and RestoreState can be nested.
-Returns a reference to the current object.
+\wxheading{See also}
-\wxheading{Remark/Warning}
+\helpref{wxSocketBase::SaveState}{wxsocketbasesavestate}
-The exact behaviour of wxSocketBase::Peek() depends on the combination
-of flags being used. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}
+%
+% SaveState
+%
+\membersection{wxSocketBase::SaveState}\label{wxsocketbasesavestate}
+
+\func{void}{SaveState}{\void}
+
+This function saves the current state of the socket in a stack. Socket
+state includes flags, as set with \helpref{SetFlags}{wxsocketbasesetflags},
+event mask, as set with \helpref{SetNotify}{wxsocketbasesetnotify} and
+\helpref{Notify}{wxsocketbasenotify}, and current settings for the
+asynchronous callbacks, as set with \helpref{Callback}{wxsocketbasecallback}
+and \helpref{CallbackData}{wxsocketbasecallbackdata}.
+
+Calls to SaveState and RestoreState can be nested.
\wxheading{See also}
-\helpref{wxSocketBase::Error}{wxsocketbaseerror},
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror},
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
-\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}
+\helpref{wxSocketBase::RestoreState}{wxsocketbaserestorestate}
%
-% Read
+% SetEventHandler
%
-\membersection{wxSocketBase::Read}\label{wxsocketbaseread}
-
-\func{wxSocketBase\&}{Read}{\param{char *}{ buffer}, \param{wxUint32}{ nbytes}}
+\membersection{wxSocketBase::SetEventHandler}\label{wxsocketbaseseteventhandler}
-This function reads a buffer of {\it nbytes} bytes from the socket.
+\func{void}{SetEventHandler}{\param{wxEvtHandler\&}{ evt\_hdlr}, \param{int}{ id = -1}}
-Use LastCount to verify the number of bytes actually read.
+Sets an event handler to be called when a socket event occurs. The
+handler will be called for those events for which notification is
+enabled with \helpref{SetNotify}{wxsocketbasesetnotify} and
+\helpref{Notify}{wxsocketbasenotify}.
-Use Error to determine if the operation succeeded.
+You can also specify a callback function to be called when an event
+occurs, although if possible, events should be used instead of callbacks.
+See \helpref{Callback}{wxsocketbasecallback} and
+\helpref{CallbackData}{wxsocketbasecallbackdata}.
\wxheading{Parameters}
-\docparam{buffer}{Buffer where to put read data.}
+\docparam{evt\_hdlr}{Specifies the event handler you want to use.}
-\docparam{nbytes}{Number of bytes.}
+\docparam{id}{The id of socket event.}
-\wxheading{Return value}
+\wxheading{See also}
-Returns a reference to the current object.
+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
+\helpref{wxSocketBase::Notify}{wxsocketbasenotify},
+\helpref{wxSocketEvent}{wxsocketevent},
+\helpref{wxEvtHandler}{wxevthandler},
+\helpref{wxSocketBase::Callback}{wxsocketbasecallback},
+\helpref{wxSocketBase::CallbackData}{wxsocketbasecallbackdata}
-\wxheading{Remark/Warning}
+%
+% SetFlags
+%
+\membersection{wxSocketBase::SetFlags}\label{wxsocketbasesetflags}
-The exact behaviour of wxSocketBase::Read() depends on the combination
-of flags being used. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}.
+\func{void}{SetFlags}{\param{wxSocketBase::wxSockFlags}{ flags}}
-\wxheading{See also}
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxSOCKET\_NONE}}{Normal functionality.}
+\twocolitem{{\bf wxSOCKET\_NOWAIT}}{Read/write as much data as possible and return immediately.}
+\twocolitem{{\bf wxSOCKET\_WAITALL}}{Wait for all required data to be read/written unless an error occurs.}
+\twocolitem{{\bf wxSOCKET\_BLOCK}}{Block the GUI (do not yield) while reading/writing data.}
+\end{twocollist}
-\helpref{wxSocketBase::Error}{wxsocketbaseerror},
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror},
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
-\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}
+A brief overview on how to use these flags follows.
+
+If no flag is specified (this is the same as {\bf wxSOCKET\_NONE}),
+IO calls will return after some data has been read or written, even
+when the transfer might not be complete. This is the same as issuing
+exactly one blocking low-level call to recv() or send(). Note that
+{\it blocking} here refers to when the function returns, not to whether
+the GUI blocks during this time.
+
+If {\bf wxSOCKET\_NOWAIT} is specified, IO calls will return immediately.
+Read operations will retrieve only available data. Write operations will
+write as much data as possible, depending on how much space is available
+in the output buffer. This is the same as issuing exactly one nonblocking
+low-level call to recv() or send(). Note that {\it nonblocking} here
+refers to when the function returns, not to whether the GUI blocks during
+this time.
+
+If {\bf wxSOCKET\_WAITALL} is specified, IO calls won't return until ALL
+the data has been read or written (or until an error occurs), blocking if
+necessary, and issuing several low level calls if necessary. This is the
+same as having a loop which makes as many blocking low-level calls to
+recv() or send() as needed so as to transfer all the data. Note that
+{\it blocking} here refers to when the function returns, not to whether
+the GUI blocks during this time.
+
+The {\bf wxSOCKET\_BLOCK} flag controls whether the GUI blocks during
+IO operations. If this flag is specified, the socket will not yield
+during IO calls, so the GUI will remain blocked until the operation
+completes. If it is not used, then the application must take extra
+care to avoid unwanted reentrance.
+
+So:
+
+{\bf wxSOCKET\_NONE} will try to read at least SOME data, no matter how much.
+
+{\bf wxSOCKET\_NOWAIT} will always return immediately, even if it cannot
+read or write ANY data.
+
+{\bf wxSOCKET\_WAITALL} will only return when it has read or written ALL
+the data.
+
+{\bf wxSOCKET\_BLOCK} has nothing to do with the previous flags and
+it controls whether the GUI blocks.
%
-% Write
+% SetNotify
%
-\membersection{wxSocketBase::Write}\label{wxsocketbasewrite}
+\membersection{wxSocketBase::SetNotify}\label{wxsocketbasesetnotify}
-\func{wxSocketBase\&}{Write}{\param{const char *}{ buffer}, \param{wxUint32}{ nbytes}}
+\func{void}{SetNotify}{\param{wxSocketEventFlags}{ flags}}
-This function writes a buffer of {\it nbytes} bytes to the socket.
+SetNotify specifies which socket events are to be sent to the event handler.
+The {\it flags} parameter is a combination of flags ORed toghether. The
+following flags can be used:
+
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxSOCKET\_INPUT\_FLAG}}{to receive wxSOCKET\_INPUT}
+\twocolitem{{\bf wxSOCKET\_OUTPUT\_FLAG}}{to receive wxSOCKET\_OUTPUT}
+\twocolitem{{\bf wxSOCKET\_CONNECTION\_FLAG}}{to receive wxSOCKET\_CONNECTION}
+\twocolitem{{\bf wxSOCKET\_LOST\_FLAG}}{to receive wxSOCKET\_LOST}
+\end{twocollist}
+
+For example:
+
+\begin{verbatim}
+ sock.SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
+ sock.Notify(TRUE);
+\end{verbatim}
+
+In this example, the user will be notified about incoming socket data and
+whenever the connection is closed.
+
+For more information on socket events see \helpref{wxSocket events}{wxsocketbase}.
+
+%
+% SetTimeout
+%
+\membersection{wxSocketBase::SetTimeout}\label{wxsocketbasesettimeout}
+
+\func{void}{SetTimeout}{\param{int }{seconds}}
+
+This function sets the default socket timeout in seconds. This timeout
+applies to all IO calls, and also to the \helpref{Wait}{wxsocketbasewait}
+family of functions if you don't specify a wait interval. Initially, the
+default is set to 10 minutes.
+
+%
+% Peek
+%
+\membersection{wxSocketBase::Peek}\label{wxsocketbasepeek}
+
+\func{wxSocketBase\&}{Peek}{\param{char *}{ buffer}, \param{wxUint32}{ nbytes}}
+
+This function peeks a buffer of {\it nbytes} bytes from the socket.
+Peeking a buffer doesn't delete it from the socket input queue.
-Use LastCount to verify the number of bytes actually written.
+Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually peeked.
-Use Error to determine if the operation succeeded.
+Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded.
\wxheading{Parameters}
-\docparam{buffer}{Buffer with the data to be sent.}
+\docparam{buffer}{Buffer where to put peeked data.}
\docparam{nbytes}{Number of bytes.}
\wxheading{Remark/Warning}
-The exact behaviour of wxSocketBase::Write() depends on the combination
-of flags being used. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}.
+The exact behaviour of wxSocketBase::Peek depends on the combination
+of flags being used. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}
\wxheading{See also}
\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}
%
-% WriteMsg
+% Read
%
-\membersection{wxSocketBase::WriteMsg}\label{wxsocketbasewritemsg}
+\membersection{wxSocketBase::Read}\label{wxsocketbaseread}
-\func{wxSocketBase\&}{WriteMsg}{\param{const char *}{ buffer}, \param{wxUint32}{ nbytes}}
+\func{wxSocketBase\&}{Read}{\param{char *}{ buffer}, \param{wxUint32}{ nbytes}}
-This function writes a buffer of {\it nbytes} bytes from the socket, but it
-writes a short header before so that ReadMsg can alloc the right size for
-the buffer. So, a buffer sent with WriteMsg {\bf must} be read with ReadMsg.
-This function always waits for the entire buffer to be sent, unless an
-error occurs.
+This function reads a buffer of {\it nbytes} bytes from the socket.
-Use LastCount to verify the number of bytes actually written.
+Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually read.
-Use Error to determine if the operation succeeded.
+Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded.
\wxheading{Parameters}
-\docparam{buffer}{Buffer with the data to be sent.}
+\docparam{buffer}{Buffer where to put read data.}
\docparam{nbytes}{Number of bytes.}
\wxheading{Remark/Warning}
-wxSocketBase::WriteMsg() will behave as if the wxSOCKET\_WAITALL flag was always set
-and it will always ignore the wxSOCKET\_NOWAIT flag. The exact behaviour of WriteMsg
-depends on the wxSOCKET\_BLOCK flag. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}.
+The exact behaviour of wxSocketBase::Read depends on the combination
+of flags being used. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}.
\wxheading{See also}
\helpref{wxSocketBase::Error}{wxsocketbaseerror},
\helpref{wxSocketBase::LastError}{wxsocketbaselasterror},
\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
-\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags},
-\helpref{wxSocketBase::ReadMsg}{wxsocketbasereadmsg}
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}
%
% ReadMsg
\func{wxSocketBase\&}{ReadMsg}{\param{char *}{ buffer}, \param{wxUint32}{ nbytes}}
-This function reads a buffer sent by WriteMsg on a socket. If the buffer passed
-to the function isn't big enough, the remaining bytes will be discarded. This
-function always waits for the buffer to be entirely filled, unless an error occurs.
+This function reads a buffer sent by \helpref{WriteMsg}{wxsocketbasewritemsg}
+on a socket. If the buffer passed to the function isn't big enough, the
+remaining bytes will be discarded. This function always waits for the
+buffer to be entirely filled, unless an error occurs.
-Use LastCount to verify the number of bytes actually read.
+Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually read.
-Use Error to determine if the operation succeeded.
+Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded.
\wxheading{Parameters}
\docparam{buffer}{Buffer where to put read data.}
-\docparam{nbytes}{Number of bytes allocated for the buffer.}
+\docparam{nbytes}{Size of the buffer.}
\wxheading{Return value}
\wxheading{Remark/Warning}
-wxSocketBase::ReadMsg() will behave as if the wxSOCKET\_WAITALL flag was always set
-and it will always ignore the wxSOCKET\_NOWAIT flag. The exact behaviour of ReadMsg
-depends on the wxSOCKET\_SPEED flag. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}.
+wxSocketBase::ReadMsg will behave as if the {\bf wxSOCKET\_WAITALL} flag
+was always set and it will always ignore the {\bf wxSOCKET\_NOWAIT} flag.
+The exact behaviour of ReadMsg depends on the {\bf wxSOCKET\_BLOCK} flag.
+For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}.
\wxheading{See also}
This function unreads a buffer. That is, the data in the buffer is put back
in the incoming queue. This function is not affected by wxSocket flags.
-If you use LastCount, it will always return {\it nbytes}.
+If you use \helpref{LastCount}{wxsocketbaselastcount}, it will always return {\it nbytes}.
-If you use Error, it will always return FALSE.
+If you use \helpref{Error}{wxsocketbaseerror}, it will always return FALSE.
\wxheading{Parameters}
\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
%
-% Discard
+% Wait
%
-\membersection{wxSocketBase::Discard}\label{wxsocketbasediscard}
-
-\func{wxSocketBase\&}{Discard}{\void}
-
-This function simply deletes all bytes in the incoming queue. This function
-doesn't wait. That is, it will behave as if the wxSOCKET\_NOWAIT flag was set. The
-wxSOCKET\_SPEED and wxSOCKET\_WAITALL flags have no effect on this function.
-
-Use LastCount to see the number of bytes discarded.
-
-If you use Error, it will always return FALSE.
-
-% ---------------------------------------------------------------------------
-% Wait functions
-% ---------------------------------------------------------------------------
\membersection{wxSocketBase::Wait}\label{wxsocketbasewait}
\func{bool}{Wait}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}}
-This function waits until one of the following conditions is true: there
-is data available for reading; the output buffer is empty (you can send
-new data); the connection has been lost; an incoming connection arrived
-(only for servers); a connection request has completed (only for clients).
+This function waits until one of the following conditions is TRUE. Note
+that it is recommended to use the individual Wait functions to wait for
+the required condition, instead of this one.
+
+\begin{itemize}
+\item The socket becomes readable.
+\item The socket becomes writable.
+\item An ongoing connection request has completed (only for clients)
+\item An incoming connection request has arrived (only for servers)
+\item The connection has been closed.
+\end{itemize}
\wxheading{Parameters}
-\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
+\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 event occured, FALSE if the timeout was reached.
+Returns TRUE when any of the above conditions is satisfied,
+FALSE if the timeout was reached.
\wxheading{See also}
\func{bool}{WaitForRead}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}}
-This function waits until there is data available to be read.
+This function waits until the socket is readable. This might mean that
+queued data is available for reading or, for streamed sockets, that
+the connection has been closed, so that a \helpref{Read}{wxsocketbaseread},
+\helpref{ReadMsg}{wxsocketbasereadmsg} or \helpref{Peek}{wxsocketbasepeek}
+operation is guaranteed to complete immediately (unless the
+{\bf wxSOCKET\_WAITALL} flag is set).
\wxheading{Parameters}
-\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
+\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 there is data to be read, FALSE if the timeout was reached.
+Returns TRUE if there is data to be read, FALSE if the timeout was reached
+or an error occured.
\wxheading{See also}
\func{bool}{WaitForWrite}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}}
-This function waits until you can write to the socket.
+This function waits until the socket becomes writable. This might mean that
+the socket is ready to send new data, or for streamed sockets, that the
+connection has been closed, so that a \helpref{Write}{wxsocketbasewrite}
+or \helpref{ReadMsg}{wxsocketbasewritemsg} operation is guaranteed to
+complete immediately (unless the {\bf wxSOCKET\_WAITALL} flag is set).
\wxheading{Parameters}
-\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
+\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 you can write to the socket, FALSE if the timeout was reached.
+Returns TRUE if the socket becomes writable, FALSE if the timeout was reached.
\wxheading{See also}
\func{bool}{Wait}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}}
-This function waits until the connection is lost. This may happen if the
-peer closes the connection or if the connection breaks.
+This function waits until the connection is lost. This may happen if
+the peer gracefully closes the connection or if the connection breaks.
\wxheading{Parameters}
-\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
+\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.}
\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite},
\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
-% ---------------------------------------------------------------------------
-% Socket state
-% ---------------------------------------------------------------------------
-
%
-% RestoreState
+% Write
%
-\membersection{wxSocketBase::RestoreState}\label{wxsocketbaserestorestate}
-
-\func{void}{RestoreState}{\void}
-
-This function restores the previous state of the socket, as saved
-with SaveState.
-
-Calls to SaveState / RestoreState can be nested.
+\membersection{wxSocketBase::Write}\label{wxsocketbasewrite}
-\wxheading{See also}
+\func{wxSocketBase\&}{Write}{\param{const char *}{ buffer}, \param{wxUint32}{ nbytes}}
-\helpref{wxSocketBase::SaveState}{wxsocketbasesavestate}
+This function writes a buffer of {\it nbytes} bytes to the socket.
-%
-% SaveState
-%
-\membersection{wxSocketBase::SaveState}\label{wxsocketbasesavestate}
+Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually written.
-\func{void}{SaveState}{\void}
+Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded.
-This function saves the current state of the socket object in a stack:
-actually it saves all flags (those set with SetFlags, SetNotify, Notfy)
-and the state of the asynchronous callbacks (Callback, CallbackData).
+\wxheading{Parameters}
-Calls to SaveState / RestoreState can be nested.
+\docparam{buffer}{Buffer with the data to be sent.}
-\wxheading{See also}
+\docparam{nbytes}{Number of bytes.}
-\helpref{wxSocketBase::RestoreState}{wxsocketbaserestorestate}
+\wxheading{Return value}
-%
-% GetLocal
-%
-\membersection{wxSocketBase::GetLocal}{wxsocketbasegetlocal}
+Returns a reference to the current object.
-\constfunc{bool}{GetLocal}{\param{wxSockAddress\& }{addr\_man}}
+\wxheading{Remark/Warning}
-This function returns the local address field of the socket. The local
-address field contains the complete local address of the socket (local
-address, local port, ...).
+The exact behaviour of wxSocketBase::Write depends on the combination
+of flags being used. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}.
-\wxheading{Return value}
+\wxheading{See also}
-It returns TRUE if no errors happened, FALSE otherwise.
+\helpref{wxSocketBase::Error}{wxsocketbaseerror},
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror},
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}
%
-% GetPeer
+% WriteMsg
%
-\membersection{wxSocketBase::GetPeer}{wxsocketbasegetlocal}
-
-\constfunc{bool}{GetPeer}{\param{wxSockAddress\& }{addr\_man}}
-
-This function returns the peer address field of the socket. The peer
-address field contains the complete peer host address of the socket
-(address, port, ...).
-
-\wxheading{Return value}
-
-It returns TRUE if no errors happened, FALSE otherwise.
+\membersection{wxSocketBase::WriteMsg}\label{wxsocketbasewritemsg}
-% ---------------------------------------------------------------------------
-% Socket callbacks
-% ---------------------------------------------------------------------------
-\membersection{wxSocketBase::SetEventHandler}\label{wxsocketbaseseteventhandler}
+\func{wxSocketBase\&}{WriteMsg}{\param{const char *}{ buffer}, \param{wxUint32}{ nbytes}}
-\func{void}{SetEventHandler}{\param{wxEvtHandler\&}{ evt\_hdlr}, \param{int}{ id = -1}}
+This function writes a buffer of {\it nbytes} bytes from the socket, but it
+writes a short header before so that \helpref{ReadMsg}{wxsocketbasereadmsg}
+knows how much data should it actually read. So, a buffer sent with WriteMsg
+{\bf must} be read with ReadMsg. This function always waits for the entire
+buffer to be sent, unless an error occurs.
-Sets an event handler to be called when a socket event occurs. The handler
-will be called for those events for which notification is enabled with
-SetNotify and Notify.
+Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually written.
-You can also specify a C callback to be called when an event occurs. See
-Callback and CallbackData.
+Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded.
\wxheading{Parameters}
-\docparam{evt\_hdlr}{Specifies the event handler you want to use.}
-
-\docparam{id}{The id of socket event.}
-
-\wxheading{See also}
-
-\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
-\helpref{wxSocketBase::Notify}{wxsocketbasenotify},
-\helpref{wxSocketEvent}{wxsocketevent},
-\helpref{wxEvtHandler}{wxevthandler},
-\helpref{wxSocketBase::Callback}{wxsocketbasecallback},
-\helpref{wxSocketBase::CallbackData}{wxsocketbasecallbackdata}
-
-\membersection{wxSocketBase::Callback}\label{wxsocketbasecallback}
-
-\func{wxSocketBase::wxSockCbk}{Callback}{\param{wxSocketBase::wxSockCbk}{ callback}}
-
-You can setup a C callback to be called when an event occurs. The callback
-will be called only for those events for which notification has been enabled
-with Notify and SetNotify. The prototype of the callback must be as follows:
-
-\begin{verbatim}
-void SocketCallback(wxSocketBase& sock,wxSocketNotify evt,char *cdata);
-\end{verbatim}
+\docparam{buffer}{Buffer with the data to be sent.}
-The first parameter is a reference to the socket object in which the event
-occured. The second parameter tells you which event occured. (See \helpref{wxSocket events}{wxsocketbase}).
-The third parameter is the user data you specified using \helpref{CallbackData}{wxsocketbasecallbackdata}.
+\docparam{nbytes}{Number of bytes to send.}
\wxheading{Return value}
-A pointer to the previous callback.
-
-\wxheading{See also}
-
-\helpref{wxSocketBase::CallbackData}{wxsocketbasecallbackdata},
-\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
-\helpref{wxSocketBase::Notify}{wxsocketbasenotify}
-
-\membersection{wxSocketBase::CallbackData}\label{wxsocketbasecallbackdata}
+Returns a reference to the current object.
-\func{char *}{CallbackData}{\param{char *}{cdata}}
+\wxheading{Remark/Warning}
-This function sets the the user data which will be passed to a \helpref{C callback}{wxsocketbasecallback}.
+wxSocketBase::WriteMsg will behave as if the {\bf wxSOCKET\_WAITALL} flag
+was always set and it will always ignore the {\bf wxSOCKET\_NOWAIT} flag.
+The exact behaviour of WriteMsg depends on the {\bf wxSOCKET\_BLOCK} flag.
+For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}.
-\wxheading{Return value}
+\wxheading{See also}
-A pointer to the previous user data.
+\helpref{wxSocketBase::Error}{wxsocketbaseerror},
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror},
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags},
+\helpref{wxSocketBase::ReadMsg}{wxsocketbasereadmsg}
-\helpref{wxSocketBase::Callback}{wxsocketbasecallback},
-\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
-\helpref{wxSocketBase::Notify}{wxsocketbasenotify}
% ---------------------------------------------------------------------------
% CLASS wxSocketClient
% ---------------------------------------------------------------------------
+
\section{\class{wxSocketClient}}\label{wxsocketclient}
\wxheading{Derived from}
\func{}{wxSocketClient}{\param{wxSockFlags}{ flags = wxSocketBase::NONE}}
-Constructs a new wxSocketClient.
+Constructor.
\wxheading{Parameters}
\func{}{\destruct{wxSocketClient}}{\void}
-Destroys a wxSocketClient object.
+Destructor.
%
% Connect
Connects to a server using the specified address.
-If {\it wait} is TRUE, Connect will wait until the connection completes and
-the socket is ready to send or receive data, or until an event occurs.
-
-{\bf Warning !} This will block the GUI.
+If {\it wait} is TRUE, Connect will wait until the connection completes.
+{\bf Warning:} This will block the GUI.
If {\it wait} is FALSE, Connect will try to establish the connection and
return immediately, without blocking the GUI. When used this way, even if
Connect returns FALSE, the connection request can be completed later.
-To detect this, use WaitConnection, or watch "connection" events (for
-succesful establishment) and "lost" events (for connection failure).
+To detect this, use \helpref{WaitOnConnect}{wxsocketclientwaitonconnect},
+or catch {\bf wxSOCKET\_CONNECTION} events (for successful establishment)
+and {\bf wxSOCKET\_LOST} events (for connection failure).
\wxheading{Parameters}
\docparam{address}{Address of the server.}
-\docparam{wait}{If true, waits for the connection to be ready.}
+\docparam{wait}{If TRUE, waits for the connection to complete.}
\wxheading{Return value}
If {\it wait} was FALSE, and Connect returns FALSE, you should still
be prepared to handle the completion of this connection request, either
-with WaitOnConnect or by watching "connection" and "lost" events.
+with \helpref{WaitOnConnect}{wxsocketclientwaitonconnect} or by watching
+{\bf wxSOCKET\_CONNECTION} and {\bf wxSOCKET\_LOST} events.
\wxheading{See also}
\func{bool}{WaitOnConnect}{\param{long}{ seconds = -1}, \param{long}{ milliseconds = 0}}
-Wait until the connection is succesfully established or until it fails.
-Use this function after a call to Connect with {\it wait} set to FALSE.
+Wait until a connection request completes, or until the specified timeout
+elapses. Use this function after issuing a call to \helpref{Connect}{wxsocketclientconnect}
+with {\it wait} set to FALSE.
\wxheading{Parameters}
-\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
+\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}
-If the connection is succesfully established, it returns TRUE.
+If the connection is succesfully established, returns TRUE.
-If the timeout expires, or if the connection fails, it returns FALSE.
+If the timeout expires, or if the connection fails, returns FALSE.
+To distinguish between these two conditions, use \helpref{IsConnected}{wxsocketbaseisconnected}
\wxheading{See also}
-\helpref{wxSocketClient::Connect}{wxsocketclientconnect}
+\helpref{wxSocketClient::Connect}{wxsocketclientconnect},
+\helpref{wxSocketBase::IsConnected}{wxsocketbaseisconnected}
% ---------------------------------------------------------------------------
% CLASS: wxSocketEvent
\twocolwidtha{7cm}
\begin{twocollist}\itemsep=0pt
\twocolitem{{\bf EVT\_SOCKET(id, func)}}{Process a socket event, supplying the member function.}
-\end{twocollist}%
-
-[TODO:]
-A brief note on how to use events.
-The wxSOCKET\_INPUT event is generated when the
+\end{twocollist}
\wxheading{See also}
Constructor.
+\membersection{wxSocketEvent::Socket}\label{wxsocketeventsocket}
+
+\constfunc{wxSocketBase *}{Socket}{\void}
+
+Returns the socket object to which this event refers to. This makes
+it possible to use the same event handler for different sockets.
+
\membersection{wxSocketEvent::SocketEvent}\label{wxsocketeventsocketevent}
\constfunc{wxSocketNotify}{SocketEvent}{\void}
\func{}{wxSocketServer}{\param{wxSockAddress\&}{ address}, \param{wxSockFlags}{ flags = wxSocketBase::NONE}}
-Constructs a new wxSocketServer.
+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}
\func{}{\destruct{wxSocketServer}}{\void}
-Destroys a wxSocketServer object (it doesn't close the accepted connections).
+Destructor (it doesn't close the accepted connections).
%
% Accept
\func{wxSocketBase *}{Accept}{\param{bool}{ wait = TRUE}}
-Creates a new object wxSocketBase and accepts an incoming connection.
+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.
+{\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 WaitForAccept or watch
-"connection" events, then call Accept once you know that there is
-an incoming connection waiting to be accepted.
+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}
\func{bool}{AcceptWith}{\param{wxSocketBase\&}{ socket}, \param{bool}{ wait = TRUE}}
Accept an incoming connection using the specified socket object.
-This is useful when someone wants to inherit wxSocketBase.
\wxheading{Parameters}
\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept},
\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
\helpref{wxSocketBase::Notify}{wxsocketbasenotify},
-\helpref{wxSocketServer::Accept}{wxsocketserveraccept}
+\helpref{wxSocketServer::Accept}{wxsocketserveraccept} for a detailed explanation
%
% WaitForAccept
\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
-Accept or AcceptWith with {\it wait} set to FALSE, to detect when an incoming
-connection is waiting to be accepted.
+\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 set with SetTimeout.}
+\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 expired.
+Returns TRUE if an incoming connection arrived, FALSE if the timeout elapsed.
\wxheading{See also}