changed the version and the date

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

diff --git a/docs/latex/wx/socket.tex b/docs/latex/wx/socket.tex
index 49a59bb2275f5e27e089d1668bbc471114ee2270..04a2515b898cbdad49e9f5cefb9590ef180d8f33 100644 (file)
--- a/docs/latex/wx/socket.tex
+++ b/docs/latex/wx/socket.tex
@@ -1,749 +1,998 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Name:        socket.tex
+%% Purpose:     wxSocket docs
+%% Author:      Guillermo Rodriguez Garcia <guille@iies.es>
+%% Modified by:
+%% Created:     1999
+%% RCS-ID:      $Id$
+%% Copyright:   (c) wxWidgets team
+%% License:     wxWindows license
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+

 \section{\class{wxSocketBase}}\label{wxsocketbase}
 
 \section{\class{wxSocketBase}}\label{wxsocketbase}
 

+wxSocketBase is the base class for all socket-related objects, and it
+defines all basic IO functionality.
+
+Note: (Workaround for implementation limitation for wxWidgets up to 2.5.x)
+If you want to use sockets or derived classes such as wxFTP in a secondary thread,
+call wxSocketBase::Initialize() (undocumented) from the main thread before creating 
+any sockets - in wxApp::OnInit for example. 
+See http://wiki.wxwidgets.org/wiki.pl?WxSocket or
+http://www.litwindow.com/knowhow/knowhow.html for more details.
+

 \wxheading{Derived from}
 
 \wxheading{Derived from}
 

-\helpref{wxEvtHandler}{wxevthandler}
+\helpref{wxObject}{wxobject}

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

-% ---------------------------------------------------------------------------
-% Event handling
-% ---------------------------------------------------------------------------
+\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}}{There is data available for reading.}
+\twocolitem{{\bf wxSOCKET\_OUTPUT}}{The socket is ready to be written to.}
+\twocolitem{{\bf wxSOCKET\_CONNECTION}}{Incoming connection request (server), or successful connection establishment (client).}
+\twocolitem{{\bf wxSOCKET\_LOST}}{The connection has been closed.}
+\end{twocollist}
+
+A brief note on how to use these events:
+
+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 successfully (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. Also, this event will be issued if
+a connection request fails.
+

 \wxheading{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
 
 \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}
 
 \wxheading{See also}
 

-\helpref{wxSocketEvent}{wxsocketevent}\\
-\helpref{wxSocketClient}{wxsocketclient}\\
-\helpref{wxSocketServer}{wxsocketserver}
+\helpref{wxSocketEvent}{wxsocketevent}, 
+\helpref{wxSocketClient}{wxsocketclient}, 
+\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}\label{socketconstruction}

 
 

-Default constructor but don't use it, you must use \helpref{wxSocketClient}{wxsocketclient}
-or \helpref{wxSocketServer}{wxsocketserver}.
+\helpref{wxSocketBase}{wxsocketbaseconstruct}\\
+\helpref{\destruct{wxSocketBase}}{wxsocketbasedestruct}\\
+\helpref{Destroy}{wxsocketbasedestroy}

 
 

-\membersection{wxSocketBase::\destruct{wxSocketBase}}
+\membersection{Socket state}\label{socketstate}

 
 

-\func{}{\destruct{wxSocketBase}}{\void}
+Functions to retrieve current state and miscellaneous info.

 
 

-Destroys the wxSocketBase object.
-
-% ---------------------------------------------------------------------------
-% State functions
-% ---------------------------------------------------------------------------
+\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}

 
 

-\membersection{wxSocketBase::Ok}\label{wxsocketbaseok}
+\membersection{Basic IO}\label{socketbasicio}

 
 

-\constfunc{bool}{Ok}{\void}
+Functions that perform basic IO functionality.

 
 

-Returns TRUE if the socket is initialized and ready and FALSE in other
-cases.
+\helpref{Close}{wxsocketbaseclose}\\
+\helpref{Discard}{wxsocketbasediscard}\\
+\helpref{Peek}{wxsocketbasepeek}\\
+\helpref{Read}{wxsocketbaseread}\\
+\helpref{ReadMsg}{wxsocketbasereadmsg}\\
+\helpref{Unread}{wxsocketbaseunread}\\
+\helpref{Write}{wxsocketbasewrite}\\
+\helpref{WriteMsg}{wxsocketbasewritemsg}

 
 

-\membersection{wxSocketBase::Error}\label{wxsocketbaseerror}
+Functions that perform a timed wait on a certain IO condition.

 
 

-\constfunc{bool}{Error}{\void}
+\helpref{InterruptWait}{wxsocketbaseinterruptwait}\\
+\helpref{Wait}{wxsocketbasewait}\\
+\helpref{WaitForLost}{wxsocketbasewaitforlost}\\
+\helpref{WaitForRead}{wxsocketbasewaitforread}\\
+\helpref{WaitForWrite}{wxsocketbasewaitforwrite}\\

 
 

-Returns TRUE if an error occured.
+and also:

 
 

-\membersection{wxSocketBase::IsConnected}\label{wxsocketbaseconnected}
+\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept}\\
+\helpref{wxSocketClient::WaitOnConnect}{wxsocketclientwaitonconnect}

 
 

-\constfunc{bool}{IsConnected}{\void}
+Functions that allow applications to customize socket IO as needed.

 
 

-Returns TRUE if the socket is connected.
+\helpref{GetFlags}{wxsocketbasegetflags}\\
+\helpref{SetFlags}{wxsocketbasesetflags}\\
+\helpref{SetTimeout}{wxsocketbasesettimeout}\\
+\helpref{SetLocal}{wxsocketbasesetlocal}\\

 
 

-\membersection{wxSocketBase::IsData}\label{wxsocketbaseisdata}
+\membersection{Handling socket events}\label{socketevents}

 
 

-\constfunc{bool}{IsData}{\void}
+Functions that allow applications to receive socket events.

 
 

-Returns TRUE if some data is arrived on the socket. 
+\helpref{Notify}{wxsocketbasenotify}\\
+\helpref{SetNotify}{wxsocketbasesetnotify}\\
+\helpref{GetClientData}{wxsocketbasegetclientdata}\\
+\helpref{SetClientData}{wxsocketbasesetclientdata}\\
+\helpref{SetEventHandler}{wxsocketbaseseteventhandler}

 
 

-\membersection{wxSocketBase::IsDisconnected}\label{wxsocketbasedisconnected}

 
 

-\constfunc{bool}{IsDisconnected}{\void}
+% ---------------------------------------------------------------------------
+% Members here
+% ---------------------------------------------------------------------------

 
 

-Returns TRUE if the socket is disconnected.
+\helponly{\insertatlevel{2}{

 
 

-\membersection{wxSocketBase::IsNoWait}\label{wxsocketbasenowait}
+\wxheading{Members}

 
 

-\constfunc{bool}{IsNoWait}{\void}
+}}

 
 

-Returns TRUE if the socket mustn't wait.
+\membersection{wxSocketBase::wxSocketBase}\label{wxsocketbaseconstruct}

 
 

-\membersection{wxSocketBase::LastCount}\label{wxsocketbaselastcount}
+\func{}{wxSocketBase}{\void}

 
 

-\constfunc{size\_t}{LastCount}{\void}
+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.

 
 

-Returns the number of bytes read or written by the last IO call.
+\membersection{wxSocketBase::\destruct{wxSocketBase}}\label{wxsocketbasedestruct}

 
 

-\membersection{wxSocketBase::LastError}\label{wxsocketbaselasterror}
+\func{}{\destruct{wxSocketBase}}{\void}

 
 

-\constfunc{int}{LastError}{\void}
+Destructor. Do not destroy a socket using the delete operator directly;
+use \helpref{Destroy}{wxsocketbasedestroy} instead. Also, do not create
+socket objects in the stack.

 
 

-Returns an error in the errno format (see your C programmer's guide).

 
 

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

 %
 %

-% Peek
+% Close

 %
 %

-\membersection{wxSocketBase::Peek}\label{wxsocketbasepeek}
-
-\func{wxSocketBase\&}{Peek}{\param{char *}{ buffer}, \param{size\_t}{ 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.
-
-\wxheading{Parameters}
-
-\docparam{buffer}{Buffer where to put peeked data.}
-
-\docparam{nbytes}{Number of bytes.}
+\membersection{wxSocketBase::Close}\label{wxsocketbaseclose}

 
 

-\wxheading{Return value}
+\func{void}{Close}{\void}

 
 

-Returns a reference to the current object.
+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. Upon socket destruction, Close is automatically
+called, so in most cases you won't need to do it yourself, unless you
+explicitly want to shut down the socket, typically to notify the peer
+that you are closing the connection.

 
 

-\wxheading{See also}
+\wxheading{Remark/Warning}

 
 

-\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
+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.

 
 %
 
 %

-% Read
+% Destroy

 %
 %

-\membersection{wxSocketBase::Read}\label{wxsocketbaseread}
+\membersection{wxSocketBase::Destroy}\label{wxsocketbasedestroy}

 
 

-\func{wxSocketBase\&}{Read}{\param{char *}{ buffer}, \param{size\_t}{ nbytes}}
+\func{bool}{Destroy}{\void}

 
 

-This function reads a buffer of {\it nbytes} bytes from the socket.
+Destroys the socket safely. Use this function instead of the delete operator,
+since otherwise socket events could reach the application even after the
+socket has been destroyed. To prevent this problem, this function appends
+the wxSocket to a list of object to be deleted on idle time, after all
+events have been processed. For the same reason, you should avoid creating
+socket objects in the stack.

 
 

-\wxheading{Parameters}
-
-\docparam{buffer}{Buffer where to put read data.}
-
-\docparam{nbytes}{Number of bytes.}
+Destroy calls \helpref{Close}{wxsocketbaseclose} automatically.

 
 \wxheading{Return value}
 
 
 \wxheading{Return value}
 

-Returns a reference to the current object.
+Always true.

 
 

-\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.
+%
+% Discard
+%
+\membersection{wxSocketBase::Discard}\label{wxsocketbasediscard}

 
 

-\wxheading{See also}
+\func{wxSocketBase\&}{Discard}{\void}

 
 

-\helpref{wxSocketBase::Error}{wxsocketbaseerror},
- \helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
- \helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
- 
-\membersection{wxSocketBase::SetFlags}\label{wxsocketbasesetflags}
+This function simply deletes all bytes in the incoming queue. This function
+always returns immediately and its operation is not affected by IO flags.

 
 

-\func{void}{SetFlags}{\param{wxSockFlags}{ flags}}
+Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually discarded.

 
 

-\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}
+If you use \helpref{Error}{wxsocketbaseerror}, it will always return false.

 
 %
 
 %

-% Read
+% Error

 %
 %

-\membersection{wxSocketBase::Write}\label{wxsocketbasewrite}
+\membersection{wxSocketBase::Error}\label{wxsocketbaseerror}

 
 

-\func{wxSocketBase\&}{Write}{\param{const char *}{ buffer}, \param{size\_t}{ nbytes}}
+\constfunc{bool}{Error}{\void}

 
 

-This function writes a buffer of {\it nbytes} bytes from the socket.
+Returns true if an error occurred in the last IO operation.

 
 

-\wxheading{Remark/Warning}
+Use this function to check for an error condition after one of the
+following calls: Discard, Peek, Read, ReadMsg, Unread, Write, WriteMsg.

 
 

-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.
+%
+% GetClientData
+%
+\membersection{wxSocketBase::GetClientData}\label{wxsocketbasegetclientdata}

 
 

-\wxheading{Parameters}
+\constfunc{void *}{GetClientData}{\void}

 
 

-\docparam{buffer}{Buffer where to get the data to write.}
+Returns a pointer of the client data for this socket, as set with 
+\helpref{SetClientData}{wxsocketbasesetclientdata}

 
 

-\docparam{nbytes}{Number of bytes.}
+%
+% GetLocal
+%
+\membersection{wxSocketBase::GetLocal}\label{wxsocketbasegetlocal}

 
 

-\wxheading{Return value}
+\constfunc{bool}{GetLocal}{\param{wxSockAddress\& }{addr}}

 
 

-Returns a reference to the current object.
+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{See also}
+\wxheading{Return value}

 
 

-\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
+true if no error happened, false otherwise.

 
 %
 
 %

-% WriteMsg
+% GetFlags

 %
 %

-\membersection{wxSocketBase::WriteMsg}\label{wxsocketbasewritemsg}
+\membersection{wxSocketBase::GetFlags}\label{wxsocketbasegetflags}

 
 

-\func{wxSocketBase\&}{WriteMsg}{\param{const char *}{ buffer}, \param{size\_t}{ nbytes}}
+\constfunc{wxSocketFlags}{GetFlags}{\void}

 
 

-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.
+Returns current IO flags, as set with \helpref{SetFlags}{wxsocketbasesetflags}

 
 

-\wxheading{Parameters}
+%
+% GetPeer
+%
+\membersection{wxSocketBase::GetPeer}\label{wxsocketbasegetpeer}

 
 

-\docparam{buffer}{Buffer where to put data peeked.}
+\constfunc{bool}{GetPeer}{\param{wxSockAddress\& }{addr}}

 
 

-\docparam{nbytes}{Number of bytes.}
+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}
 
 
 \wxheading{Return value}
 

-Returns a reference to the current object.
-
-\wxheading{See also}
+true if no error happened, false otherwise.

 
 

-\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}\\
-\helpref{wxSocketBase::ReadMsg}{wxsocketbasereadmsg}
+%
+% InterruptWait
+%
+\membersection{wxSocketBase::InterruptWait}\label{wxsocketbaseinterruptwait}
+
+\func{void}{InterruptWait}{\void}
+
+Use this function to interrupt any wait operation currently in progress.
+Note that this is not intended as a regular way to interrupt a Wait call,
+but only as an escape mechanism for exceptional situations where it is
+absolutely necessary to use it, for example to abort an operation due to
+some exception or abnormal problem. InterruptWait is automatically called
+when you \helpref{Close}{wxsocketbaseclose} a socket (and thus also upon
+socket destruction), so you don't need to use it in these cases.
+
+\helpref{wxSocketBase::Wait}{wxsocketbasewait}, 
+\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept}, 
+\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}, 
+\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}, 
+\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}, 
+\helpref{wxSocketClient::WaitOnConnect}{wxsocketclientwaitonconnect}

 
 %
 
 %

-% ReadMsg
+% IsConnected

 %
 %

-\membersection{wxSocketBase::ReadMsg}\label{wxsocketbasereadmsg}
+\membersection{wxSocketBase::IsConnected}\label{wxsocketbaseisconnected}

 
 

-\func{wxSocketBase\&}{ReadMsg}{\param{char *}{ buffer}, \param{size\_t}{ nbytes}}
+\constfunc{bool}{IsConnected}{\void}

 
 

-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.
+Returns true if the socket is connected.

 
 

-\wxheading{Parameters}
+%
+% IsData
+%
+\membersection{wxSocketBase::IsData}\label{wxsocketbaseisdata}

 
 

-\docparam{buffer}{Buffer where to put read data.}
+\constfunc{bool}{IsData}{\void}

 
 

-\docparam{nbytes}{Number of bytes allocated for the buffer.}
+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 read operation will complete
+immediately without blocking (unless the {\bf wxSOCKET\_WAITALL} flag
+is set, in which case the operation might still block).

 
 

-\wxheading{Return value}
+\membersection{wxSocketBase::IsDisconnected}\label{wxsocketbaseisdisconnected}

 
 

-Returns a reference to the current object.
+%
+% IsDisconnected
+%
+\constfunc{bool}{IsDisconnected}{\void}

 
 

-\wxheading{See also}
+Returns true if the socket is not connected.

 
 

-\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}\\
-\helpref{wxSocketBase::WriteMsg}{wxsocketbasewritemsg}
+\membersection{wxSocketBase::LastCount}\label{wxsocketbaselastcount}

 
 %
 
 %

-% Unread
+% LastCount

 %
 %

-\membersection{wxSocketBase::UnRead}\label{wxsocketbaseunread}
+\constfunc{wxUint32}{LastCount}{\void}

 
 

-\func{wxSocketBase\&}{UnRead}{\param{const char *}{ buffer}, \param{size\_t}{ nbytes}}
+Returns the number of bytes read or written by the last IO call.

 
 

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

 
 

-\wxheading{Parameters}
+%
+% LastError
+%
+\membersection{wxSocketBase::LastError}\label{wxsocketbaselasterror}

 
 

-\docparam{buffer}{Buffer to be unread.}
+\constfunc{wxSocketError}{LastError}{\void}

 
 

-\docparam{nbytes}{Number of bytes.}
+Returns the last wxSocket error. See \helpref{wxSocket errors}{wxsocketbase}.

 
 

-\wxheading{Return value}
+Please note that this function merely returns the last error code,
+but it should not be used to determine if an error has occurred (this
+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.

 
 

-Returns a reference to the current object.
+%
+% Notify
+%
+\membersection{wxSocketBase::Notify}\label{wxsocketbasenotify}

 
 

-\wxheading{See also}
+\func{void}{Notify}{\param{bool}{ notify}}

 
 

-\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
+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.

 
 

+% 
+% 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
-doesn't wait.
+Returns true if the socket is initialized and ready and false in other
+cases.

 
 

-% ---------------------------------------------------------------------------
-% Wait functions
-% ---------------------------------------------------------------------------
-\membersection{wxSocketBase::Wait}\label{wxsocketbasewait}
+\wxheading{Remark/Warning}

 
 

-\func{bool}{Wait}{\param{long}{ seconds = -1}, \param{long}{ microsecond = 0}}
+For \helpref{wxSocketClient}{wxsocketclient}, Ok won't return true unless
+the client is connected to a server.

 
 

-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.
+For \helpref{wxSocketServer}{wxsocketserver}, Ok will return true if the
+server could bind to the specified address and is already listening for
+new connections.

 
 

-\wxheading{Parameters}
+Ok does not check for IO errors;
+use \helpref{Error}{wxsocketbaseerror} instead for that purpose.

 
 

-\docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
+%
+% RestoreState
+%
+\membersection{wxSocketBase::RestoreState}\label{wxsocketbaserestorestate}

 
 

-\docparam{microsecond}{Number of microseconds to wait.}
+\func{void}{RestoreState}{\void}

 
 

-\wxheading{Return value}
+This function restores the previous state of the socket, as saved
+with \helpref{SaveState}{wxsocketbasesavestate}

 
 

-Returns TRUE if an event occured, FALSE if the timeout was reached.
+Calls to SaveState and RestoreState can be nested.

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

-\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}\\
-\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}\\
-\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
+\helpref{wxSocketBase::SaveState}{wxsocketbasesavestate}

 
 %
 
 %

-% WaitForRead
+% SaveState

 %
 %

-\membersection{wxSocketBase::WaitForRead}\label{wxsocketbasewaitforread}
-
-\func{bool}{WaitForRead}{\param{long}{ seconds = -1}, \param{long}{ microsecond = 0}}
+\membersection{wxSocketBase::SaveState}\label{wxsocketbasesavestate}

 
 

-This function waits for a read event.
+\func{void}{SaveState}{\void}

 
 

-\wxheading{Parameters}
+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}, user data, as set with 
+\helpref{SetClientData}{wxsocketbasesetclientdata}.

 
 

-\docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
+Calls to SaveState and RestoreState can be nested.

 
 

-\docparam{microsecond}{Number of microseconds to wait.}
+\wxheading{See also}

 
 

-\wxheading{Return value}
+\helpref{wxSocketBase::RestoreState}{wxsocketbaserestorestate}

 
 

-Returns TRUE if a byte arrived, FALSE if the timeout was reached.
+%
+% SetClientData
+%
+\membersection{wxSocketBase::SetClientData}\label{wxsocketbasesetclientdata}

 
 

-\wxheading{See also}
+\func{void}{SetClientData}{\param{void *}{data}}

 
 

-\helpref{wxSocketBase::Wait}{wxsocketbasewait}\\
-\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}\\
-\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
+Sets user-supplied client data for this socket. All socket events will
+contain a pointer to this data, which can be retrieved with
+the \helpref{wxSocketEvent::GetClientData}{wxsocketeventgetclientdata} function.

 
 %
 
 %

-% WaitForWrite
+% SetEventHandler

 %
 %

-\membersection{wxSocketBase::WaitForWrite}\label{wxsocketbasewaitforwrite}
+\membersection{wxSocketBase::SetEventHandler}\label{wxsocketbaseseteventhandler}

 
 

-\func{bool}{WaitForWrite}{\param{long}{ seconds = -1}, \param{long}{ microsecond = 0}}
+\func{void}{SetEventHandler}{\param{wxEvtHandler\&}{ handler}, \param{int}{ id = -1}}

 
 

-This function waits for a write event.
+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}.

 
 \wxheading{Parameters}
 
 
 \wxheading{Parameters}
 

-\docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
+\docparam{handler}{Specifies the event handler you want to use.}

 
 

-\docparam{microsecond}{Number of microseconds to wait.}
-
-\wxheading{Return value}
-
-Returns TRUE if a write event occured, FALSE if the timeout was reached.
+\docparam{id}{The id of socket event.}

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

-\helpref{wxSocketBase::Wait}{wxsocketbasewait}\\
-\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}\\
-\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}, 
+\helpref{wxSocketBase::Notify}{wxsocketbasenotify}, 
+\helpref{wxSocketEvent}{wxsocketevent}, 
+\helpref{wxEvtHandler}{wxevthandler}

 
 %
 
 %

-% WaitForLost
+% SetFlags

 %
 %

-\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.
+\membersection{wxSocketBase::SetFlags}\label{wxsocketbasesetflags}

 
 

-\wxheading{Parameters}
+\func{void}{SetFlags}{\param{wxSocketFlags}{ flags}}

 
 

-\docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
+Use SetFlags to customize IO operation for this socket.
+The {\it flags} parameter may be a combination of flags ORed together.
+The following flags can be used:

 
 

-\docparam{microsecond}{Number of microseconds to wait.}
+\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.}
+\twocolitem{{\bf wxSOCKET\_REUSEADDR}}{Allows the use of an in-use port (wxServerSocket only)}
+\end{twocollist}

 
 

-\wxheading{Return value}
+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.
+
+The {\bf wxSOCKET\_REUSEADDR} flag controls the use of the SO\_REUSEADDR standard
+setsockopt() flag. This flag allows the socket to bind to a port that is already in use.
+This is mostly used on UNIX-based systems to allow rapid starting and stopping of a server - 
+otherwise you may have to wait several minutes for the port to become available.
+wxSOCKET\_REUSEADDR can also be used with socket clients to (re)bind to a particular local port
+for an outgoing connection.
+This option can have surprising platform dependent behavior, so check the documentation for
+your platform's implementation of setsockopt(). Note that on BSD-based systems (e.g. Mac OS X),
+use of wxSOCKET\_REUSEADDR implies SO\_REUSEPORT in addition to SO\_REUSEADDR to be consistent
+with Windows.
+
+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.
+
+{\bf wxSOCKET\_REUSEADDR} controls special platform-specific behavior for
+reusing local addresses/ports.

 
 

-Returns TRUE if a "lost" event occured, FALSE if the timeout was reached.
+%
+% SetLocal
+%
+\membersection{wxSocketBase::SetLocal}\label{wxsocketbasesetlocal}

 
 

-\wxheading{See also}
+\func{bool}{SetLocal}{\param{wxIPV4address\&}{ local}}

 
 

-\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}\\
-\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}\\
-\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
+This function allows you to set the local address and port,
+useful when an application needs to reuse a particular port. When
+a local port is set for a \helpref{wxSocketClient}{wxsocketclient},
+{\bf bind} will be called before {\bf connect}.

 
 %
 
 %

-% RestoreState
+% SetNotify

 %
 %

-\membersection{wxSocketBase::RestoreState}\label{wxsocketbaserestorestate}
+\membersection{wxSocketBase::SetNotify}\label{wxsocketbasesetnotify}

 
 

-\func{void}{RestoreState}{\void}
+\func{void}{SetNotify}{\param{wxSocketEventFlags}{ flags}}

 
 

-This function restores a previously saved state.
+SetNotify specifies which socket events are to be sent to the event handler.
+The {\it flags} parameter may be combination of flags ORed together. The
+following flags can be used:

 
 

-\wxheading{See also}
+\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}

 
 

-\helpref{wxSocketBase::SaveState}{wxsocketbasesavestate}
+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}.

 
 

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

 %
 %

-% SaveState
+% SetTimeout

 %
 %

-\membersection{wxSocketBase::SaveState}\label{wxsocketbasesavestate}
+\membersection{wxSocketBase::SetTimeout}\label{wxsocketbasesettimeout}

 
 

-\func{void}{SaveState}{\void}
+\func{void}{SetTimeout}{\param{int }{seconds}}

 
 

-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. 
+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
+timeout is 10 minutes.

 
 

-\wxheading{See also}
+%
+% Peek
+%
+\membersection{wxSocketBase::Peek}\label{wxsocketbasepeek}

 
 

-\helpref{wxSocketBase::RestoreState}{wxsocketbaserestorestate}
+\func{wxSocketBase\&}{Peek}{\param{void *}{ buffer}, \param{wxUint32}{ nbytes}}

 
 

-% ---------------------------------------------------------------------------
-% Socket callbacks
-% ---------------------------------------------------------------------------
-\membersection{wxSocketBase::SetEventHandler}\label{wxsocketbaseseteventhandler}
+This function peeks a buffer of {\it nbytes} bytes from the socket.
+Peeking a buffer doesn't delete it from the socket input queue.

 
 

-\func{void}{SetEventHandler}{\param{wxEvtHandler\&}{ evt\_hdlr}, \param{int}{ id = -1}}
+Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually peeked.

 
 

-Sets an event handler to be called when a socket event occured.
+Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded.

 
 \wxheading{Parameters}
 
 
 \wxheading{Parameters}
 

-\docparam{evt\_hdlr}{Specifies the event handler you want to use.}
-
-\docparam{id}{The id of socket event.}
+\docparam{buffer}{Buffer where to put peeked data.}

 
 

-\wxheading{See also}
+\docparam{nbytes}{Number of bytes.}

 
 

-\helpref{wxSocketEvent}{wxsocketevent}
+\wxheading{Return value}

 
 

-% ---------------------------------------------------------------------------
-% CLASS wxSocketClient
-% ---------------------------------------------------------------------------
-\section{\class{wxSocketClient}}\label{wxsocketclient}
+Returns a reference to the current object.

 
 

-\wxheading{Derived from}
+\wxheading{Remark/Warning}

 
 

-\helpref{wxSocketBase}{wxsocketbase}
+The exact behaviour of wxSocketBase::Peek depends on the combination
+of flags being used. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}

 
 

-\wxheading{Include files}
+\wxheading{See also}

 
 

-<wx/socket.h>
+\helpref{wxSocketBase::Error}{wxsocketbaseerror}, 
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, 
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, 
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}

 
 

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

 %
 %

-% wxSocketClient
+% Read

 %
 %

-\membersection{wxSocketClient::wxSocketClient}
+\membersection{wxSocketBase::Read}\label{wxsocketbaseread}

 
 

-\func{}{wxSocketClient}{\param{wxSockFlags}{ flags = wxSocketBase::NONE}}
+\func{wxSocketBase\&}{Read}{\param{void *}{ buffer}, \param{wxUint32}{ nbytes}}
+
+This function reads a buffer of {\it nbytes} bytes from the socket.

 
 

-Constructs a new wxSocketClient.
+Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually read.

 
 

-{\bf Warning !} The new socket client needs to be registered to a socket handler (See \helpref{wxSocketHandler}{wxsockethandler}).
+Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded.

 
 \wxheading{Parameters}
 
 
 \wxheading{Parameters}
 

-\docparam{flags}{Socket flags (See \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags})}
+\docparam{buffer}{Buffer where to put read data.}

 
 

-%
-% ~wxSocketClient
-%
-\membersection{wxSocketClient::\destruct{wxSocketClient}}
+\docparam{nbytes}{Number of bytes.}

 
 

-\func{}{\destruct{wxSocketClient}}{\void}
+\wxheading{Return value}
+
+Returns a reference to the current object.

 
 

-Destroys a wxSocketClient 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}{wxsocketbaseerror}, 
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, 
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, 
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}

 
 %
 
 %

-% Connect
+% ReadMsg

 %
 %

-\membersection{wxSocketClient::Connect}\label{wxsocketclientconnect}
+\membersection{wxSocketBase::ReadMsg}\label{wxsocketbasereadmsg}
+
+\func{wxSocketBase\&}{ReadMsg}{\param{void *}{ buffer}, \param{wxUint32}{ nbytes}}

 
 

-\func{bool}{Connect}{\param{wxSockAddress\&}{ address}, \param{bool}{ wait = TRUE}}
+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.

 
 

-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.
+Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually read.
+
+Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded.

 
 \wxheading{Parameters}
 
 
 \wxheading{Parameters}
 

-\docparam{address}{Address of the server.}
+\docparam{buffer}{Buffer where to put read data.}

 
 

-\docparam{wait}{If true, waits for the connection to be ready.}
+\docparam{nbytes}{Size of the buffer.}

 
 \wxheading{Return value}
 
 
 \wxheading{Return value}
 

-Returns TRUE if the connection is established and no error occurs.
+Returns a reference to the current object.
+
+\wxheading{Remark/Warning}
+
+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}
 
 
 \wxheading{See also}
 

-\helpref{wxSocketClient::WaitOnConnect}{wxsocketclientwaitonconnect}
+\helpref{wxSocketBase::Error}{wxsocketbaseerror}, 
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, 
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, 
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}, 
+\helpref{wxSocketBase::WriteMsg}{wxsocketbasewritemsg}

 
 %
 
 %

-% WaitOnConnect
+% Unread

 %
 %

-\membersection{wxSocketClient::WaitOnConnect}\label{wxsocketclientwaitonconnect}
+\membersection{wxSocketBase::Unread}\label{wxsocketbaseunread}

 
 

-\func{bool}{WaitOnConnect}{\param{long}{ seconds = -1}, \param{long}{ microseconds = 0}}
+\func{wxSocketBase\&}{Unread}{\param{const void *}{ buffer}, \param{wxUint32}{ nbytes}}

 
 

-Wait for a "connect" event.
+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.

 
 

-\wxheading{See also}
+If you use \helpref{LastCount}{wxsocketbaselastcount}, it will always return {\it nbytes}.

 
 

-\helpref{wxSocketBase::Wait}{wxsocketbasewait} for a detailed description.
+If you use \helpref{Error}{wxsocketbaseerror}, it will always return false.

 
 

-% ---------------------------------------------------------------------------
-% CLASS: wxSocketEvent
-% ---------------------------------------------------------------------------
-\section{\class{wxSocketEvent}}\label{wxsocketevent}
+\wxheading{Parameters}

 
 

-This event class contains information about socket events.
+\docparam{buffer}{Buffer to be unread.}

 
 

-\wxheading{Derived from}
+\docparam{nbytes}{Number of bytes.}

 
 

-\helpref{wxEvent}{wxevent}
+\wxheading{Return value}

 
 

-\wxheading{Include files}
+Returns a reference to the current object.

 
 

-<wx/socket.h>
+\wxheading{See also}

 
 

-\wxheading{Event table macros}
+\helpref{wxSocketBase::Error}{wxsocketbaseerror}, 
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, 
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}

 
 

-To process a socket event, use these event handler macros to direct input to member
-functions that take a wxSocketEvent argument.
+%
+% Wait
+%
+\membersection{wxSocketBase::Wait}\label{wxsocketbasewait}

 
 

-\twocolwidtha{7cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf EVT\_SOCKET(id, func)}}{Process a socket event, supplying the member function.}
-\end{twocollist}%
+\func{bool}{Wait}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}}

 
 

-\wxheading{See also}
+This function waits until any of the following conditions is true:
+                                            
+\begin{itemize}
+\item The socket becomes readable.
+\item The socket becomes writable.
+\item An ongoing connection request has completed (\helpref{wxSocketClient}{wxsocketclient} only)
+\item An incoming connection request has arrived (\helpref{wxSocketServer}{wxsocketserver} only)
+\item The connection has been closed.
+\end{itemize}

 
 

-\helpref{wxSocketHandler}{wxsockethandler},\rtfsp
-\helpref{wxSocketBase}{wxsocketbase},\rtfsp
-\helpref{wxSocketClient}{wxsocketclient},\rtfsp
-\helpref{wxSocketServer}{wxsocketserver}
+Note that it is recommended to use the individual Wait functions
+to wait for the required condition, instead of this one.

 
 

-\latexignore{\rtfignore{\wxheading{Members}}}
+\wxheading{Parameters}

 
 

-\membersection{wxSocketEvent::wxSocketEvent}
+\docparam{seconds}{Number of seconds to wait.
+If -1, it will wait for the default timeout,
+as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.}

 
 

-\func{}{wxSocketEvent}{\param{int}{ id = 0}}
+\docparam{millisecond}{Number of milliseconds to wait.}

 
 

-Constructor.
+\wxheading{Return value}

 
 

-\membersection{wxSocketEvent::SocketEvent}\label{wxsocketeventsocketevent}
+Returns true when any of the above conditions is satisfied,
+false if the timeout was reached.

 
 

-\constfunc{wxSocketBase::wxRequestEvent}{SocketEvent}{\void}
+\wxheading{See also}

 
 

-Returns the socket event type.
+\helpref{wxSocketBase::InterruptWait}{wxsocketbaseinterruptwait}, 
+\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept}, 
+\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}, 
+\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}, 
+\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}, 
+\helpref{wxSocketClient::WaitOnConnect}{wxsocketclientwaitonconnect}

 
 

-% ---------------------------------------------------------------------------
-% CLASS: wxSocketHandler
-% ---------------------------------------------------------------------------
-\section{\class{wxSocketHandler}}\label{wxsockethandler}
+%
+% WaitForLost
+%
+\membersection{wxSocketBase::WaitForLost}\label{wxsocketbasewaitforlost}

 
 

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

 
 

-\helpref{wxObject}{wxobject}
+This function waits until the connection is lost. This may happen if
+the peer gracefully closes the connection or if the connection breaks.

 
 

-\wxheading{Include files}
+\wxheading{Parameters}

 
 

-<wx/socket.h>
+\docparam{seconds}{Number of seconds to wait.
+If -1, it will wait for the default timeout,
+as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.}

 
 

-% ---------------------------------------------------------------------------
-% Members
-% ---------------------------------------------------------------------------
-\latexignore{\rtfignore{\wxheading{Members}}}
+\docparam{millisecond}{Number of milliseconds to wait.}

 
 

-%
-% wxSocketHandler
-%
-\membersection{wxSocketHandler::wxSocketHandler}
+\wxheading{Return value}

 
 

-\func{}{wxSocketHandler}{\void}
+Returns true if the connection was lost, false if the timeout was reached.

 
 

-Constructs a new wxSocketHandler.
+\wxheading{See also}

 
 

-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.
+\helpref{wxSocketBase::InterruptWait}{wxsocketbaseinterruptwait},
+\helpref{wxSocketBase::Wait}{wxsocketbasewait}

 
 %
 
 %

-% ~wxSocketHandler
+% WaitForRead

 %
 %

-\membersection{wxSocketHandler::\destruct{wxSocketHandler}}
+\membersection{wxSocketBase::WaitForRead}\label{wxsocketbasewaitforread}

 
 

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

 
 

-Destroys a wxSocketHandler object.
+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 read operation will complete
+immediately without blocking (unless the {\bf wxSOCKET\_WAITALL} flag
+is set, in which case the operation might still block).

 
 

-%
-% Register
-%
-\membersection{wxSocketHandler::Register}
+\wxheading{Parameters}

 
 

-\func{void}{Register}{\param{wxSocketBase *}{socket}}
+\docparam{seconds}{Number of seconds to wait.
+If -1, it will wait for the default timeout,
+as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.}

 
 

-Register a socket: if it is already registered in this handler it will just
-return immediately.
+\docparam{millisecond}{Number of milliseconds to wait.}

 
 

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

 
 

-\docparam{socket}{Socket to be registered.}
+Returns true if the socket becomes readable, false on timeout.
+
+\wxheading{See also}
+
+\helpref{wxSocketBase::InterruptWait}{wxsocketbaseinterruptwait}, 
+\helpref{wxSocketBase::Wait}{wxsocketbasewait}

 
 %
 
 %

-% UnRegister
+% WaitForWrite

 %
 %

-\membersection{wxSocketHandler::UnRegister}
+\membersection{wxSocketBase::WaitForWrite}\label{wxsocketbasewaitforwrite}

 
 

-\func{void}{UnRegister}{\param{wxSocketBase *}{socket}}
+\func{bool}{WaitForWrite}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}}

 
 

-UnRegister a socket: if it isn't registered in this handler it will just
-return.
+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 write operation is guaranteed to
+complete immediately (unless the {\bf wxSOCKET\_WAITALL} flag is set,
+in which case the operation might still block).

 
 \wxheading{Parameters}
 
 
 \wxheading{Parameters}
 

-\docparam{socket}{Socket to be unregistered.}
+\docparam{seconds}{Number of seconds to wait.
+If -1, it will wait for the default timeout,
+as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.}

 
 

-%
-% Count
-%
-\membersection{wxSocketHandler::Count}
+\docparam{millisecond}{Number of milliseconds to wait.}

 
 

-\constfunc{unsigned long}{Count}{\void}
+\wxheading{Return value}

 
 

-Returns the number of sockets registered in the handler.
+Returns true if the socket becomes writable, false on timeout.

 
 

-\wxheading{Return value}
+\wxheading{See also}

 
 

-Number of sockets registered.
+\helpref{wxSocketBase::InterruptWait}{wxsocketbaseinterruptwait}, 
+\helpref{wxSocketBase::Wait}{wxsocketbasewait}

 
 %
 
 %

-% CreateServer
+% Write

 %
 %

-\membersection{wxSocketHandler::CreateServer}
+\membersection{wxSocketBase::Write}\label{wxsocketbasewrite}

 
 

-\func{wxSocketServer *}{CreateServer}{\param{wxSockAddress\&}{ address}, \param{wxSocketBase::wxSockFlags}{ flags = wxSocketbase::NONE}}
+\func{wxSocketBase\&}{Write}{\param{const void *}{ buffer}, \param{wxUint32}{ nbytes}}

 
 

-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}.
+This function writes a buffer of {\it nbytes} bytes to the socket.

 
 

-\wxheading{Return value}
+Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually written.

 
 

-Returns a new socket server.
+Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded.

 
 

-%
-% CreateClient
-%
-\membersection{wxSocketHandler::CreateClient}
-
-\func{wxSocketServer *}{CreateClient}{\param{wxSocketBase::wxSockFlags}{ flags = wxSocketbase::NONE}}
+\wxheading{Parameters}

 
 

-Creates a new wxSocketClient object. The object is automatically registered
-to the current socket handler.
+\docparam{buffer}{Buffer with the data to be sent.}

 
 

-For a detailed description of the parameters, see \helpref{wxSocketClient::Connect}{wxsocketclientconnect}.
+\docparam{nbytes}{Number of bytes.}

 
 \wxheading{Return value}
 
 
 \wxheading{Return value}
 

-Returns a new socket client.
+Returns a reference to the current object.

 
 

-%
-% Master
-%
-\membersection{wxSocketHandler::Master}\label{wxsockethandlermaster}
+\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}.

 
 

-\func{static wxSocketHandler\&}{Master}{\void}
+\wxheading{See also}

 
 

-Returns a default socket handler.
+\helpref{wxSocketBase::Error}{wxsocketbaseerror}, 
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, 
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, 
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}

 
 %
 
 %

-% Wait
+% WriteMsg

 %
 %

-\membersection{wxSocketHandler::Wait}
+\membersection{wxSocketBase::WriteMsg}\label{wxsocketbasewritemsg}
+
+\func{wxSocketBase\&}{WriteMsg}{\param{const void *}{ buffer}, \param{wxUint32}{ nbytes}}

 
 

-\func{int}{Wait}{\param{long}{ seconds},\param{long}{ microseconds}}
+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.

 
 

-Wait for an event on all registered sockets.
+Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually written.
+
+Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded.

 
 \wxheading{Parameters}
 
 
 \wxheading{Parameters}
 

-\docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
+\docparam{buffer}{Buffer with the data to be sent.}

 
 

-\docparam{microsecond}{Number of microseconds to wait.}
+\docparam{nbytes}{Number of bytes to send.}

 
 \wxheading{Return value}
 
 
 \wxheading{Return value}
 

-Returns 0 if a timeout occured, else the number of events detected.
+Returns a reference to the current object.

 
 

-\wxheading{See also}
+\wxheading{Remark/Warning}

 
 

-\helpref{wxSocketBase::Wait}{wxsocketbasewait}
+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}.

 
 

-%
-% YieldSock
-%
-\membersection{wxSocketHandler::YieldSock}
+\wxheading{See also}

 
 

-\func{void}{YieldSock}{\void}
+\helpref{wxSocketBase::Error}{wxsocketbaseerror}, 
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, 
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, 
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}, 
+\helpref{wxSocketBase::ReadMsg}{wxsocketbasereadmsg}

 
 

-Execute pending requests in all registered sockets.

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

-% CLASS: wxSocketServer
+% CLASS wxSocketClient

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

-\section{\class{wxSocketServer}}\label{wxsocketserver}
+
+\section{\class{wxSocketClient}}\label{wxsocketclient}

 
 \wxheading{Derived from}
 
 
 \wxheading{Derived from}
 


@@ -753,70 +1002,190 @@ Execute pending requests in all registered sockets.
 
 <wx/socket.h>
 
 
 <wx/socket.h>
 

+\latexignore{\rtfignore{\wxheading{Members}}}
+

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

-\latexignore{\rtfignore{\wxheading{Members}}}
-

 %
 %

-% wxSocketServer
+% wxSocketClient

 %
 %

-\membersection{wxSocketServer::wxSocketServer}\label{wxsocketserverconstr}
-
-\func{}{wxSocketServer}{\param{wxSockAddress\&}{ address}, \param{wxSockFlags}{ flags = wxSocketBase::NONE}}
+\membersection{wxSocketClient::wxSocketClient}\label{wxsocketclientctor}

 
 

-Constructs a new wxSocketServer.
+\func{}{wxSocketClient}{\param{wxSocketFlags}{ flags = wxSOCKET\_NONE}}

 
 

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

 
 \wxheading{Parameters}
 
 
 \wxheading{Parameters}
 

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

 \docparam{flags}{Socket flags (See \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags})}
 
 %
 \docparam{flags}{Socket flags (See \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags})}
 
 %

-% ~wxSocketServer
+% ~wxSocketClient

 %
 %

-\membersection{wxSocketServer::\destruct{wxSocketServer}}
+\membersection{wxSocketClient::\destruct{wxSocketClient}}\label{wxsocketclientdtor}

 
 

-\func{}{\destruct{wxSocketServer}}{\void}
+\func{}{\destruct{wxSocketClient}}{\void}

 
 

-Destroys a wxSocketServer object (it doesn't close the accepted connection).
+Destructor. Please see \helpref{wxSocketBase::Destroy}{wxsocketbasedestroy}.

 
 %
 
 %

-% Accept
+% Connect

 %
 %

-\membersection{wxSocketServer::Accept}
+\membersection{wxSocketClient::Connect}\label{wxsocketclientconnect}
+
+\func{bool}{Connect}{\param{wxSockAddress\&}{ address}, \param{bool}{ wait = true}}

 
 

-\func{wxSocketBase *}{Accept}{\void}
+\func{bool}{Connect}{\param{wxSockAddress\&}{ address}, \param{wxSockAddress\&}{ local},
+\param{bool}{ wait = true}}
+
+Connects to a server using the specified address.
+
+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 \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.}

 
 

-Creates a new object wxSocketBase and accepts an incoming connection. {\bf Warning !} This function will block the GUI.
+\docparam{local}{Bind to the specified local address and port before connecting.
+The local address and port can also be set using \helpref{SetLocal}{wxsocketbasesetlocal},
+and then using the 2-parameter Connect method.}
+
+\docparam{wait}{If true, waits for the connection to complete.}

 
 \wxheading{Return value}
 
 
 \wxheading{Return value}
 

-Returns an opened socket connection.
+Returns true if the connection is established and no error occurs.
+
+If {\it wait} was true, and Connect returns false, an error occurred
+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 \helpref{WaitOnConnect}{wxsocketclientwaitonconnect} or by
+watching {\bf wxSOCKET\_CONNECTION} and {\bf wxSOCKET\_LOST} events.

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

-\helpref{wxSocketServer::AcceptWith}{wxsocketserveracceptwith}
+\helpref{wxSocketClient::WaitOnConnect}{wxsocketclientwaitonconnect}, 
+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}, 
+\helpref{wxSocketBase::Notify}{wxsocketbasenotify}

 
 %
 
 %

-% AcceptWith
+% WaitOnConnect

 %
 %

-\membersection{wxSocketServer::AcceptWith}\label{wxsocketserveracceptwith}
+\membersection{wxSocketClient::WaitOnConnect}\label{wxsocketclientwaitonconnect}

 
 

-\func{bool}{AcceptWith}{\param{wxSocketBase\&}{ socket}}
+\func{bool}{WaitOnConnect}{\param{long}{ seconds = -1}, \param{long}{ milliseconds = 0}}

 
 

-Accept an incoming connection using the specified socket object.
-This is useful when someone wants to inherit wxSocketBase.
+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}
 
 
 \wxheading{Parameters}
 

-\docparam{socket}{Socket to be initialized}
+\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}
 
 
 \wxheading{Return value}
 

-Returns TRUE if no error occurs, else FALSE.
+WaitOnConnect returns true if the connection request completes. This
+does not necessarily mean that the connection was successfully established;
+it might also happen that the connection was refused by the peer. Use 
+\helpref{IsConnected}{wxsocketbaseisconnected} to distinguish between
+these two situations.
+
+If the timeout elapses, WaitOnConnect returns false.
+
+These semantics allow code like this:
+
+\begin{verbatim}
+// Issue the connection request
+client->Connect(addr, false);
+
+// Wait until the request completes or until we decide to give up
+bool waitmore = true; 
+while ( !client->WaitOnConnect(seconds, millis) && waitmore )
+{
+    // possibly give some feedback to the user,
+    // and update waitmore as needed.
+}
+bool success = client->IsConnected();
+\end{verbatim}
+
+\wxheading{See also}
+
+\helpref{wxSocketClient::Connect}{wxsocketclientconnect}, 
+\helpref{wxSocketBase::InterruptWait}{wxsocketbaseinterruptwait}, 
+\helpref{wxSocketBase::IsConnected}{wxsocketbaseisconnected}
+
+% ---------------------------------------------------------------------------
+% 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}, 
+\helpref{wxSocketClient}{wxsocketclient}, 
+\helpref{wxSocketServer}{wxsocketserver}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxSocketEvent::wxSocketEvent}\label{wxsocketeventctor}
+
+\func{}{wxSocketEvent}{\param{int}{ id = 0}}
+
+Constructor.
+
+\membersection{wxSocketEvent::GetClientData}\label{wxsocketeventgetclientdata}
+
+\func{void *}{GetClientData}{\void}
+
+Gets the client data of the socket which generated this event, as
+set with \helpref{wxSocketBase::SetClientData}{wxsocketbasesetclientdata}.
+
+\membersection{wxSocketEvent::GetSocket}\label{wxsocketeventgetsocket}
+
+\constfunc{wxSocketBase *}{GetSocket}{\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::GetSocketEvent}\label{wxsocketeventgetsocketevent}
+
+\constfunc{wxSocketNotify}{GetSocketEvent}{\void}
+
+Returns the socket event type.