<wx/socket.h>
-\wxheading{wxSocket errors}{wxsocketerrs}
+\wxheading{wxSocket errors}
\twocolwidtha{7cm}
\begin{twocollist}\itemsep=0pt
\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\_WOULDBLOCK}}{The socket is non-blocking and the operation would block.}
+\twocolitem{{\bf wxSOCKET\_TIMEDOUT}}{The timeout for this operation expired.}
\twocolitem{{\bf wxSOCKET\_MEMERR}}{Memory exhausted.}
-\end{twocollist}%
+\end{twocollist}
-\wxheading{wxSocket events}{wxsocketevents}
+\wxheading{wxSocket events}
\twocolwidtha{7cm}
\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf wxSOCKET\_INPUT}}{Some data are ready to be got.}
+\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}}{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}%
+\twocolitem{{\bf wxSOCKET\_CONNECTION}}{Incoming connection (server), or 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 Connect or accepted with Accept. After that, new
+events will be generated only after an output operation fails
+with {\bf wxSOCKET\_WOULDBLOCK} and buffer space becomes available
+again. This means that the application should assume that it
+can write data to the socket until an {\bf wxSOCKET\_WOULDBLOCK}
+error occurs; after this, whenever the socket becomes writable
+again the application will be notified with another
+{\bf wxSOCKET\_OUTPUT} event.
+
+The {\bf wxSOCKET\_CONNECTION} event is issued when a delayed connection
+request completes succesfully (client) or when a new connection arrives
+at the incoming queue (server).
+
+The {\bf wxSOCKET\_LOST} event is issued when a close indication is
+received for the socket. This means that the connection broke down or
+that it was closed by the peer. Also, this event will be issued if
+a delayed connection request fails.
% ---------------------------------------------------------------------------
% Event handling
\wxheading{Event handling}
To process events from a socket, use the following event handler macro to direct
- input to member
-functions that take a \helpref{wxSocketEvent}{wxsocketevent} argument.
+input to member functions that take a \helpref{wxSocketEvent}{wxsocketevent} argument.
\twocolwidtha{7cm}%
\begin{twocollist}\itemsep=0pt
\twocolitem{{\bf EVT\_SOCKET(id, func)}}{A socket event occured.}
-\end{twocollist}%
+\end{twocollist}
% ---------------------------------------------------------------------------
% See also ...
% ---------------------------------------------------------------------------
\wxheading{See also}
-\helpref{wxSocketEvent}{wxsocketevent}\\
-\helpref{wxSocketClient}{wxsocketclient}\\
+\helpref{wxSocketEvent}{wxsocketevent},
+\helpref{wxSocketClient}{wxsocketclient},
\helpref{wxSocketServer}{wxsocketserver}
% ---------------------------------------------------------------------------
\func{}{wxSocketBase}{\void}
-Default constructor but don't use it, you must use \helpref{wxSocketClient}{wxsocketclient}
+Default constructor. Don't use it; use \helpref{wxSocketClient}{wxsocketclient}
or \helpref{wxSocketServer}{wxsocketserver}.
\membersection{wxSocketBase::\destruct{wxSocketBase}}
\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.}
+\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 wxYield) while reading/writing data.}
\end{twocollist}
+A brief overview on how to use these flags follows.
+
+If no flag is specified (this is the same as {\bf wxSOCKET\_NONE}),
+IO calls will return after some data has been read or written, even
+when the transfer might not be complete. This is the same as issuing
+exactly one blocking low-level call to recv() or send(). Note that
+blocking here refers to when the function returns, not to whether
+the GUI blocks during this time.
+
+If {\bf wxSOCKET\_NOWAIT} is specified, IO calls will return immediately.
+Read operations will retrieve only available data. Write operations will
+write as much data as possible, depending on how much space is available
+in the output buffer. This is the same as issuing exactly one nonblocking
+low-level call to recv() or send(). Note that nonblocking here refers to
+when the function returns, not to whether the GUI blocks during this time.
+
+If {\bf wxSOCKET\_WAITALL} is specified, IO calls won't return until ALL
+the data has been read or written (or until an error occurs), blocking if
+necessary, and issuing several low level calls if necessary. This is the
+same as having a loop which makes as many blocking low-level calls to
+recv() or send() as needed so as to transfer all the data. Note that
+"blocking" here refers to when the function returns, not to whether
+the GUI blocks during this time.
+
+The {\bf wxSOCKET\_BLOCK} flag controls whether the GUI blocks during
+IO operations. If this flag is not used, then the application must take
+extra care to avoid unwanted reentrance.
+
+So:
+
+{\bf wxSOCKET\_NONE} will try to read 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.
+
%
% SetNotify
%
\membersection{wxSocketBase::SetNotify}\label{wxsocketbasesetnotify}
-\func{void}{SetNotify}{\param{wxSocketEventFlags}{ event_flags}}
+\func{void}{SetNotify}{\param{wxSocketEventFlags}{ 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:
+SetNotify specifies which socket events are to be sent to the event handler.
+The {\it flags} parameter is a combination of flags ORed toghether. The
+following flags can be used:
\twocolwidtha{7cm}
\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf wxSOCKET\_INPUT\_FLAG}}{to receive wxSOCKET_INPUT}
-\twocolitem{{\bf wxSOCKET\_OUTPUT\_FLAG}}{to receive wxSOCKET_OUTPUT}
-\twocolitem{{\bf wxSOCKET\_CONNECTION\_FLAG}}{to receive wxSOCKET_CONNECTION}
-\twocolitem{{\bf wxSOCKET\_LOST\_FLAG}}{to receive wxSOCKET_LOST}
-\end{twocollist}%
+\twocolitem{{\bf wxSOCKET\_INPUT\_FLAG}}{to receive wxSOCKET\_INPUT}
+\twocolitem{{\bf wxSOCKET\_OUTPUT\_FLAG}}{to receive wxSOCKET\_OUTPUT}
+\twocolitem{{\bf wxSOCKET\_CONNECTION\_FLAG}}{to receive wxSOCKET\_CONNECTION}
+\twocolitem{{\bf wxSOCKET\_LOST\_FLAG}}{to receive wxSOCKET\_LOST}
+\end{twocollist}
For example:
+
\begin{verbatim}
- sock.SetNotify(wxSOCKET\_INPUT\_FLAG | wxSOCKET\_LOST\_FLAG);
+ sock.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}{wxsocketevents}.
+In this example, the user will be notified about incoming socket data and
+whenever the connection is closed.
+
+For more information on socket events see \helpref{wxSocket events}{wxsocketbase}.
%
% SetTimeout
%
-\membersection{wxSocketBase::SetTimeout}{wxsocketbasesettimeout}
+\membersection{wxSocketBase::SetTimeout}\label{wxsocketbasesettimeout}
+
\func{void}{SetTimeout}{\param{int }{seconds}}
-This function sets the socket timeout in seconds.
+This function sets the default socket timeout in seconds. This
+timeout applies to IO calls, and also to Wait() functions if you
+don't specify a wait interval. If you never use SetTimeout(), the
+default timeout will be 10 minutes.
%
% Notify
\constfunc{bool}{Error}{\void}
-Returns TRUE if an error occured.
+Returns TRUE if an error occured in the last IO operation.
+
+The following operations update the Error() status:
+Read, Write, ReadMsg, WriteMsg, Peek, Unread, Discard.
\membersection{wxSocketBase::IsConnected}\label{wxsocketbaseconnected}
\constfunc{bool}{IsData}{\void}
-Returns TRUE if some data is arrived on the socket.
+Returns TRUE if there is data available to be read.
\membersection{wxSocketBase::IsDisconnected}\label{wxsocketbasedisconnected}
Returns the number of bytes read or written by the last IO call.
+The following operations update the LastCount() value:
+Read, Write, ReadMsg, WriteMsg, Peek, Unread, Discard.
+
\membersection{wxSocketBase::LastError}\label{wxsocketbaselasterror}
\constfunc{wxSocketError}{LastError}{\void}
-Returns the last occured wxSocket error. See \helpref{wxSocket errors}{wxsocketerrs}.
+Returns the last wxSocket error. See \helpref{wxSocket errors}{wxsocketbase}.
+
+Please note that this function merely returns the last error code,
+but it should not be used to determine if an error has occured (this
+is because successful operations do not change the LastError value).
+Use Error, instead of LastError, to determine if the last IO call
+failed. If Error returns TRUE, use LastError to discover the
+cause of the error.
% ---------------------------------------------------------------------------
% IO calls
\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 socket input queue.
+
+Use LastCount to verify the number of bytes actually peeked.
+
+Use Error to determine if the operation succeeded.
\wxheading{Parameters}
Returns a reference to the current object.
+\wxheading{Remark/Warning}
+
+The exact behaviour of wxSocketBase::Peek() depends on the combination
+of flags being used. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}
+
\wxheading{See also}
-\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
+\helpref{wxSocketBase::Error}{wxsocketbaseerror},
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror},
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}
%
% Read
This function reads a buffer of {\it nbytes} bytes from the socket.
+Use LastCount to verify the number of bytes actually read.
+
+Use Error to determine if the operation succeeded.
+
\wxheading{Parameters}
\docparam{buffer}{Buffer where to put read data.}
\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.
+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::LastCount}{wxsocketbaselastcount},
- \helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
+\helpref{wxSocketBase::Error}{wxsocketbaseerror},
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror},
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}
%
% Write
\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 to the socket.
-\wxheading{Remark/Warning}
+Use LastCount to verify the number of bytes actually written.
-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.
+Use Error to determine if the operation succeeded.
\wxheading{Parameters}
-\docparam{buffer}{Buffer where to get the data to write.}
+\docparam{buffer}{Buffer with the data to be sent.}
\docparam{nbytes}{Number of bytes.}
Returns a reference to the current object.
+\wxheading{Remark/Warning}
+
+The exact behaviour of wxSocketBase::Write() depends on the combination
+of flags being used. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}.
+
\wxheading{See also}
-\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
+\helpref{wxSocketBase::Error}{wxsocketbaseerror},
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror},
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}
%
% WriteMsg
\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
-the buffer. So a buffer sent with WriteMsg {\bf must} be read with ReadMsg.
+This function writes a buffer of {\it nbytes} bytes from the socket, but it
+writes a short header before so that ReadMsg 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.
+
+Use LastCount to verify the number of bytes actually written.
+
+Use Error to determine if the operation succeeded.
\wxheading{Parameters}
-\docparam{buffer}{Buffer where to put data peeked.}
+\docparam{buffer}{Buffer with the data to be sent.}
\docparam{nbytes}{Number of bytes.}
Returns a reference to the current object.
+\wxheading{Remark/Warning}
+
+wxSocketBase::WriteMsg() will behave as if the {\bf wxSOCKET\_WAITALL} flag
+was always set and it will always ignore the {\bf wxSOCKET\_NOWAIT} flag.
+The exact behaviour of WriteMsg depends on the {\bf wxSOCKET\_BLOCK} flag.
+For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}.
+
\wxheading{See also}
-\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}\\
+\helpref{wxSocketBase::Error}{wxsocketbaseerror},
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror},
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags},
\helpref{wxSocketBase::ReadMsg}{wxsocketbasereadmsg}
%
\func{wxSocketBase\&}{ReadMsg}{\param{char *}{ buffer}, \param{wxUint32}{ nbytes}}
This function reads a buffer sent by WriteMsg on a socket. If the buffer passed
-to the function isn't big enough, the function filled it and then discard the
-bytes left. This function always wait for the buffer to be entirely filled.
+to the function isn't big enough, the remaining bytes will be discarded. This
+function always waits for the buffer to be entirely filled, unless an error occurs.
+
+Use LastCount to verify the number of bytes actually read.
+
+Use Error to determine if the operation succeeded.
\wxheading{Parameters}
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}
-\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
-\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}\\
+\helpref{wxSocketBase::Error}{wxsocketbaseerror},
+\helpref{wxSocketBase::LastError}{wxsocketbaselasterror},
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
+\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags},
\helpref{wxSocketBase::WriteMsg}{wxsocketbasewritemsg}
%
\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.
-It is useful for sockets because we can't seek it.
+This function unreads a buffer. That is, the data in the buffer is put back
+in the incoming queue. This function is not affected by wxSocket flags.
+
+If you use LastCount, it will always return {\it nbytes}.
+
+If you use Error, it will always return FALSE.
\wxheading{Parameters}
\wxheading{See also}
-\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\
-\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
+\helpref{wxSocketBase::Error}{wxsocketbaseerror},
+\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount},
\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
%
\func{wxSocketBase\&}{Discard}{\void}
This function simply deletes all bytes in the incoming queue. This function
-doesn't wait.
+always returns immediately and its operation is not affected by IO flags.
+
+Use LastCount to see the number of bytes discarded.
+
+If you use Error, it will always return FALSE.
% ---------------------------------------------------------------------------
% Wait functions
\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
-established connection.
+This function waits until one of the following conditions is true: there
+is data available for reading; the output buffer is empty (you can send
+new data); the connection has been lost; an incoming connection arrived
+(only for servers); a connection request has completed (only for clients).
+It is usually better to use the individual Wait functions to wait for the
+required condition.
\wxheading{Parameters}
-\docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
+\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
\docparam{millisecond}{Number of milliseconds to wait.}
\wxheading{See also}
-\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}\\
-\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}\\
+\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread},
+\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite},
\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
%
\func{bool}{WaitForRead}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}}
-This function waits for a read event.
+This function waits until there is data available to be read.
\wxheading{Parameters}
-\docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
+\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
\docparam{millisecond}{Number of milliseconds to wait.}
\wxheading{Return value}
-Returns TRUE if a byte arrived, FALSE if the timeout was reached.
+Returns TRUE if there is data to be read, FALSE if the timeout was reached.
\wxheading{See also}
-\helpref{wxSocketBase::Wait}{wxsocketbasewait}\\
-\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}\\
+\helpref{wxSocketBase::Wait}{wxsocketbasewait},
+\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite},
\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
%
\func{bool}{WaitForWrite}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}}
-This function waits for a write event.
+This function waits until you can write to the socket.
\wxheading{Parameters}
-\docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
+\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
\docparam{millisecond}{Number of milliseconds to wait.}
\wxheading{Return value}
-Returns TRUE if a write event occured, FALSE if the timeout was reached.
+Returns TRUE if you can write to the socket, FALSE if the timeout was reached.
\wxheading{See also}
-\helpref{wxSocketBase::Wait}{wxsocketbasewait}\\
-\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}\\
+\helpref{wxSocketBase::Wait}{wxsocketbasewait},
+\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread},
\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
%
\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 until the connection is lost. This may happen if the
+peer closes the connection or if the connection breaks.
\wxheading{Parameters}
-\docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.}
+\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
\docparam{millisecond}{Number of milliseconds to wait.}
\wxheading{Return value}
-Returns TRUE if a "lost" event occured, FALSE if the timeout was reached.
+Returns TRUE if the connection was lost, FALSE if the timeout was reached.
\wxheading{See also}
-\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}\\
-\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}\\
+\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread},
+\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite},
\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
+% ---------------------------------------------------------------------------
+% Socket state
+% ---------------------------------------------------------------------------
+
%
% RestoreState
%
\func{void}{RestoreState}{\void}
-This function restores a previously saved state.
+This function restores the previous state of the socket, as saved
+with SaveState.
+
+Calls to SaveState / RestoreState can be nested.
\wxheading{See also}
\helpref{wxSocketBase::SaveState}{wxsocketbasesavestate}
-% ---------------------------------------------------------------------------
-% Socket state
-% ---------------------------------------------------------------------------
%
% SaveState
%
\func{void}{SaveState}{\void}
This function saves the current state of the socket object in a stack:
-actually it saves all flags and the state of the asynchronous callbacks.
-
-\wxheading{See also}
+actually it saves all flags (those set with SetFlags, SetNotify, Notify)
+and the state of the asynchronous callbacks (Callback, CallbackData).
-%
-% SaveState
-%
-
-\helpref{wxSocketBase::RestoreState}{wxsocketbaserestorestate}
-\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).
+Calls to SaveState / RestoreState can be nested.
\wxheading{See also}
-\helpref{wxSocketBase::SaveState}{wxsocketbasesavestate}
+\helpref{wxSocketBase::RestoreState}{wxsocketbaserestorestate}
%
% GetLocal
%
\membersection{wxSocketBase::GetLocal}{wxsocketbasegetlocal}
-\constfunc{bool}{GetLocal}{\param{wxSockAddress\& }{addr_man}}
+
+\constfunc{bool}{GetLocal}{\param{wxSockAddress\& }{addr\_man}}
This function returns the local address field of the socket. The local
address field contains the complete local address of the socket (local
% GetPeer
%
\membersection{wxSocketBase::GetPeer}{wxsocketbasegetlocal}
-\constfunc{bool}{GetPeer}{\param{wxSockAddress\& }{addr_man}}
+
+\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
\func{void}{SetEventHandler}{\param{wxEvtHandler\&}{ evt\_hdlr}, \param{int}{ id = -1}}
-Sets an event handler to be called when a socket event occured.
+Sets an event handler to be called when a socket event occurs. The handler
+will be called for those events for which notification is enabled with
+SetNotify and Notify.
+
+You can also specify a callback function to be called when an event occurs.
+See \helpref{Callback}{wxsocketbasecallback} and \helpref{CallbackData}{wxsocketbasecallbackdata}.
\wxheading{Parameters}
\wxheading{See also}
-\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}
-\helpref{wxSocketBase::Notify}{wxsocketbasenotify}
-\helpref{wxSocketEvent}{wxsocketevent}
-\helpref{wxEvtHandler}{wxevthandler}
+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
+\helpref{wxSocketBase::Notify}{wxsocketbasenotify},
+\helpref{wxSocketEvent}{wxsocketevent},
+\helpref{wxEvtHandler}{wxevthandler},
+\helpref{wxSocketBase::Callback}{wxsocketbasecallback},
+\helpref{wxSocketBase::CallbackData}{wxsocketbasecallbackdata}
\membersection{wxSocketBase::Callback}\label{wxsocketbasecallback}
\func{wxSocketBase::wxSockCbk}{Callback}{\param{wxSocketBase::wxSockCbk}{ callback}}
-wxSocket event handler can call C callback. This function allows you to set it.
-The format of the callback is as followed:
+You can setup a callback function to be called when an event occurs. The function
+will be called only for those events for which notification has been enabled
+with Notify and SetNotify. The prototype of the callback must be as follows:
+
\begin{verbatim}
-void SocketCallback(wxSocketBase& sock,wxSocketNotify evt,char *cdata);
+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}{wxsocketevents}).
-The third parameters is the client data you specified using \helpref{CallbackData}{wxsocketcallbackdata}.
+The first parameter is a reference to the socket object in which the event
+occured. The second parameter tells you which event occured. (See \helpref{wxSocket events}{wxsocketbase}).
+The third parameter is the user data you specified using \helpref{CallbackData}{wxsocketbasecallbackdata}.
\wxheading{Return value}
-It returns the previous callback.
+A pointer to the previous callback.
\wxheading{See also}
-\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}
+\helpref{wxSocketBase::CallbackData}{wxsocketbasecallbackdata},
+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
\helpref{wxSocketBase::Notify}{wxsocketbasenotify}
-\membersection{wxSocketBase::CallbackData}\label{wxsocketcallbackdata}
+\membersection{wxSocketBase::CallbackData}\label{wxsocketbasecallbackdata}
\func{char *}{CallbackData}{\param{char *}{cdata}}
-This function sets the the client data which will be passed to a \helpref{C callback}{wxsocketcallback}.
+This function sets the the user data which will be passed to a
+callback function set via \helpref{Callback}{wxsocketbasecallback}.
\wxheading{Return value}
-This function returns the old value of the client data pointer.
+A pointer to the previous user data.
+
+\helpref{wxSocketBase::Callback}{wxsocketbasecallback},
+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
+\helpref{wxSocketBase::Notify}{wxsocketbasenotify}
% ---------------------------------------------------------------------------
% CLASS wxSocketClient
\func{bool}{Connect}{\param{wxSockAddress\&}{ address}, \param{bool}{ wait = TRUE}}
-Connects to a server using the specified address. If {\it wait} is TRUE, Connect
-will wait for the socket ready to send or receive data.
+Connects to a server using the specified address.
+
+If {\it wait} is TRUE, Connect will wait until the connection completes
+successfully, or until an event occurs. {\bf Warning !} This will block the GUI.
+
+If {\it wait} is FALSE, Connect will try to establish the connection and
+return immediately, without blocking the GUI. When used this way, even if
+Connect returns FALSE, the connection request can be completed later.
+To detect this, use WaitConnection, or catch {\bf wxSOCKET\_CONNECTION}
+events (for successful establishment) and {\bf wxSOCKET\_LOST} events
+(for connection failure).
\wxheading{Parameters}
\docparam{address}{Address of the server.}
-\docparam{wait}{If true, waits for the connection to be ready.}
+\docparam{wait}{If TRUE, waits for the connection to be ready.}
\wxheading{Return value}
Returns TRUE if the connection is established and no error occurs.
+If {\it wait} was TRUE, and Connect returns FALSE, an error occured
+and the connection failed.
+
+If {\it wait} was FALSE, and Connect returns FALSE, you should still
+be prepared to handle the completion of this connection request, either
+with WaitOnConnect or by watching {\bf wxSOCKET\_CONNECTION} and
+{\bf wxSOCKET\_LOST} events.
+
\wxheading{See also}
-\helpref{wxSocketClient::WaitOnConnect}{wxsocketclientwaitonconnect}
+\helpref{wxSocketClient::WaitOnConnect}{wxsocketclientwaitonconnect},
+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
+\helpref{wxSocketBase::Notify}{wxsocketbasenotify}
%
% WaitOnConnect
\func{bool}{WaitOnConnect}{\param{long}{ seconds = -1}, \param{long}{ milliseconds = 0}}
-Wait for a "connect" event.
+Wait until the connection is succesfully established or until it fails.
+Use this function after a call to Connect with {\it wait} set to FALSE.
+
+\wxheading{Parameters}
+
+\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
+
+\docparam{millisecond}{Number of milliseconds to wait.}
+
+\wxheading{Return value}
+
+If the connection is succesfully established, it returns TRUE.
+
+If the timeout expires, or if the connection fails, it returns FALSE.
\wxheading{See also}
-\helpref{wxSocketBase::Wait}{wxsocketbasewait} for a detailed description.
+\helpref{wxSocketClient::Connect}{wxsocketclientconnect}
% ---------------------------------------------------------------------------
% CLASS: wxSocketEvent
\wxheading{See also}
-\helpref{wxSocketBase}{wxsocketbase},\rtfsp
-\helpref{wxSocketClient}{wxsocketclient},\rtfsp
+\helpref{wxSocketBase}{wxsocketbase},
+\helpref{wxSocketClient}{wxsocketclient},
\helpref{wxSocketServer}{wxsocketserver}
\latexignore{\rtfignore{\wxheading{Members}}}
Constructor.
+\membersection{wxSocketEvent::Socket}\label{wxsocketeventsocket}
+
+\constfunc{wxSocketBase *}{Socket}{\void}
+
+Returns the socket object to which this event refers to. This makes
+it possible to use the same event handler for different sockets.
+
\membersection{wxSocketEvent::SocketEvent}\label{wxsocketeventsocketevent}
\constfunc{wxSocketNotify}{SocketEvent}{\void}
\func{}{\destruct{wxSocketServer}}{\void}
-Destroys a wxSocketServer object (it doesn't close the accepted connection).
+Destroys a wxSocketServer object (it doesn't close the accepted connections).
%
% Accept
%
-\membersection{wxSocketServer::Accept}
+\membersection{wxSocketServer::Accept}\label{wxsocketserveraccept}
+
+\func{wxSocketBase *}{Accept}{\param{bool}{ wait = TRUE}}
-\func{wxSocketBase *}{Accept}{\void}
+Creates a new object wxSocketBase and accepts an incoming connection.
-Creates a new object wxSocketBase and accepts an incoming connection. {\bf Warning !} This function will block the GUI.
+If {\it wait} is TRUE and there are no pending connections to be
+accepted, it will wait for the next incoming connection to arrive.
+{\bf Warning !} This will block the GUI.
+
+If {\it wait} is FALSE, it will try to accept a pending connection
+if there is one, but it will always return immediately without
+blocking the GUI. If you want to use Accept in this way, you can
+either check for incoming connections with WaitForAccept or watch
+{\bf wxSOCKET\_CONNECTION} events, then call Accept once you know
+that there is an incoming connection waiting to be accepted.
\wxheading{Return value}
-Returns an opened socket connection.
+Returns an opened socket connection, or NULL if an error occured or
+if the {\it wait} parameter was FALSE and there were no pending
+connections.
\wxheading{See also}
+\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept},
+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
+\helpref{wxSocketBase::Notify}{wxsocketbasenotify},
\helpref{wxSocketServer::AcceptWith}{wxsocketserveracceptwith}
%
%
\membersection{wxSocketServer::AcceptWith}\label{wxsocketserveracceptwith}
-\func{bool}{AcceptWith}{\param{wxSocketBase\&}{ socket}}
+\func{bool}{AcceptWith}{\param{wxSocketBase\&}{ socket}, \param{bool}{ wait = TRUE}}
Accept an incoming connection using the specified socket object.
-This is useful when someone wants to inherit wxSocketBase.
\wxheading{Parameters}
\wxheading{Return value}
-Returns TRUE if no error occurs, else FALSE.
+Returns TRUE on success, or FALSE if an error occured or if the
+{\it wait} parameter was FALSE and there were no pending
+connections.
+
+\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept},
+\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify},
+\helpref{wxSocketBase::Notify}{wxsocketbasenotify},
+\helpref{wxSocketServer::Accept}{wxsocketserveraccept} for a detailed explanation
+
+%
+% WaitForAccept
+%
+\membersection{wxSocketServer::WaitForAccept}\label{wxsocketserverwaitforaccept}
+
+\func{bool}{WaitForAccept}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}}
+
+This function waits for an incoming connection. Use it if you want to call
+Accept or AcceptWith with {\it wait} set to FALSE, to detect when an incoming
+connection is waiting to be accepted.
+
+\wxheading{Parameters}
+
+\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.}
+
+\docparam{millisecond}{Number of milliseconds to wait.}
+
+\wxheading{Return value}
+
+Returns TRUE if an incoming connection arrived, FALSE if the timeout expired.
+
+\wxheading{See also}
+
+\helpref{wxSocketServer::Accept}{wxsocketserveraccept},
+\helpref{wxSocketServer::AcceptWith}{wxsocketserveracceptwith}
projects / wxWidgets.git / blobdiff