X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/b80dc5febe0017218e62726b52e32ee418eaa7e3..7f24fdbfeae21875fe73f5aa69aede354baed29b:/docs/latex/wx/socket.tex

diff --git a/docs/latex/wx/socket.tex b/docs/latex/wx/socket.tex
index 18c8ddc249..bcc46c9218 100644
--- a/docs/latex/wx/socket.tex
+++ b/docs/latex/wx/socket.tex
@@ -4,16 +4,65 @@
 
 \helpref{wxEvtHandler}{wxevthandler}
 
+\wxheading{Include files}
+
+<wx/socket.h>
+
+\wxheading{wxSocket errors}
+
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxSOCKET\_NOERROR}}{No error happened.}
+\twocolitem{{\bf wxSOCKET\_INVOP}}{Invalid operation.}
+\twocolitem{{\bf wxSOCKET\_IOERR}}{Input/Output error.}
+\twocolitem{{\bf wxSOCKET\_INVADDR}}{Invalid address passed to wxSocket.}
+\twocolitem{{\bf wxSOCKET\_INVSOCK}}{Invalid socket (uninitialized).}
+\twocolitem{{\bf wxSOCKET\_NOHOST}}{No corresponding host.}
+\twocolitem{{\bf wxSOCKET\_INVPORT}}{Invalid port.}
+\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}%
+
+\wxheading{wxSocket events}
+
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxSOCKET\_INPUT}}{Some data has arrived to the socket.}
+\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\_LOST}}{The connection has been closed.}
+\twocolitem{{\bf wxSOCKET\_MAX\_EVENT}}{This should never happen but the compiler may complain about it.}
+\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\_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.
+
 % ---------------------------------------------------------------------------
 % 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.
+input to member functions that take a \helpref{wxSocketEvent}{wxsocketevent} argument.
 
-\twocolwidtha{7cm}
+\twocolwidtha{7cm}%
 \begin{twocollist}\itemsep=0pt
 \twocolitem{{\bf EVT\_SOCKET(id, func)}}{A socket event occured.}
 \end{twocollist}%
@@ -21,23 +70,22 @@ functions that take a \helpref{wxSocketEvent}{wxsocketevent} argument.
 % ---------------------------------------------------------------------------
 % See also ...
 % ---------------------------------------------------------------------------
-
 \wxheading{See also}
 
-\helpref{wxSocketEvent}{wxsocketevent}
-\helpref{wxSocketClient}{wxsocketclient}
+\helpref{wxSocketEvent}{wxsocketevent}, 
+\helpref{wxSocketClient}{wxsocketclient}, 
 \helpref{wxSocketServer}{wxsocketserver}
 
 % ---------------------------------------------------------------------------
 % Members
 % ---------------------------------------------------------------------------
-
 \latexignore{\rtfignore{\wxheading{Members}}}
 
 \membersection{wxSocketBase::wxSocketBase}
+
 \func{}{wxSocketBase}{\void}
 
-Default constructor but don't use it, you must use \helpref{wxSocketClient}{wxsocketclient}
+Default constructor. Don't use it; use \helpref{wxSocketClient}{wxsocketclient} 
 or \helpref{wxSocketServer}{wxsocketserver}.
 
 \membersection{wxSocketBase::\destruct{wxSocketBase}}
@@ -50,6 +98,119 @@ Destroys the wxSocketBase object.
 % State functions
 % ---------------------------------------------------------------------------
 
+%
+% SetFlags
+%
+
+\membersection{wxSocketBase::SetFlags}\label{wxsocketbasesetflags}
+
+\func{void}{SetFlags}{\param{wxSocketBase::wxSockFlags}{ flags}}
+
+\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}
+
+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
+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 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
+"blocking" here refers to when the function returns, not to whether
+the GUI blocks during this time.
+
+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. 
+
+So:
+
+{\bf wxSOCKET\_NONE} will try to read 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 control whether the GUI blocks.
+
+%
+% SetNotify
+%
+\membersection{wxSocketBase::SetNotify}\label{wxsocketbasesetnotify}
+
+\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:
+
+\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);
+\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}{wxsocketbasesettimeout}
+
+\func{void}{SetTimeout}{\param{int }{seconds}}
+
+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.
+
+%
+% Notify
+%
+\membersection{wxSocketBase::Notify}\label{wxsocketbasenotify}
+
+\func{void}{Notify}{\param{bool}{ notify}}
+
+Notify will enable (notify is TRUE) or disable (notify is FALSE) the propagation
+of socket events.
+
+% 
+% Ok
+%
+
 \membersection{wxSocketBase::Ok}\label{wxsocketbaseok}
 
 \constfunc{bool}{Ok}{\void}
@@ -61,7 +222,10 @@ cases.
 
 \constfunc{bool}{Error}{\void}
 
-Returns TRUE if an error occured.
+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.
 
 \membersection{wxSocketBase::IsConnected}\label{wxsocketbaseconnected}
 
@@ -69,11 +233,11 @@ Returns TRUE if an error occured.
 
 Returns TRUE if the socket is connected.
 
-\membersection{wxSocketBase::IsData}\label{wxsocketbaseerror}
+\membersection{wxSocketBase::IsData}\label{wxsocketbaseisdata}
 
 \constfunc{bool}{IsData}{\void}
 
-Returns TRUE if some data is arrived on the socket. 
+Returns TRUE if there is data available to be read. 
 
 \membersection{wxSocketBase::IsDisconnected}\label{wxsocketbasedisconnected}
 
@@ -89,354 +253,524 @@ Returns TRUE if the socket mustn't wait.
 
 \membersection{wxSocketBase::LastCount}\label{wxsocketbaselastcount}
 
-\constfunc{size\_t}{LastCount}{\void}
+\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.
+
 \membersection{wxSocketBase::LastError}\label{wxsocketbaselasterror}
 
-\constfunc{int}{LastError}{\void}
+\constfunc{wxSocketError}{LastError}{\void}
 
-Returns an error in the errno format (see your C programmer's guide).
+Returns the last wxSocket error. See \helpref{wxSocket errors}{wxsocketbase}.
+
+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.
 
 % ---------------------------------------------------------------------------
 % IO calls
 % ---------------------------------------------------------------------------
-
 %
 % Peek
 %
-
 \membersection{wxSocketBase::Peek}\label{wxsocketbasepeek}
 
-\func{wxSocketBase\&}{Peek}{\param{char *}{ buffer}, \param{size\_t}{ nbytes}}
+\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 system socket in-queue.
 
+Use LastCount to verify the number of bytes actually peeked.
+
+Use Error to determine if the operation succeeded.
+
 \wxheading{Parameters}
 
 \docparam{buffer}{Buffer where to put peeked data.}
+
 \docparam{nbytes}{Number of bytes.}
 
-\wxheading{Returns value}
+\wxheading{Return value}
+
 Returns a reference to the current object.
 
+\wxheading{Remark/Warning}
+
+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::Error}{wxsocketbaserror},
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
+\helpref{wxSocketBase::Error}{wxsocketbaseerror}, 
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, 
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, 
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}
 
 %
 % Read
 %
-
 \membersection{wxSocketBase::Read}\label{wxsocketbaseread}
 
-\func{wxSocketBase\&}{Read}{\param{char *}{ buffer}, \param{size\_t}{ nbytes}}
+\func{wxSocketBase\&}{Read}{\param{char *}{ buffer}, \param{wxUint32}{ nbytes}}
 
 This function reads a buffer of {\it nbytes} bytes from the socket.
 
+Use LastCount to verify the number of bytes actually read.
+
+Use Error to determine if the operation succeeded.
+
 \wxheading{Parameters}
 
 \docparam{buffer}{Buffer where to put read data.}
+
 \docparam{nbytes}{Number of bytes.}
 
-\wxheading{Returns value}
+\wxheading{Return value}
+
 Returns a reference to the current object.
 
+\wxheading{Remark/Warning}
+
+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}{wxsocketbaserror},
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
- 
+\helpref{wxSocketBase::Error}{wxsocketbaseerror}, 
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, 
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, 
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}
+
 %
-% Read
+% Write
 %
-
 \membersection{wxSocketBase::Write}\label{wxsocketbasewrite}
 
-\func{wxSocketBase\&}{Write}{\param{const char *}{ buffer}, \param{size\_t}{ nbytes}}
+\func{wxSocketBase\&}{Write}{\param{const char *}{ buffer}, \param{wxUint32}{ nbytes}}
+
+This function writes a buffer of {\it nbytes} bytes to the socket.
 
-This function writes a buffer of {\it nbytes} bytes from the socket.
+Use LastCount to verify the number of bytes actually written.
+
+Use Error to determine if the operation succeeded.
 
 \wxheading{Parameters}
 
-\docparam{buffer}{Buffer where to get the data to write.}
+\docparam{buffer}{Buffer with the data to be sent.}
+
 \docparam{nbytes}{Number of bytes.}
 
-\wxheading{Returns value}
+\wxheading{Return value}
+
 Returns a reference to the current object.
 
+\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}.
+
 \wxheading{See also}
 
-\helpref{wxSocketBase::Error}{wxsocketbaserror},
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
+\helpref{wxSocketBase::Error}{wxsocketbaseerror}, 
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, 
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, 
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}
 
 %
 % WriteMsg
 %
-
 \membersection{wxSocketBase::WriteMsg}\label{wxsocketbasewritemsg}
 
-\func{wxSocketBase\&}{WriteMsg}{\param{const char *}{ buffer}, \param{size\_t}{ nbytes}}
+\func{wxSocketBase\&}{WriteMsg}{\param{const char *}{ buffer}, \param{wxUint32}{ nbytes}}
 
-This function writes a buffer of {\it nbytes} bytes from the socket. But it
+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.
+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.
+
+Use LastCount to verify the number of bytes actually written.
+
+Use Error to determine if the operation succeeded.
 
 \wxheading{Parameters}
 
-\docparam{buffer}{Buffer where to put data peeked.}
+\docparam{buffer}{Buffer with the data to be sent.}
+
 \docparam{nbytes}{Number of bytes.}
 
-\wxheading{Returns value}
+\wxheading{Return value}
+
 Returns a reference to the current object.
 
+\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}.
+
 \wxheading{See also}
 
-\helpref{wxSocketBase::Error}{wxsocketbaserror},
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror},
+\helpref{wxSocketBase::Error}{wxsocketbaseerror}, 
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, 
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, 
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}, 
 \helpref{wxSocketBase::ReadMsg}{wxsocketbasereadmsg}
 
 %
 % ReadMsg
 %
-
 \membersection{wxSocketBase::ReadMsg}\label{wxsocketbasereadmsg}
 
-\func{wxSocketBase\&}{ReadMsg}{\param{char *}{ buffer}, \param{size\_t}{ nbytes}}
+\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 function filled it and then discard the
-bytes left. This function always wait for the buffer to be entirely filled.
+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 Error 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.}
 
-\wxheading{Returns value}
+\wxheading{Return value}
+
 Returns a reference to the current object.
 
+\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}.
+
 \wxheading{See also}
 
-\helpref{wxSocketBase::Error}{wxsocketbaserror},
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror},
+\helpref{wxSocketBase::Error}{wxsocketbaseerror}, 
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, 
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, 
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}, 
 \helpref{wxSocketBase::WriteMsg}{wxsocketbasewritemsg}
 
 %
 % Unread
 %
+\membersection{wxSocketBase::Unread}\label{wxsocketbaseunread}
 
-\membersection{wxSocketBase::UnRead}\label{wxsocketbaseunread}
+\func{wxSocketBase\&}{Unread}{\param{const char *}{ buffer}, \param{wxUint32}{ nbytes}}
 
-\func{wxSocketBase\&}{UnRead}{\param{const char *}{ buffer}, \param{size\_t}{ nbytes}}
+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.
 
-This function unreads a buffer. It means that the buffer is put in the top
-of the incoming queue. But, it is put also at the end of all unread buffers.
-It is useful for sockets because we can't seek it.
+If you use LastCount, it will always return {\it nbytes}.
+
+If you use Error, it will always return FALSE.
 
 \wxheading{Parameters}
 
 \docparam{buffer}{Buffer to be unread.}
+
 \docparam{nbytes}{Number of bytes.}
 
-\wxheading{Returns value}
+\wxheading{Return value}
+
 Returns a reference to the current object.
 
 \wxheading{See also}
 
-\helpref{wxSocketBase::Error}{wxsocketbaserror},
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
+\helpref{wxSocketBase::Error}{wxsocketbaseerror}, 
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, 
 \helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
 
 %
 % Discard
 %
-
 \membersection{wxSocketBase::Discard}\label{wxsocketbasediscard}
 
 \func{wxSocketBase\&}{Discard}{\void}
 
 This function simply deletes all bytes in the incoming queue. This function
-doesn't wait.
+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}{ microsecond = 0}}
 
-This function waits for an event: it could be an incoming byte, the possibility
-for the client to write, a lost connection, an incoming connection, an
-established connection.
+\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).
 
 \wxheading{Parameters}
 
-\docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
-\docparam{microsecond}{Number of microseconds to wait.}
+\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
 
-\wxheading{Return value:}
+\docparam{millisecond}{Number of milliseconds to wait.}
+
+\wxheading{Return value}
 
 Returns TRUE if an event occured, FALSE if the timeout was reached.
 
 \wxheading{See also}
 
-\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread},
-\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite},
+\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}, 
+\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}, 
 \helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
 
 %
 % WaitForRead
 %
-
 \membersection{wxSocketBase::WaitForRead}\label{wxsocketbasewaitforread}
-\func{bool}{WaitForRead}{\param{long}{ seconds = -1}, \param{long}{ microsecond = 0}}
 
-This function waits for a read event.
+\func{bool}{WaitForRead}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}}
+
+This function waits until there is data available to be read.
 
 \wxheading{Parameters}
 
-\docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
-\docparam{microsecond}{Number of microseconds to wait.}
+\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
 
-\wxheading{Return value:}
+\docparam{millisecond}{Number of milliseconds to wait.}
 
-Returns TRUE if a byte arrived, FALSE if the timeout was reached.
+\wxheading{Return value}
+
+Returns TRUE if there is data to be read, FALSE if the timeout was reached.
 
 \wxheading{See also}
 
-\helpref{wxSocketBase::Wait}{wxsocketbasewait},
-\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite},
+\helpref{wxSocketBase::Wait}{wxsocketbasewait}, 
+\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}, 
 \helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
 
 %
 % WaitForWrite
 %
-
 \membersection{wxSocketBase::WaitForWrite}\label{wxsocketbasewaitforwrite}
-\func{bool}{WaitForWrite}{\param{long}{ seconds = -1}, \param{long}{ microsecond = 0}}
 
-This function waits for a write event.
+\func{bool}{WaitForWrite}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}}
+
+This function waits until you can write to the socket.
 
 \wxheading{Parameters}
 
-\docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
-\docparam{microsecond}{Number of microseconds to wait.}
+\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
+
+\docparam{millisecond}{Number of milliseconds to wait.}
 
-\wxheading{Return value:}
+\wxheading{Return value}
 
-Returns TRUE if a write event occured, FALSE if the timeout was reached.
+Returns TRUE if you can write to the socket, FALSE if the timeout was reached.
 
 \wxheading{See also}
 
-\helpref{wxSocketBase::Wait}{wxsocketbasewait},
-\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread},
+\helpref{wxSocketBase::Wait}{wxsocketbasewait}, 
+\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}, 
 \helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
 
 %
 % WaitForLost
 %
-
 \membersection{wxSocketBase::WaitForLost}\label{wxsocketbasewaitforlost}
-\func{bool}{Wait}{\param{long}{ seconds = -1}, \param{long}{ microsecond = 0}}
 
-This function waits for a "lost" event. For instance, the peer may have closed
-the connection, or the connection may have been broken.
+\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.
 
 \wxheading{Parameters}
 
-\docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
-\docparam{microsecond}{Number of microseconds to wait.}
+\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
+
+\docparam{millisecond}{Number of milliseconds to wait.}
 
-\wxheading{Return value:}
+\wxheading{Return value}
 
-Returns TRUE if a "lost" event occured, FALSE if the timeout was reached.
+Returns TRUE if the connection was lost, FALSE if the timeout was reached.
 
 \wxheading{See also}
 
-\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread},
-\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite},
+\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}, 
+\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}, 
 \helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
 
 % ---------------------------------------------------------------------------
 % Socket state
 % ---------------------------------------------------------------------------
 
+%
+% RestoreState
+%
+\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.
+
+\wxheading{See also}
+
+\helpref{wxSocketBase::SaveState}{wxsocketbasesavestate}
+
 %
 % SaveState
 %
 \membersection{wxSocketBase::SaveState}\label{wxsocketbasesavestate}
+
 \func{void}{SaveState}{\void}
 
 This function saves the current state of the socket object in a stack:
-actually it saves all flags and the state of the asynchronous callbacks. 
+actually it saves all flags (those set with SetFlags, SetNotify, Notfy)
+and the state of the asynchronous callbacks (Callback, CallbackData).
+
+Calls to SaveState / RestoreState can be nested.
 
 \wxheading{See also}
 
 \helpref{wxSocketBase::RestoreState}{wxsocketbaserestorestate}
 
 %
-% RestoreState
+% GetLocal
 %
+\membersection{wxSocketBase::GetLocal}{wxsocketbasegetlocal}
 
-\membersection{wxSocketBase::RestoreState}\label{wxsocketbaserestorestate}
+\constfunc{bool}{GetLocal}{\param{wxSockAddress\& }{addr_man}}
 
-\func{void}{RestoreState}{\void}
+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, ...).
 
-This function restores a previously saved state.
+\wxheading{Return value}
 
-\wxheading{See also}
+It returns TRUE if no errors happened, FALSE otherwise.
 
-\helpref{wxSocketBase::SaveState}{wxsocketbasesavestate}
+%
+% GetPeer
+%
+\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.
 
 % ---------------------------------------------------------------------------
 % Socket callbacks
 % ---------------------------------------------------------------------------
+\membersection{wxSocketBase::SetEventHandler}\label{wxsocketbaseseteventhandler}
 
-\membersection{wxSocketBase::SetEventHandler}{wxsocketbaseseteventhandler}
 \func{void}{SetEventHandler}{\param{wxEvtHandler\&}{ evt\_hdlr}, \param{int}{ id = -1}}
 
-Sets an event handler to be called when a socket event occured.
+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.
+
+You can also specify a C callback to be called when an event occurs. See
+Callback and CallbackData.
 
 \wxheading{Parameters}
 
 \docparam{evt\_hdlr}{Specifies the event handler you want to use.}
+
 \docparam{id}{The id of socket event.}
 
 \wxheading{See also}
 
-\helpref{wxSocketEvent}{wxsocketevent}
+\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}
+
+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}.
+
+\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}
+
+\func{char *}{CallbackData}{\param{char *}{cdata}}
+
+This function sets the the user data which will be passed to a \helpref{C callback}{wxsocketbasecallback}.
+
+\wxheading{Return value}
+
+A pointer to the previous user data.
+
+\helpref{wxSocketBase::Callback}{wxsocketbasecallback}, 
+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}, 
+\helpref{wxSocketBase::Notify}{wxsocketbasenotify}
 
 % ---------------------------------------------------------------------------
 % CLASS wxSocketClient
 % ---------------------------------------------------------------------------
-
 \section{\class{wxSocketClient}}\label{wxsocketclient}
 
 \wxheading{Derived from}
 
 \helpref{wxSocketBase}{wxsocketbase}
 
+\wxheading{Include files}
+
+<wx/socket.h>
+
 % ---------------------------------------------------------------------------
 % Members
 % ---------------------------------------------------------------------------
-
 %
 % wxSocketClient
 %
-
 \membersection{wxSocketClient::wxSocketClient}
+
 \func{}{wxSocketClient}{\param{wxSockFlags}{ flags = wxSocketBase::NONE}}
 
 Constructs a new wxSocketClient.
-{\bf Warning !} The created needs to be registered to a socket handler (See \helpref{wxSocketHandler}{wxsockethandler}).
 
 \wxheading{Parameters}
 
@@ -445,267 +779,253 @@ Constructs a new wxSocketClient.
 %
 % ~wxSocketClient
 %
-
 \membersection{wxSocketClient::\destruct{wxSocketClient}}
+
 \func{}{\destruct{wxSocketClient}}{\void}
 
-Destructs a wxSocketClient object.
+Destroys a wxSocketClient object.
 
 %
 % Connect
 %
+\membersection{wxSocketClient::Connect}\label{wxsocketclientconnect}
 
-\membersection{wxSocketClient::Connect}{wxsocketclientconnect}
 \func{bool}{Connect}{\param{wxSockAddress\&}{ address}, \param{bool}{ wait = TRUE}}
 
-Connects to a server using the specified address. If {\it wait} is TRUE, Connect
-will wait for the socket ready to send or receive data.
+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 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).
 
 \wxheading{Parameters}
 
 \docparam{address}{Address of the server.}
+
 \docparam{wait}{If true, waits for the connection to be ready.}
 
 \wxheading{Return value}
 
 Returns TRUE if the connection is established and no error occurs.
 
+If {\it wait} was TRUE, and Connect returns FALSE, an error occured
+and the connection failed.
+
+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.
+
 \wxheading{See also}
 
-\helpref{wxSocketClient::WaitOnConnect}{wxsocketclientwaitonconnect}
+\helpref{wxSocketClient::WaitOnConnect}{wxsocketclientwaitonconnect}, 
+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}, 
+\helpref{wxSocketBase::Notify}{wxsocketbasenotify}
 
 %
 % WaitOnConnect
 %
+\membersection{wxSocketClient::WaitOnConnect}\label{wxsocketclientwaitonconnect}
 
-\membersection{wxSocketClient::WaitOnConnect}
-\func{bool}{WaitOnConnect}{\param{long}{ seconds = -1}, \param{long}{ microseconds = 0}}
+\func{bool}{WaitOnConnect}{\param{long}{ seconds = -1}, \param{long}{ milliseconds = 0}}
 
-Wait for a "connect" event.
+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. 
 
-\wxheading{See also}
-
-\helpref{wxSocketBase::Wait}{wxsocketbasewait} for a detailed description.
-
-% ---------------------------------------------------------------------------
-% CLASS: wxSocketServer
-% ---------------------------------------------------------------------------
+\wxheading{Parameters}
 
-\section{\class{wxSocketServer}}\label{wxsocketserver}
+\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
 
-\wxheading{Derived from}
+\docparam{millisecond}{Number of milliseconds to wait.}
 
-\helpref{wxSocketBase}{wxsocketbase}
+\wxheading{Return value}
 
-% ---------------------------------------------------------------------------
-% Members
-% ---------------------------------------------------------------------------
+If the connection is succesfully established, it returns TRUE.
 
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-%
-% wxSocketServer
-%
+If the timeout expires, or if the connection fails, it returns FALSE.
 
-\membersection{wxSocketServer::wxSocketServer}{wxsocketserverconstr}
-\func{}{wxSocketServer}{\param{wxSockAddress\&}{ address}, \param{wxSockFlags}{ flags = wxSocketBase::NONE}}
+\wxheading{See also}
 
-Constructs a new wxSocketServer.
-{\bf Warning !} The created object needs to be registered to a socket handler
-(See \helpref{wxSocketHandler}{wxsockethandler}).
+\helpref{wxSocketClient::Connect}{wxsocketclientconnect}
 
-\wxheading{Parameters}
+% ---------------------------------------------------------------------------
+% CLASS: wxSocketEvent
+% ---------------------------------------------------------------------------
+\section{\class{wxSocketEvent}}\label{wxsocketevent}
 
-\docparam{address}{Specifies the local address for the server (e.g. port number).}
-\docparam{flags}{Socket flags (See \helpref{wxSocketBase::SetFlags}{wxsocketbase
-setflags})}
+This event class contains information about socket events.
 
-%
-% ~wxSocketServer
-%
+\wxheading{Derived from}
 
-\membersection{wxSocketServer::\destruct{wxSocketServer}}
-\func{}{\destruct{wxSocketServer}}{\void}
+\helpref{wxEvent}{wxevent}
 
-Destructs a wxSocketServer object (it doesn't close the accepted connection).
+\wxheading{Include files}
 
-%
-% Accept
-%
+<wx/socket.h>
 
-\membersection{wxSocketServer::Accept}
-\func{wxSocketBase *}{Accept}{\void}
+\wxheading{Event table macros}
 
-Creates a new object wxSocketBase and accepts an incoming connection. {\bf Warning !} This function will block the GUI.
+To process a socket event, use these event handler macros to direct input to member
+functions that take a wxSocketEvent argument.
 
-\wxheading{Return value}
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_SOCKET(id, func)}}{Process a socket event, supplying the member function.}
+\end{twocollist}%
 
-Returns an opened socket connection.
+[TODO:]
+A brief note on how to use events.
+The wxSOCKET_INPUT event is generated when the
 
 \wxheading{See also}
 
-\helpref{wxSocketServer::AcceptWith}{wxsocketserveracceptwith}
-
-%
-% AcceptWith
-%
+\helpref{wxSocketBase}{wxsocketbase}, 
+\helpref{wxSocketClient}{wxsocketclient}, 
+\helpref{wxSocketServer}{wxsocketserver}
 
-\membersection{wxSocketServer::AcceptWith}{wxsocketserveracceptwith}
-\func{bool}{AcceptWith}{\param{wxSocketBase\&}{ socket}}
+\latexignore{\rtfignore{\wxheading{Members}}}
 
-Accept an incoming connection using the specified socket object.
-This is useful when someone wants to inherit wxSocketBase.
+\membersection{wxSocketEvent::wxSocketEvent}
 
-\wxheading{Parameters}
+\func{}{wxSocketEvent}{\param{int}{ id = 0}}
 
-\docparam{socket}{Socket to be initialized}
+Constructor.
 
-\wxheading{Return value}
+\membersection{wxSocketEvent::SocketEvent}\label{wxsocketeventsocketevent}
 
-Returns TRUE if no error occurs, else FALSE.
+\constfunc{wxSocketNotify}{SocketEvent}{\void}
 
+Returns the socket event type.
 
 % ---------------------------------------------------------------------------
-% CLASS: wxSocketHandler
+% CLASS: wxSocketServer
 % ---------------------------------------------------------------------------
-
-\section{\class{wxSocketHandler}}\label{wxsockethandler}
+\section{\class{wxSocketServer}}\label{wxsocketserver}
 
 \wxheading{Derived from}
 
-\helpref{wxObject}{wxobject}
+\helpref{wxSocketBase}{wxsocketbase}
+
+\wxheading{Include files}
+
+<wx/socket.h>
 
 % ---------------------------------------------------------------------------
 % Members
 % ---------------------------------------------------------------------------
-
 \latexignore{\rtfignore{\wxheading{Members}}}
 
 %
-% wxSocketHandler
-%
-\membersection{wxSocketHandler::wxSocketHandler}
-\func{}{wxSocketHandler}{\void}
-
-Constructs a new wxSocketHandler.
-It is advised to use \helpref{wxSocketHandler::Master}{wxsockethandlermaster}
-to get a socket handler. But creating a socket handler is useful to group
-many sockets.
-
-%
-% ~wxSocketHandler
-%
-
-\membersection{wxSocketHandler::\destruct{wxSocketHandler}}
-\func{}{\destruct{wxSocketHandler}}{\void}
-
-Destructs a wxSocketHandler object.
-
-%
-% Register
+% wxSocketServer
 %
+\membersection{wxSocketServer::wxSocketServer}\label{wxsocketserverconstr}
 
-\membersection{wxSocketHandler::Register}
-\func{void}{Register}{\param{wxSocketBase *}{socket}}
+\func{}{wxSocketServer}{\param{wxSockAddress\&}{ address}, \param{wxSockFlags}{ flags = wxSocketBase::NONE}}
 
-Register a socket: if it is already registered in this handler it will just
-return immediately.
+Constructs a new wxSocketServer.
 
 \wxheading{Parameters}
 
-\docparam{socket}{Socket to be registered.}
+\docparam{address}{Specifies the local address for the server (e.g. port number).}
+
+\docparam{flags}{Socket flags (See \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags})}
 
 %
-% UnRegister
+% ~wxSocketServer
 %
+\membersection{wxSocketServer::\destruct{wxSocketServer}}
 
-\membersection{wxSocketHandler::UnRegister}
-\func{void}{UnRegister}{\param{wxSocketBase *}{socket}}
-
-UnRegister a socket: if it isn't registered in this handler it will just
-return.
-
-\wxheading{Parameters}
+\func{}{\destruct{wxSocketServer}}{\void}
 
-\docparam{socket}{Socket to be unregistered.}
+Destroys a wxSocketServer object (it doesn't close the accepted connections).
 
 %
-% Count
+% Accept
 %
+\membersection{wxSocketServer::Accept}\label{wxsocketserveraccept}
 
-\membersection{wxSocketHandler::Count}
-\constfunc{unsigned long}{Count}{\void}
+\func{wxSocketBase *}{Accept}{\param{bool}{ wait = TRUE}}
 
-Returns the number of sockets registered in the handler.
+Creates a new object wxSocketBase and accepts an incoming connection.
 
-\wxheading{Return value}
+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.
 
-Number of sockets registered.
+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.
 
-%
-% CreateServer
-%
-
-\membersection{wxSocketHandler::CreateServer}
-\func{wxSocketServer *}{CreateServer}{\param{wxSockAddress\&}{ address}, \param{wxSocketBase::wxSockFlags}{ flags = wxSocketbase::NONE}}
+\wxheading{Return value}
 
-Creates a new wxSocketServer object. The object is automatically registered
-to the current socket handler.
-For a detailed description of the parameters, see \helpref{wxSocketServer::wxSocketServer}{wxsocketserverconstr}.
+Returns an opened socket connection, or NULL if an error occured or
+if the {\it wait} parameter was FALSE and there were no pending
+connections.
 
-\wxheading{Return value}
+\wxheading{See also}
 
-Returns a new socket server.
+\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept}, 
+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}, 
+\helpref{wxSocketBase::Notify}{wxsocketbasenotify}, 
+\helpref{wxSocketServer::AcceptWith}{wxsocketserveracceptwith}
 
 %
-% CreateClient
+% AcceptWith
 %
+\membersection{wxSocketServer::AcceptWith}\label{wxsocketserveracceptwith}
 
-\membersection{wxSocketHandler::CreateClient}
-\func{wxSocketServer *}{CreateClient}{\param{wxSocketBase::wxSockFlags}{ flags = wxSocketbase::NONE}}
+\func{bool}{AcceptWith}{\param{wxSocketBase\&}{ socket}, \param{bool}{ wait = TRUE}}
 
-Creates a new wxSocketClient object. The object is automatically registered
-to the current socket handler.
-For a detailed description of the parameters, see \helpref{wxSocketClient::Connect}{wxsocketclientconnect}.
+Accept an incoming connection using the specified socket object.
+This is useful when someone wants to inherit wxSocketBase.
 
-\wxheading{Return value}
+\wxheading{Parameters}
 
-Returns a new socket client.
+\docparam{socket}{Socket to be initialized}
 
-%
-% Master
-%
+\wxheading{Return value}
 
-\membersection{wxSocketHandler::Master}
-\func{static wxSocketHandler\&}{Master}{\void}
+Returns TRUE on success, or FALSE if an error occured or if the
+{\it wait} parameter was FALSE and there were no pending
+connections.
 
-Returns a default socket handler.
+\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept}, 
+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}, 
+\helpref{wxSocketBase::Notify}{wxsocketbasenotify}, 
+\helpref{wxSocketServer::Accept}{wxsocketserveraccept}
 
 %
-% Wait
+% WaitForAccept
 %
-\membersection{wxSocketHandler::Wait}
-\func{int}{Wait}{\param{long}{ seconds},\param{long}{ microseconds}}
+\membersection{wxSocketServer::WaitForAccept}\label{wxsocketserverwaitforaccept}
 
-Wait for an event on all registered sockets.
+\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.
 
 \wxheading{Parameters}
 
-\docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
-\docparam{microsecond}{Number of microseconds to wait.}
+\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
+
+\docparam{millisecond}{Number of milliseconds to wait.}
 
 \wxheading{Return value}
 
-Returns 0 if a timeout occured, else the number of events detected.
+Returns TRUE if an incoming connection arrived, FALSE if the timeout expired.
 
 \wxheading{See also}
 
-\helpref{wxSocketBase::Wait}{wxsockebasewait}
-
-%
-% YieldSock
-%
-\membersection{wxSocketHandler::YieldSock}
-\func{void}{YieldSock}{\void}
+\helpref{wxSocketServer::Accept}{wxsocketserveraccept}, 
+\helpref{wxSocketServer::AcceptWith}{wxsocketserveracceptwith}
 
-Execute pending requests in all registered sockets.
