cvs debugging

[wxWidgets.git] / docs / latex / wx / socket.tex

diff --git a/docs/latex/wx/socket.tex b/docs/latex/wx/socket.tex
index b2800c1fbe700ae4f439fd34a211a8a7302ffd38..26fb37c2d3ccdd4bb279121d57d3f5fc62e3827d 100644 (file)
--- a/docs/latex/wx/socket.tex
+++ b/docs/latex/wx/socket.tex
@@ -4,6 +4,36 @@
 
 \helpref{wxEvtHandler}{wxevthandler}
 
 
 \helpref{wxEvtHandler}{wxevthandler}
 

+\wxheading{Include files}
+
+<wx/socket.h>
+
+\wxheading{wxSocket errors}%\label{wxsocketerrs} % Labels don't work on a non-section!
+
+\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\_TRYAGAIN}}{The IO call has a timeout or is in non-blocking mode.}
+\twocolitem{{\bf wxSOCKET\_MEMERR}}{Memory exhausted.}
+\end{twocollist}%
+
+\wxheading{wxSocket events}
+
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxSOCKET\_INPUT}}{Some data are ready to be got.}
+\twocolitem{{\bf wxSOCKET\_OUTPUT}}{The socket is ready to be written to.}
+\twocolitem{{\bf wxSOCKET\_CONNECTION}}{Someone want to connect our server.}
+\twocolitem{{\bf wxSOCKET\_LOST}}{The connection has been broken.}
+\twocolitem{{\bf wxSOCKET\_MAX\_EVENT}}{This should never happen but the compiler may complain about it.}
+\end{twocollist}%
+

 % ---------------------------------------------------------------------------
 % Event handling
 % ---------------------------------------------------------------------------
 % ---------------------------------------------------------------------------
 % Event handling
 % ---------------------------------------------------------------------------


@@ -13,7 +43,7 @@ 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}%
 \begin{twocollist}\itemsep=0pt
 \twocolitem{{\bf EVT\_SOCKET(id, func)}}{A socket event occured.}
 \end{twocollist}%


@@ -21,20 +51,19 @@ functions that take a \helpref{wxSocketEvent}{wxsocketevent} argument.
 % ---------------------------------------------------------------------------
 % See also ...
 % ---------------------------------------------------------------------------
 % ---------------------------------------------------------------------------
 % See also ...
 % ---------------------------------------------------------------------------

-

 \wxheading{See also}
 
 \wxheading{See also}
 

-\helpref{wxSocketEvent}{wxsocketevent}
-\helpref{wxSocketClient}{wxsocketclient}
+\helpref{wxSocketEvent}{wxsocketevent}\\
+\helpref{wxSocketClient}{wxsocketclient}\\

 \helpref{wxSocketServer}{wxsocketserver}
 
 % ---------------------------------------------------------------------------
 % Members
 % ---------------------------------------------------------------------------
 \helpref{wxSocketServer}{wxsocketserver}
 
 % ---------------------------------------------------------------------------
 % Members
 % ---------------------------------------------------------------------------

-

 \latexignore{\rtfignore{\wxheading{Members}}}
 
 \membersection{wxSocketBase::wxSocketBase}
 \latexignore{\rtfignore{\wxheading{Members}}}
 
 \membersection{wxSocketBase::wxSocketBase}

+

 \func{}{wxSocketBase}{\void}
 
 Default constructor but don't use it, you must use \helpref{wxSocketClient}{wxsocketclient}
 \func{}{wxSocketBase}{\void}
 
 Default constructor but don't use it, you must use \helpref{wxSocketClient}{wxsocketclient}


@@ -50,6 +79,72 @@ Destroys the wxSocketBase object.
 % State functions
 % ---------------------------------------------------------------------------
 
 % State functions
 % ---------------------------------------------------------------------------
 

+%
+% SetFlags
+%
+
+\membersection{wxSocketBase::SetFlags}\label{wxsocketbasesetflags}
+
+\func{void}{SetFlags}{\param{wxSocketBase::wxSockFlags}{ flags}}
+
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxSocketBase::NONE}}{Normal functionnalities.}
+\twocolitem{{\bf wxSocketBase::NOWAIT}}{Get the available data in the input queue and exit immediately.}
+\twocolitem{{\bf wxSocketBase::WAITALL}}{Wait for all required data unless an error occured.}
+\twocolitem{{\bf wxSocketBase::SPEED}}{Disable the asynchronous IO functionnality.}
+\end{twocollist}
+
+%
+% SetNotify
+%
+\membersection{wxSocketBase::SetNotify}\label{wxsocketbasesetnotify}
+
+\func{void}{SetNotify}{\param{wxSocketEventFlags}{ event_flags}}
+
+SetNotify setups which socket events are to be sent to the event handler.
+You specify in parameters a mask of wxSocket events. The flags is:
+
+\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 datas and
+a broken connection.
+
+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 socket timeout in seconds.
+
+%
+% 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}
 \membersection{wxSocketBase::Ok}\label{wxsocketbaseok}
 
 \constfunc{bool}{Ok}{\void}


@@ -69,7 +164,7 @@ Returns TRUE if an error occured.
 
 Returns TRUE if the socket is connected.
 
 
 Returns TRUE if the socket is connected.
 

-\membersection{wxSocketBase::IsData}\label{wxsocketbaseerror}
+\membersection{wxSocketBase::IsData}\label{wxsocketbaseisdata}

 
 \constfunc{bool}{IsData}{\void}
 
 
 \constfunc{bool}{IsData}{\void}
 


@@ -89,27 +184,25 @@ Returns TRUE if the socket mustn't wait.
 
 \membersection{wxSocketBase::LastCount}\label{wxsocketbaselastcount}
 
 
 \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.
 
 \membersection{wxSocketBase::LastError}\label{wxsocketbaselasterror}
 
 
 Returns the number of bytes read or written by the last IO call.
 
 \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 occured wxSocket error. See \helpref{wxSocket errors}{wxsocketbase}.

 
 % ---------------------------------------------------------------------------
 % IO calls
 % ---------------------------------------------------------------------------
 
 % ---------------------------------------------------------------------------
 % IO calls
 % ---------------------------------------------------------------------------

-

 %
 % Peek
 %
 %
 % Peek
 %

-

 \membersection{wxSocketBase::Peek}\label{wxsocketbasepeek}
 
 \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.
 
 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.


@@ -117,72 +210,101 @@ doesn't delete it from the system socket in-queue.
 \wxheading{Parameters}
 
 \docparam{buffer}{Buffer where to put peeked data.}
 \wxheading{Parameters}
 
 \docparam{buffer}{Buffer where to put peeked data.}

+

 \docparam{nbytes}{Number of bytes.}
 
 \docparam{nbytes}{Number of bytes.}
 

-\wxheading{Returns value}
+\wxheading{Return value}
+

 Returns a reference to the current object.
 
 \wxheading{See also}
 
 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}
 
 %
 % Read
 %
 \helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
 
 %
 % Read
 %

-

 \membersection{wxSocketBase::Read}\label{wxsocketbaseread}
 
 \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.
 
 \wxheading{Parameters}
 
 \docparam{buffer}{Buffer where to put read data.}
 
 This function reads a buffer of {\it nbytes} bytes from the socket.
 
 \wxheading{Parameters}
 
 \docparam{buffer}{Buffer where to put read data.}

+

 \docparam{nbytes}{Number of bytes.}
 
 \docparam{nbytes}{Number of bytes.}
 

-\wxheading{Returns value}
+\wxheading{Return value}
+

 Returns a reference to the current object.
 
 Returns a reference to the current object.
 

+\wxheading{Remark/Warning}
+
+By default, Read uses an internal asynchronous manager: it will send data when
+the socket requests them. It is particularly interesting when you enter a long
+data transfer (e.g. a big file, an image, ...). But it is also buggy when you
+simply discuss with the peer using user data. In this case, wxSocket prepares
+itself to send data (Write wait for them to be sent) and during a GUI refresh
+the user enters new data, which involves a new Read call though the previous
+isn't finished. Well, in most cases it can work but it might fail too.
+So I advise you to use the SPEED flag, which disables the asynchronous manager,
+when you just want to discuss with the peer.
+
+This remark is also valid for all IO call.
+

 \wxheading{See also}
 
 \wxheading{See also}
 

-\helpref{wxSocketBase::Error}{wxsocketbaserror},
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
- 
+\helpref{wxSocketBase::Error}{wxsocketbaseerror},
+ \helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
+ \helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
+

 %
 %

-% Read
+% Write

 %
 %

-

 \membersection{wxSocketBase::Write}\label{wxsocketbasewrite}
 
 \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 from the socket.
 
 
 This function writes a buffer of {\it nbytes} bytes from the socket.
 

+\wxheading{Remark/Warning}
+
+By default, Write uses an internal asynchronous manager: it will send data when
+the socket requests them. It is particularly interesting when you enter a long
+data transfer (e.g. a big file, an image, ...). But it is also buggy when you
+simply discuss with the peer using user data. In this case, wxSocket prepares
+itself to send data (Write wait for them to be sent) and during a GUI refresh
+the user enters new data, which involves a new Write call though the previous
+isn't finished. Well, in most cases it can work but it might fail too.  
+So I advise you to use the SPEED flag, which disables the asynchronous manager,
+when you just want to discuss with the peer.
+

 \wxheading{Parameters}
 
 \docparam{buffer}{Buffer where to get the data to write.}
 \wxheading{Parameters}
 
 \docparam{buffer}{Buffer where to get the data to write.}

+

 \docparam{nbytes}{Number of bytes.}
 
 \docparam{nbytes}{Number of bytes.}
 

-\wxheading{Returns value}
+\wxheading{Return value}
+

 Returns a reference to the current object.
 
 \wxheading{See also}
 
 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}
 
 %
 % WriteMsg
 %
 \helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
 
 %
 % WriteMsg
 %

-

 \membersection{wxSocketBase::WriteMsg}\label{wxsocketbasewritemsg}
 
 \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
 writes a short header before so that ReadMsg can alloc the right size for
 
 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


@@ -191,25 +313,26 @@ the buffer. So a buffer sent with WriteMsg {\bf must} be read with ReadMsg.
 \wxheading{Parameters}
 
 \docparam{buffer}{Buffer where to put data peeked.}
 \wxheading{Parameters}
 
 \docparam{buffer}{Buffer where to put data peeked.}

+

 \docparam{nbytes}{Number of bytes.}
 
 \docparam{nbytes}{Number of bytes.}
 

-\wxheading{Returns value}
+\wxheading{Return value}
+

 Returns a reference to the current object.
 
 \wxheading{See also}
 
 Returns a reference to the current object.
 
 \wxheading{See also}
 

-\helpref{wxSocketBase::Error}{wxsocketbaserror},
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror},
+\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}\\

 \helpref{wxSocketBase::ReadMsg}{wxsocketbasereadmsg}
 
 %
 % ReadMsg
 %
 \helpref{wxSocketBase::ReadMsg}{wxsocketbasereadmsg}
 
 %
 % ReadMsg
 %

-

 \membersection{wxSocketBase::ReadMsg}\label{wxsocketbasereadmsg}
 
 \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
 
 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


@@ -218,25 +341,26 @@ bytes left. This function always wait for the buffer to be entirely filled.
 \wxheading{Parameters}
 
 \docparam{buffer}{Buffer where to put read data.}
 \wxheading{Parameters}
 
 \docparam{buffer}{Buffer where to put read data.}

+

 \docparam{nbytes}{Number of bytes allocated for the buffer.}
 
 \docparam{nbytes}{Number of bytes allocated for the buffer.}
 

-\wxheading{Returns value}
+\wxheading{Return value}
+

 Returns a reference to the current object.
 
 \wxheading{See also}
 
 Returns a reference to the current object.
 
 \wxheading{See also}
 

-\helpref{wxSocketBase::Error}{wxsocketbaserror},
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror},
+\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}\\

 \helpref{wxSocketBase::WriteMsg}{wxsocketbasewritemsg}
 
 %
 % Unread
 %
 \helpref{wxSocketBase::WriteMsg}{wxsocketbasewritemsg}
 
 %
 % Unread
 %

+\membersection{wxSocketBase::Unread}\label{wxsocketbaseunread}

 
 

-\membersection{wxSocketBase::UnRead}\label{wxsocketbaseunread}
-
-\func{wxSocketBase\&}{UnRead}{\param{const char *}{ buffer}, \param{size\_t}{ nbytes}}
+\func{wxSocketBase\&}{Unread}{\param{const char *}{ buffer}, \param{wxUint32}{ nbytes}}

 
 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.
 
 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.


@@ -245,21 +369,22 @@ It is useful for sockets because we can't seek it.
 \wxheading{Parameters}
 
 \docparam{buffer}{Buffer to be unread.}
 \wxheading{Parameters}
 
 \docparam{buffer}{Buffer to be unread.}

+

 \docparam{nbytes}{Number of bytes.}
 
 \docparam{nbytes}{Number of bytes.}
 

-\wxheading{Returns value}
+\wxheading{Return value}
+

 Returns a reference to the current object.
 
 \wxheading{See also}
 
 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
 %
 \helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
 
 %
 % Discard
 %

-

 \membersection{wxSocketBase::Discard}\label{wxsocketbasediscard}
 
 \func{wxSocketBase\&}{Discard}{\void}
 \membersection{wxSocketBase::Discard}\label{wxsocketbasediscard}
 
 \func{wxSocketBase\&}{Discard}{\void}


@@ -271,7 +396,8 @@ doesn't wait.
 % Wait functions
 % ---------------------------------------------------------------------------
 \membersection{wxSocketBase::Wait}\label{wxsocketbasewait}
 % Wait functions
 % ---------------------------------------------------------------------------
 \membersection{wxSocketBase::Wait}\label{wxsocketbasewait}

-\func{bool}{Wait}{\param{long}{ seconds = -1}, \param{long}{ microsecond = 0}}
+
+\func{bool}{Wait}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 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
 
 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


@@ -280,72 +406,75 @@ established connection.
 \wxheading{Parameters}
 
 \docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
 \wxheading{Parameters}
 
 \docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}

-\docparam{microsecond}{Number of microseconds to wait.}

 
 

-\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}
 
 
 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
 %
 \helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
 
 %
 % WaitForRead
 %

-

 \membersection{wxSocketBase::WaitForRead}\label{wxsocketbasewaitforread}
 \membersection{wxSocketBase::WaitForRead}\label{wxsocketbasewaitforread}

-\func{bool}{WaitForRead}{\param{long}{ seconds = -1}, \param{long}{ microsecond = 0}}
+
+\func{bool}{WaitForRead}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}}

 
 This function waits for a read event.
 
 \wxheading{Parameters}
 
 \docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
 
 This function waits for a read event.
 
 \wxheading{Parameters}
 
 \docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}

-\docparam{microsecond}{Number of microseconds to wait.}

 
 

-\wxheading{Return value:}
+\docparam{millisecond}{Number of milliseconds to wait.}
+
+\wxheading{Return value}

 
 Returns TRUE if a byte arrived, FALSE if the timeout was reached.
 
 \wxheading{See also}
 
 
 Returns TRUE if a byte arrived, 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
 %
 \helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
 
 %
 % WaitForWrite
 %

-

 \membersection{wxSocketBase::WaitForWrite}\label{wxsocketbasewaitforwrite}
 \membersection{wxSocketBase::WaitForWrite}\label{wxsocketbasewaitforwrite}

-\func{bool}{WaitForWrite}{\param{long}{ seconds = -1}, \param{long}{ microsecond = 0}}
+
+\func{bool}{WaitForWrite}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}}

 
 This function waits for a write event.
 
 \wxheading{Parameters}
 
 \docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
 
 This function waits for a write event.
 
 \wxheading{Parameters}
 
 \docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}

-\docparam{microsecond}{Number of microseconds to wait.}

 
 

-\wxheading{Return value:}
+\docparam{millisecond}{Number of milliseconds to wait.}
+
+\wxheading{Return value}

 
 Returns TRUE if a write event occured, FALSE if the timeout was reached.
 
 \wxheading{See also}
 
 
 Returns TRUE if a write event occured, 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
 %
 \helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
 
 %
 % WaitForLost
 %

-

 \membersection{wxSocketBase::WaitForLost}\label{wxsocketbasewaitforlost}
 \membersection{wxSocketBase::WaitForLost}\label{wxsocketbasewaitforlost}

-\func{bool}{Wait}{\param{long}{ seconds = -1}, \param{long}{ microsecond = 0}}
+
+\func{bool}{Wait}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}}

 
 This function waits for a "lost" event. For instance, the peer may have closed
 the connection, or the connection may have been broken.
 
 This function waits for a "lost" event. For instance, the peer may have closed
 the connection, or the connection may have been broken.


@@ -353,26 +482,41 @@ the connection, or the connection may have been broken.
 \wxheading{Parameters}
 
 \docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
 \wxheading{Parameters}
 
 \docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}

-\docparam{microsecond}{Number of microseconds to wait.}

 
 

-\wxheading{Return value:}
+\docparam{millisecond}{Number of milliseconds to wait.}
+
+\wxheading{Return value}

 
 Returns TRUE if a "lost" event occured, FALSE if the timeout was reached.
 
 \wxheading{See also}
 
 
 Returns TRUE if a "lost" 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}
 
 \helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
 

+%
+% RestoreState
+%
+\membersection{wxSocketBase::RestoreState}\label{wxsocketbaserestorestate}
+
+\func{void}{RestoreState}{\void}
+
+This function restores the previous state of the socket (include flags,
+notify flags, notify state, C callback function and data).
+
+\wxheading{See also}
+
+\helpref{wxSocketBase::SaveState}{wxsocketbasesavestate}
+

 % ---------------------------------------------------------------------------
 % Socket state
 % ---------------------------------------------------------------------------
 % ---------------------------------------------------------------------------
 % Socket state
 % ---------------------------------------------------------------------------

-

 %
 % SaveState
 %
 \membersection{wxSocketBase::SaveState}\label{wxsocketbasesavestate}
 %
 % SaveState
 %
 \membersection{wxSocketBase::SaveState}\label{wxsocketbasesavestate}

+

 \func{void}{SaveState}{\void}
 
 This function saves the current state of the socket object in a stack:
 \func{void}{SaveState}{\void}
 
 This function saves the current state of the socket object in a stack:


@@ -383,24 +527,40 @@ actually it saves all flags and the state of the asynchronous callbacks.
 \helpref{wxSocketBase::RestoreState}{wxsocketbaserestorestate}
 
 %
 \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
 % ---------------------------------------------------------------------------
 
 % ---------------------------------------------------------------------------
 % 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.
 \func{void}{SetEventHandler}{\param{wxEvtHandler\&}{ evt\_hdlr}, \param{int}{ id = -1}}
 
 Sets an event handler to be called when a socket event occured.


@@ -408,35 +568,73 @@ Sets an event handler to be called when a socket event occured.
 \wxheading{Parameters}
 
 \docparam{evt\_hdlr}{Specifies the event handler you want to use.}
 \wxheading{Parameters}
 
 \docparam{evt\_hdlr}{Specifies the event handler you want to use.}

+

 \docparam{id}{The id of socket event.}
 
 \wxheading{See also}
 
 \docparam{id}{The id of socket event.}
 
 \wxheading{See also}
 

+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}
+\helpref{wxSocketBase::Notify}{wxsocketbasenotify}

 \helpref{wxSocketEvent}{wxsocketevent}
 \helpref{wxSocketEvent}{wxsocketevent}

+\helpref{wxEvtHandler}{wxevthandler}
+
+\membersection{wxSocketBase::Callback}\label{wxsocketbasecallback}
+
+\func{wxSocketBase::wxSockCbk}{Callback}{\param{wxSocketBase::wxSockCbk}{ callback}}
+
+wxSocket event handler can call C callback. This function allows you to set it.
+The format of the callback is as followed:
+\begin{verbatim}
+void SocketCallback(wxSocketBase& sock,wxSocketNotify evt,char *cdata);
+\end{verbatim}
+
+The first parameter reminds you of the caller socket. The second parameter
+informs you about the current event (See \helpref{wxSocket events}{wxsocketbase}).
+The third parameters is the client data you specified using \helpref{CallbackData}{wxsocketcallbackdata}.
+
+\wxheading{Return value}
+
+It returns the previous callback.
+
+\wxheading{See also}
+
+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}
+\helpref{wxSocketBase::Notify}{wxsocketbasenotify}
+
+\membersection{wxSocketBase::CallbackData}\label{wxsocketcallbackdata}
+
+\func{char *}{CallbackData}{\param{char *}{cdata}}
+
+This function sets the the client data which will be passed to a \helpref{C callback}{wxsocketbasecallback}.
+
+\wxheading{Return value}
+
+This function returns the old value of the client data pointer.

 
 % ---------------------------------------------------------------------------
 % CLASS wxSocketClient
 % ---------------------------------------------------------------------------
 
 % ---------------------------------------------------------------------------
 % CLASS wxSocketClient
 % ---------------------------------------------------------------------------

-

 \section{\class{wxSocketClient}}\label{wxsocketclient}
 
 \wxheading{Derived from}
 
 \helpref{wxSocketBase}{wxsocketbase}
 
 \section{\class{wxSocketClient}}\label{wxsocketclient}
 
 \wxheading{Derived from}
 
 \helpref{wxSocketBase}{wxsocketbase}
 

+\wxheading{Include files}
+
+<wx/socket.h>
+

 % ---------------------------------------------------------------------------
 % Members
 % ---------------------------------------------------------------------------
 % ---------------------------------------------------------------------------
 % Members
 % ---------------------------------------------------------------------------

-

 %
 % wxSocketClient
 %
 %
 % wxSocketClient
 %

-

 \membersection{wxSocketClient::wxSocketClient}
 \membersection{wxSocketClient::wxSocketClient}

+

 \func{}{wxSocketClient}{\param{wxSockFlags}{ flags = wxSocketBase::NONE}}
 
 Constructs a new 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}
 
 
 \wxheading{Parameters}
 


@@ -445,17 +643,17 @@ Constructs a new wxSocketClient.
 %
 % ~wxSocketClient
 %
 %
 % ~wxSocketClient
 %

-

 \membersection{wxSocketClient::\destruct{wxSocketClient}}
 \membersection{wxSocketClient::\destruct{wxSocketClient}}

+

 \func{}{\destruct{wxSocketClient}}{\void}
 
 \func{}{\destruct{wxSocketClient}}{\void}
 

-Destructs a wxSocketClient object.
+Destroys a wxSocketClient object.

 
 %
 % Connect
 %
 
 %
 % 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
 \func{bool}{Connect}{\param{wxSockAddress\&}{ address}, \param{bool}{ wait = TRUE}}
 
 Connects to a server using the specified address. If {\it wait} is TRUE, Connect


@@ -464,6 +662,7 @@ will wait for the socket ready to send or receive data.
 \wxheading{Parameters}
 
 \docparam{address}{Address of the server.}
 \wxheading{Parameters}
 
 \docparam{address}{Address of the server.}

+

 \docparam{wait}{If true, waits for the connection to be ready.}
 
 \wxheading{Return value}
 \docparam{wait}{If true, waits for the connection to be ready.}
 
 \wxheading{Return value}


@@ -477,9 +676,9 @@ Returns TRUE if the connection is established and no error occurs.
 %
 % WaitOnConnect
 %
 %
 % 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 for a "connect" event.
 


@@ -488,52 +687,97 @@ Wait for a "connect" event.
 \helpref{wxSocketBase::Wait}{wxsocketbasewait} for a detailed description.
 
 % ---------------------------------------------------------------------------
 \helpref{wxSocketBase::Wait}{wxsocketbasewait} for a detailed description.
 
 % ---------------------------------------------------------------------------

-% CLASS: wxSocketServer
+% CLASS: wxSocketEvent

 % ---------------------------------------------------------------------------
 % ---------------------------------------------------------------------------

+\section{\class{wxSocketEvent}}\label{wxsocketevent}
+
+This event class contains information about socket events.
+
+\wxheading{Derived from}
+
+\helpref{wxEvent}{wxevent}
+
+\wxheading{Include files}
+
+<wx/socket.h>
+
+\wxheading{Event table macros}
+
+To process a socket event, use these event handler macros to direct input to member
+functions that take a wxSocketEvent argument.

 
 

+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_SOCKET(id, func)}}{Process a socket event, supplying the member function.}
+\end{twocollist}%
+
+\wxheading{See also}
+
+\helpref{wxSocketBase}{wxsocketbase},\rtfsp
+\helpref{wxSocketClient}{wxsocketclient},\rtfsp
+\helpref{wxSocketServer}{wxsocketserver}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxSocketEvent::wxSocketEvent}
+
+\func{}{wxSocketEvent}{\param{int}{ id = 0}}
+
+Constructor.
+
+\membersection{wxSocketEvent::SocketEvent}\label{wxsocketeventsocketevent}
+
+\constfunc{wxSocketNotify}{SocketEvent}{\void}
+
+Returns the socket event type.
+
+% ---------------------------------------------------------------------------
+% CLASS: wxSocketServer
+% ---------------------------------------------------------------------------

 \section{\class{wxSocketServer}}\label{wxsocketserver}
 
 \wxheading{Derived from}
 
 \helpref{wxSocketBase}{wxsocketbase}
 
 \section{\class{wxSocketServer}}\label{wxsocketserver}
 
 \wxheading{Derived from}
 
 \helpref{wxSocketBase}{wxsocketbase}
 

+\wxheading{Include files}
+
+<wx/socket.h>
+

 % ---------------------------------------------------------------------------
 % Members
 % ---------------------------------------------------------------------------
 % ---------------------------------------------------------------------------
 % Members
 % ---------------------------------------------------------------------------

-

 \latexignore{\rtfignore{\wxheading{Members}}}
 
 %
 % wxSocketServer
 %
 \latexignore{\rtfignore{\wxheading{Members}}}
 
 %
 % wxSocketServer
 %

+\membersection{wxSocketServer::wxSocketServer}\label{wxsocketserverconstr}

 
 

-\membersection{wxSocketServer::wxSocketServer}{wxsocketserverconstr}

 \func{}{wxSocketServer}{\param{wxSockAddress\&}{ address}, \param{wxSockFlags}{ flags = wxSocketBase::NONE}}
 
 Constructs a new wxSocketServer.
 \func{}{wxSocketServer}{\param{wxSockAddress\&}{ address}, \param{wxSockFlags}{ flags = wxSocketBase::NONE}}
 
 Constructs a new wxSocketServer.

-{\bf Warning !} The created object needs to be registered to a socket handler
-(See \helpref{wxSocketHandler}{wxsockethandler}).

 
 \wxheading{Parameters}
 
 \docparam{address}{Specifies the local address for the server (e.g. port number).}
 
 \wxheading{Parameters}
 
 \docparam{address}{Specifies the local address for the server (e.g. port number).}

-\docparam{flags}{Socket flags (See \helpref{wxSocketBase::SetFlags}{wxsocketbase
-setflags})}
+
+\docparam{flags}{Socket flags (See \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags})}

 
 %
 % ~wxSocketServer
 %
 
 %
 % ~wxSocketServer
 %

-

 \membersection{wxSocketServer::\destruct{wxSocketServer}}
 \membersection{wxSocketServer::\destruct{wxSocketServer}}

+

 \func{}{\destruct{wxSocketServer}}{\void}
 
 \func{}{\destruct{wxSocketServer}}{\void}
 

-Destructs a wxSocketServer object (it doesn't close the accepted connection).
+Destroys a wxSocketServer object (it doesn't close the accepted connection).

 
 %
 % Accept
 %
 
 %
 % Accept
 %

-

 \membersection{wxSocketServer::Accept}
 \membersection{wxSocketServer::Accept}

+

 \func{wxSocketBase *}{Accept}{\void}
 
 Creates a new object wxSocketBase and accepts an incoming connection. {\bf Warning !} This function will block the GUI.
 \func{wxSocketBase *}{Accept}{\void}
 
 Creates a new object wxSocketBase and accepts an incoming connection. {\bf Warning !} This function will block the GUI.


@@ -549,8 +793,8 @@ Returns an opened socket connection.
 %
 % AcceptWith
 %
 %
 % AcceptWith
 %

+\membersection{wxSocketServer::AcceptWith}\label{wxsocketserveracceptwith}

 
 

-\membersection{wxSocketServer::AcceptWith}{wxsocketserveracceptwith}

 \func{bool}{AcceptWith}{\param{wxSocketBase\&}{ socket}}
 
 Accept an incoming connection using the specified socket object.
 \func{bool}{AcceptWith}{\param{wxSocketBase\&}{ socket}}
 
 Accept an incoming connection using the specified socket object.


@@ -564,119 +808,3 @@ This is useful when someone wants to inherit wxSocketBase.
 
 Returns TRUE if no error occurs, else FALSE.
 
 
 Returns TRUE if no error occurs, else FALSE.
 

-
-% ---------------------------------------------------------------------------
-% CLASS: wxSocketHandler
-% ---------------------------------------------------------------------------
-
-\section{\class{wxSocketHandler}}\label{wxsockethandler}
-
-\wxheading{Derived from}
-
-\helpref{wxObject}{wxobject}
-
-% ---------------------------------------------------------------------------
-% 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
-%
-
-\membersection{wxSocketHandler::Register}
-\func{void}{Register}{\param{wxSocketBase *}{socket}}
-
-Register a socket: if it is already registered in this handler it will just
-return immediately.
-
-\wxheading{Parameters}
-
-\docparam{socket}{Socket to be registered.}
-
-%
-% UnRegister
-%
-
-\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}
-
-\docparam{socket}{Socket to be unregistered.}
-
-%
-% Count
-%
-
-\membersection{wxSocketHandler::Count}
-\constfunc{unsigned long}{Count}{\void}
-
-Returns the number of sockets registered in the handler.
-
-\wxheading{Return value}
-
-Number of sockets registered.
-
-%
-% CreateServer
-%
-
-\membersection{wxSocketHandler::CreateServer}
-\func{wxSocketServer *}{CreateServer}{\param{wxSockAddress\&}{ address}, \param{wxSocketBase::wxSockFlags}{ flags = wxSocketbase::NONE}}
-
-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}.
-
-\wxheading{Return value}
-
-Returns a new socket server.
-
-%
-% CreateClient
-%
-
-\membersection{wxSocketHandler::CreateClient}
-\func{wxSocketServer *}{CreateClient}{\param{wxSocketBase::wxSockFlags}{ flags = wxSocketbase::NONE}}
-
-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}.
-
-\wxheading{Return value}
-
-Returns a new socket client.
-
-%
-% Master
-%
-
-\membersection{wxSocketHandler::Master}
-\func{static wxSocketHandler\&}{Master}{\void}
-
-Returns a default socket handler.