X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/42ff6409d9aff9ba1b771842a256feaeb40e28cd..2cb20bea55c193c991b1e4953597370c815717ad:/docs/latex/wx/socket.tex diff --git a/docs/latex/wx/socket.tex b/docs/latex/wx/socket.tex index 7216280a3a..eae9022e3c 100644 --- a/docs/latex/wx/socket.tex +++ b/docs/latex/wx/socket.tex @@ -1,52 +1,240 @@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% Name: socket.tex +%% Purpose: wxSocket docs +%% Author: Guillermo Rodriguez Garcia +%% Modified by: +%% Created: 1999 +%% RCS-ID: $Id$ +%% Copyright: (c) wxWindows team +%% Licence: wxWindows licence +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \section{\class{wxSocketBase}}\label{wxsocketbase} \wxheading{Derived from} \helpref{wxEvtHandler}{wxevthandler} -% --------------------------------------------------------------------------- -% Event handling -% --------------------------------------------------------------------------- +\wxheading{Include files} + + + +\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 (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 \helpref{Connect}{wxsocketclientconnect} or accepted +with \helpref{Accept}{wxsocketserveraccept}. After that, new +events will be generated only after an output operation fails +with {\bf wxSOCKET\_WOULDBLOCK} and buffer space becomes available +again. This means that the application should assume that it +can write data to the socket until an {\bf wxSOCKET\_WOULDBLOCK} +error occurs; after this, whenever the socket becomes writable +again the application will be notified with another +{\bf wxSOCKET\_OUTPUT} event. + +The {\bf wxSOCKET\_CONNECTION} event is issued when a delayed connection +request completes succesfully (client) or when a new connection arrives +at the incoming queue (server). + +The {\bf wxSOCKET\_LOST} event is issued when a close indication is +received for the socket. This means that the connection broke down or +that it was closed by the peer. Also, this event will be issued if +a delayed connection request fails. + \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{wxSocketServer}{wxsocketserver} +\helpref{wxSocketEvent}{wxsocketevent}, +\helpref{wxSocketClient}{wxsocketclient}, +\helpref{wxSocketServer}{wxsocketserver}, +\helpref{Sockets sample}{samplesockets} % --------------------------------------------------------------------------- % Members % --------------------------------------------------------------------------- + \latexignore{\rtfignore{\wxheading{Members}}} \membersection{wxSocketBase::wxSocketBase} \func{}{wxSocketBase}{\void} -Default constructor but don't use it, you must use \helpref{wxSocketClient}{wxsocketclient} +Default constructor. Don't use it; use \helpref{wxSocketClient}{wxsocketclient} or \helpref{wxSocketServer}{wxsocketserver}. \membersection{wxSocketBase::\destruct{wxSocketBase}} \func{}{\destruct{wxSocketBase}}{\void} -Destroys the wxSocketBase object. +Destructor. % --------------------------------------------------------------------------- % State functions % --------------------------------------------------------------------------- +% +% SetFlags +% + +\membersection{wxSocketBase::SetFlags}\label{wxsocketbasesetflags} + +\func{void}{SetFlags}{\param{wxSocketBase::wxSockFlags}{ flags}} + +\twocolwidtha{7cm} +\begin{twocollist}\itemsep=0pt +\twocolitem{{\bf wxSOCKET\_NONE}}{Normal functionality.} +\twocolitem{{\bf wxSOCKET\_NOWAIT}}{Read/write as much data as possible and return immediately.} +\twocolitem{{\bf wxSOCKET\_WAITALL}}{Wait for all required data to be read/written unless an error occurs.} +\twocolitem{{\bf wxSOCKET\_BLOCK}}{Block the GUI (do not yield) while reading/writing data.} +\end{twocollist} + +A brief overview on how to use these flags follows. + +If no flag is specified (this is the same as {\bf wxSOCKET\_NONE}), +IO calls will return after some data has been read or written, even +when the transfer might not be complete. This is the same as issuing +exactly one blocking low-level call to recv() or send(). Note that +{\it blocking} here refers to when the function returns, not to whether +the GUI blocks during this time. + +If {\bf wxSOCKET\_NOWAIT} is specified, IO calls will return immediately. +Read operations will retrieve only available data. Write operations will +write as much data as possible, depending on how much space is available +in the output buffer. This is the same as issuing exactly one nonblocking +low-level call to recv() or send(). Note that {\it nonblocking} here +refers to when the function returns, not to whether the GUI blocks during +this time. + +If {\bf wxSOCKET\_WAITALL} is specified, IO calls won't return until ALL +the data has been read or written (or until an error occurs), blocking if +necessary, and issuing several low level calls if necessary. This is the +same as having a loop which makes as many blocking low-level calls to +recv() or send() as needed so as to transfer all the data. Note that +{\it blocking} here refers to when the function returns, not to whether +the GUI blocks during this time. + +The {\bf wxSOCKET\_BLOCK} flag controls whether the GUI blocks during +IO operations. If this flag is specified, the socket will not yield +during IO calls, so the GUI will remain blocked until the operation +completes. If it is not used, then the application must take extra +care to avoid unwanted reentrance. + +So: + +{\bf wxSOCKET\_NONE} will try to read at least SOME data, no matter how much. + +{\bf wxSOCKET\_NOWAIT} will always return immediately, even if it cannot +read or write ANY data. + +{\bf wxSOCKET\_WAITALL} will only return when it has read or written ALL +the data. + +{\bf wxSOCKET\_BLOCK} has nothing to do with the previous flags and +it controls whether the GUI blocks. + +% +% SetNotify +% +\membersection{wxSocketBase::SetNotify}\label{wxsocketbasesetnotify} + +\func{void}{SetNotify}{\param{wxSocketEventFlags}{ flags}} + +SetNotify specifies which socket events are to be sent to the event handler. +The {\it flags} parameter is a combination of flags ORed toghether. The +following flags can be used: + +\twocolwidtha{7cm} +\begin{twocollist}\itemsep=0pt +\twocolitem{{\bf wxSOCKET\_INPUT\_FLAG}}{to receive wxSOCKET\_INPUT} +\twocolitem{{\bf wxSOCKET\_OUTPUT\_FLAG}}{to receive wxSOCKET\_OUTPUT} +\twocolitem{{\bf wxSOCKET\_CONNECTION\_FLAG}}{to receive wxSOCKET\_CONNECTION} +\twocolitem{{\bf wxSOCKET\_LOST\_FLAG}}{to receive wxSOCKET\_LOST} +\end{twocollist} + +For example: + +\begin{verbatim} + sock.SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG); + sock.Notify(TRUE); +\end{verbatim} + +In this example, the user will be notified about incoming socket data and +whenever the connection is closed. + +For more information on socket events see \helpref{wxSocket events}{wxsocketbase}. + +% +% SetTimeout +% +\membersection{wxSocketBase::SetTimeout}\label{wxsocketbasesettimeout} + +\func{void}{SetTimeout}{\param{int }{seconds}} + +This function sets the default socket timeout in seconds. This timeout +applies to all IO calls, and also to the \helpref{Wait}{wxsocketbasewait} +family of functions if you don't specify a wait interval. Initially, the +default is set to 10 minutes. + +% +% Notify +% +\membersection{wxSocketBase::Notify}\label{wxsocketbasenotify} + +\func{void}{Notify}{\param{bool}{ notify}} + +According to the {\it notify} value, this function enables +or disables socket events. If {\it notify} is TRUE, the events +configured with \helpref{SetNotify}{wxsocketbasesetnotify} will +be sent to the application. If {\it notify} is FALSE; no events +will be sent. + +% +% Ok +% + \membersection{wxSocketBase::Ok}\label{wxsocketbaseok} \constfunc{bool}{Ok}{\void} @@ -58,9 +246,12 @@ cases. \constfunc{bool}{Error}{\void} -Returns TRUE if an error occured. +Returns TRUE if an error occured in the last IO operation. -\membersection{wxSocketBase::IsConnected}\label{wxsocketbaseconnected} +Use this function to check for an error condition after one of the +following calls: Read, Write, ReadMsg, WriteMsg, Peek, Unread, Discard. + +\membersection{wxSocketBase::IsConnected}\label{wxsocketbaseisconnected} \constfunc{bool}{IsConnected}{\void} @@ -70,31 +261,36 @@ Returns TRUE if the socket is connected. \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} \constfunc{bool}{IsDisconnected}{\void} -Returns TRUE if the socket is disconnected. - -\membersection{wxSocketBase::IsNoWait}\label{wxsocketbasenowait} - -\constfunc{bool}{IsNoWait}{\void} - -Returns TRUE if the socket mustn't wait. +Returns TRUE if the socket is not connected. \membersection{wxSocketBase::LastCount}\label{wxsocketbaselastcount} -\constfunc{size\_t}{LastCount}{\void} +\constfunc{wxUint32}{LastCount}{\void} Returns the number of bytes read or written by the last IO call. +Use this function to get the number of bytes actually transferred +after using one of the following IO calls: Read, Write, ReadMsg, +WriteMsg, Peek, Unread, Discard. + \membersection{wxSocketBase::LastError}\label{wxsocketbaselasterror} -\constfunc{int}{LastError}{\void} +\constfunc{wxSocketError}{LastError}{\void} + +Returns the last wxSocket error. See \helpref{wxSocket errors}{wxsocketbase}. -Returns an error in the errno format (see your C programmer's guide). +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 \helpref{Error}{wxsocketbaseerror} first, in order to determine +if the last IO call failed. If this returns TRUE, use LastError() +to discover the cause of the error. % --------------------------------------------------------------------------- % IO calls @@ -104,10 +300,14 @@ Returns an error in the errno format (see your C programmer's guide). % \membersection{wxSocketBase::Peek}\label{wxsocketbasepeek} -\func{wxSocketBase\&}{Peek}{\param{char *}{ buffer}, \param{size\_t}{ nbytes}} +\func{wxSocketBase\&}{Peek}{\param{char *}{ buffer}, \param{wxUint32}{ nbytes}} + +This function peeks a buffer of {\it nbytes} bytes from the socket. +Peeking a buffer doesn't delete it from the socket input queue. + +Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually peeked. -This function peeks a buffer of {\it nbytes} bytes from the socket. Peeking a buffer -doesn't delete it from the system socket in-queue. +Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded. \wxheading{Parameters} @@ -119,21 +319,31 @@ doesn't delete it from the system socket in-queue. 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 % \membersection{wxSocketBase::Read}\label{wxsocketbaseread} -\func{wxSocketBase\&}{Read}{\param{char *}{ buffer}, \param{size\_t}{ nbytes}} +\func{wxSocketBase\&}{Read}{\param{char *}{ buffer}, \param{wxUint32}{ nbytes}} This function reads a buffer of {\it nbytes} bytes from the socket. +Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually read. + +Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded. + \wxheading{Parameters} \docparam{buffer}{Buffer where to put read data.} @@ -144,30 +354,34 @@ This function reads a buffer of {\it nbytes} bytes from the socket. Returns a reference to the current object. -\wxheading{See also} +\wxheading{Remark/Warning} -\helpref{wxSocketBase::Error}{wxsocketbaseerror}, - \helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, - \helpref{wxSocketBase::LastError}{wxsocketbaselasterror} - -\membersection{wxSocketBase::SetFlags}\label{wxsocketbasesetflags} +The exact behaviour of wxSocketBase::Read() depends on the combination +of flags being used. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}. -\func{void}{SetFlags}{\param{wxSockFlags}{ flags}} +\wxheading{See also} -TODO +\helpref{wxSocketBase::Error}{wxsocketbaseerror}, +\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, +\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, +\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags} % -% Read +% Write % \membersection{wxSocketBase::Write}\label{wxsocketbasewrite} -\func{wxSocketBase\&}{Write}{\param{const char *}{ buffer}, \param{size\_t}{ nbytes}} +\func{wxSocketBase\&}{Write}{\param{const char *}{ buffer}, \param{wxUint32}{ nbytes}} -This function writes a buffer of {\it nbytes} bytes from the socket. +This function writes a buffer of {\it nbytes} bytes to the socket. + +Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually written. + +Use \helpref{Error}{wxsocketbaseerror} 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.} @@ -175,78 +389,114 @@ This function writes a buffer of {\it nbytes} bytes from the socket. 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 % \membersection{wxSocketBase::WriteMsg}\label{wxsocketbasewritemsg} -\func{wxSocketBase\&}{WriteMsg}{\param{const char *}{ buffer}, \param{size\_t}{ nbytes}} +\func{wxSocketBase\&}{WriteMsg}{\param{const char *}{ buffer}, \param{wxUint32}{ nbytes}} -This function writes a buffer of {\it nbytes} bytes from the socket. But it -writes a short header before so that ReadMsg can alloc the right size for -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 \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. + +Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually written. + +Use \helpref{Error}{wxsocketbaseerror} 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.} +\docparam{nbytes}{Number of bytes to send.} \wxheading{Return value} 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::ReadMsg}{wxsocketbasereadmsg} +\helpref{wxSocketBase::Error}{wxsocketbaseerror}, +\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, +\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, +\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}, +\helpref{wxSocketBase::ReadMsg}{wxsocketbasereadmsg} % % ReadMsg % \membersection{wxSocketBase::ReadMsg}\label{wxsocketbasereadmsg} -\func{wxSocketBase\&}{ReadMsg}{\param{char *}{ buffer}, \param{size\_t}{ nbytes}} +\func{wxSocketBase\&}{ReadMsg}{\param{char *}{ buffer}, \param{wxUint32}{ nbytes}} + +This function reads a buffer sent by \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. -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. +Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually read. + +Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded. \wxheading{Parameters} \docparam{buffer}{Buffer where to put read data.} -\docparam{nbytes}{Number of bytes allocated for the buffer.} +\docparam{nbytes}{Size of the buffer.} \wxheading{Return value} 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::WriteMsg}{wxsocketbasewritemsg} +\helpref{wxSocketBase::Error}{wxsocketbaseerror}, +\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, +\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, +\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}, +\helpref{wxSocketBase::WriteMsg}{wxsocketbasewritemsg} % % Unread % -\membersection{wxSocketBase::UnRead}\label{wxsocketbaseunread} +\membersection{wxSocketBase::Unread}\label{wxsocketbaseunread} + +\func{wxSocketBase\&}{Unread}{\param{const char *}{ buffer}, \param{wxUint32}{ nbytes}} -\func{wxSocketBase\&}{UnRead}{\param{const char *}{ buffer}, \param{size\_t}{ nbytes}} +This function unreads a buffer. That is, the data in the buffer is put back +in the incoming queue. This function is not affected by wxSocket flags. -This function unreads a buffer. It means that the buffer is put in the top -of the incoming queue. But, it is put also at the end of all unread buffers. -It is useful for sockets because we can't seek it. +If you use \helpref{LastCount}{wxsocketbaselastcount}, it will always return {\it nbytes}. + +If you use \helpref{Error}{wxsocketbaseerror}, it will always return FALSE. \wxheading{Parameters} @@ -260,9 +510,9 @@ Returns a reference to the current object. \wxheading{See also} -\helpref{wxSocketBase::Error}{wxsocketbaseerror}, - \helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, - \helpref{wxSocketBase::LastError}{wxsocketbaselasterror} +\helpref{wxSocketBase::Error}{wxsocketbaseerror}, +\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, +\helpref{wxSocketBase::LastError}{wxsocketbaselasterror} % % Discard @@ -272,110 +522,139 @@ Returns a reference to the current object. \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 \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually discarded. + +If you use \helpref{Error}{wxsocketbaseerror}, it will always return FALSE. % --------------------------------------------------------------------------- % Wait functions % --------------------------------------------------------------------------- \membersection{wxSocketBase::Wait}\label{wxsocketbasewait} -\func{bool}{Wait}{\param{long}{ seconds = -1}, \param{long}{ microsecond = 0}} +\func{bool}{Wait}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}} -This function waits for an event: it could be an incoming byte, the possibility -for the client to write, a lost connection, an incoming connection, an -established connection. +This function waits until one of the following conditions is TRUE. Note +that it is recommended to use the individual Wait functions to wait for +the required condition, instead of this one. + +\begin{itemize} +\item There is data available for reading. +\item The socket becomes writable. +\item An ongoing connection request has completed (only for clients) +\item An incoming connection request has arrived (only for servers) +\item The connection has been closed. +\end{itemize} \wxheading{Parameters} -\docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.} +\docparam{seconds}{Number of seconds to wait. +If -1, it will wait for the default timeout, +as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.} -\docparam{microsecond}{Number of microseconds to wait.} +\docparam{millisecond}{Number of milliseconds to wait.} \wxheading{Return value} -Returns TRUE if an event occured, FALSE if the timeout was reached. +Returns TRUE when any of the above conditions is satisfied, +FALSE if the timeout was reached. \wxheading{See also} -\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}, - \helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}, - \helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost} +\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}, +\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}, +\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost} % % WaitForRead % \membersection{wxSocketBase::WaitForRead}\label{wxsocketbasewaitforread} -\func{bool}{WaitForRead}{\param{long}{ seconds = -1}, \param{long}{ microsecond = 0}} +\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, or until +an error occurs. \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, +as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.} -\docparam{microsecond}{Number of microseconds to wait.} +\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 +or an error occured. \wxheading{See also} -\helpref{wxSocketBase::Wait}{wxsocketbasewait}, - \helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}, - \helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost} +\helpref{wxSocketBase::Wait}{wxsocketbasewait}, +\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}, +\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost} % % WaitForWrite % \membersection{wxSocketBase::WaitForWrite}\label{wxsocketbasewaitforwrite} -\func{bool}{WaitForWrite}{\param{long}{ seconds = -1}, \param{long}{ microsecond = 0}} +\func{bool}{WaitForWrite}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}} -This function waits for a write event. +This function waits until the socket is ready to send data, +or until an error occurs. \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, +as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.} -\docparam{microsecond}{Number of microseconds to wait.} +\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 or an error occured. \wxheading{See also} -\helpref{wxSocketBase::Wait}{wxsocketbasewait}, - \helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}, - \helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost} +\helpref{wxSocketBase::Wait}{wxsocketbasewait}, +\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}, +\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost} % % WaitForLost % \membersection{wxSocketBase::WaitForLost}\label{wxsocketbasewaitforlost} -\func{bool}{Wait}{\param{long}{ seconds = -1}, \param{long}{ microsecond = 0}} +\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 gracefully 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, +as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.} -\docparam{microsecond}{Number of microseconds to wait.} +\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::WaitForLost}{wxsocketbasewaitforlost} +\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}, +\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}, +\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost} + +% --------------------------------------------------------------------------- +% Socket state +% --------------------------------------------------------------------------- % % RestoreState @@ -384,15 +663,15 @@ Returns TRUE if a "lost" event occured, FALSE if the timeout was reached. \func{void}{RestoreState}{\void} -This function restores a previously saved state. +This function restores the previous state of the socket, as saved +with \helpref{SaveState}{wxsocketbasesavestate} + +Calls to SaveState and RestoreState can be nested. \wxheading{See also} \helpref{wxSocketBase::SaveState}{wxsocketbasesavestate} -% --------------------------------------------------------------------------- -% Socket state -% --------------------------------------------------------------------------- % % SaveState % @@ -400,13 +679,49 @@ This function restores a previously saved state. \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. +This function saves the current state of the socket in a stack. Socket +state includes flags, as set with \helpref{SetFlags}{wxsocketbasesetflags}, +event mask, as set with \helpref{SetNotify}{wxsocketbasesetnotify} and +\helpref{Notify}{wxsocketbasenotify}, and current settings for the +asynchronous callbacks, as set with \helpref{Callback}{wxsocketbasecallback} +and \helpref{CallbackData}{wxsocketbasecallbackdata}. + +Calls to SaveState and RestoreState can be nested. \wxheading{See also} \helpref{wxSocketBase::RestoreState}{wxsocketbaserestorestate} +% +% GetLocal +% +\membersection{wxSocketBase::GetLocal}\label{wxsocketbasegetlocal} + +\constfunc{bool}{GetLocal}{\param{wxSockAddress\& }{addr\_man}} + +This function returns the local address field of the socket. The local +address field contains the complete local address of the socket (local +address, local port, ...). + +\wxheading{Return value} + +It returns TRUE if no errors happened, FALSE otherwise. + +% +% GetPeer +% +\membersection{wxSocketBase::GetPeer}\label{wxsocketbasegetpeer} + +\constfunc{bool}{GetPeer}{\param{wxSockAddress\& }{addr\_man}} + +This function returns the peer address field of the socket. The peer +address field contains the complete peer host address of the socket +(address, port, ...). + +\wxheading{Return value} + +It returns TRUE if no errors happened, FALSE otherwise. + % --------------------------------------------------------------------------- % Socket callbacks % --------------------------------------------------------------------------- @@ -414,7 +729,15 @@ actually it saves all flags and the state of the asynchronous callbacks. \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 \helpref{SetNotify}{wxsocketbasesetnotify} and +\helpref{Notify}{wxsocketbasenotify}. + +You can also specify a callback function to be called when an event +occurs, although if possible, events should be used instead of callbacks. +See \helpref{Callback}{wxsocketbasecallback} and +\helpref{CallbackData}{wxsocketbasecallbackdata}. \wxheading{Parameters} @@ -424,7 +747,61 @@ Sets an event handler to be called when a socket event occured. \wxheading{See also} -\helpref{wxSocketEvent}{wxsocketevent} +\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}, +\helpref{wxSocketBase::Notify}{wxsocketbasenotify}, +\helpref{wxSocketEvent}{wxsocketevent}, +\helpref{wxEvtHandler}{wxevthandler}, +\helpref{wxSocketBase::Callback}{wxsocketbasecallback}, +\helpref{wxSocketBase::CallbackData}{wxsocketbasecallbackdata} + +\membersection{wxSocketBase::Callback}\label{wxsocketbasecallback} + +\func{wxSocketBase::wxSockCbk}{Callback}{\param{wxSocketBase::wxSockCbk}{ callback}} + +You can setup a callback function to be called when an event occurs. +The function will be called only for those events for which notification +has been enabled with \helpref{Notify}{wxsocketbasenotify} and +\helpref{SetNotify}{wxsocketbasesetnotify}. The prototype of the +callback must be as follows: + +\begin{verbatim} +void SocketCallback(wxSocketBase& sock, wxSocketNotify evt, char *cdata); +\end{verbatim} + +The first parameter is a reference to the socket object in which the +event occured. The second parameter tells you which event occured. +(See \helpref{wxSocket events}{wxsocketbase}). The third parameter +is the user data you specified using +\helpref{CallbackData}{wxsocketbasecallbackdata}. + +Note that events are preferred over callbacks where possible. + +\wxheading{Return value} + +A pointer to the previous callback. + +\wxheading{See also} + +\helpref{wxSocketBase::CallbackData}{wxsocketbasecallbackdata}, +\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}, +\helpref{wxSocketBase::Notify}{wxsocketbasenotify} + +\membersection{wxSocketBase::CallbackData}\label{wxsocketbasecallbackdata} + +\func{char *}{CallbackData}{\param{char *}{cdata}} + +This function sets the the user data which will be passed to a +callback function set via \helpref{Callback}{wxsocketbasecallback}. + +Note that events are preferred over callbacks where possible. + +\wxheading{Return value} + +A pointer to the previous user data. + +\helpref{wxSocketBase::Callback}{wxsocketbasecallback}, +\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}, +\helpref{wxSocketBase::Notify}{wxsocketbasenotify} % --------------------------------------------------------------------------- % CLASS wxSocketClient @@ -435,6 +812,10 @@ Sets an event handler to be called when a socket event occured. \helpref{wxSocketBase}{wxsocketbase} +\wxheading{Include files} + + + % --------------------------------------------------------------------------- % Members % --------------------------------------------------------------------------- @@ -445,9 +826,7 @@ Sets an event handler to be called when a socket event occured. \func{}{wxSocketClient}{\param{wxSockFlags}{ flags = wxSocketBase::NONE}} -Constructs a new wxSocketClient. - -{\bf Warning !} The created socket client needs to be registered to a socket handler (See \helpref{wxSocketHandler}{wxsockethandler}). +Constructor. \wxheading{Parameters} @@ -460,7 +839,7 @@ Constructs a new wxSocketClient. \func{}{\destruct{wxSocketClient}}{\void} -Destructs a wxSocketClient object. +Destructor. % % Connect @@ -469,35 +848,72 @@ Destructs a wxSocketClient object. \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. +{\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.} -\docparam{wait}{If true, waits for the connection to be ready.} +\docparam{wait}{If TRUE, waits for the connection to complete.} \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 \helpref{WaitOnConnect}{wxsocketclientwaitonconnect} 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 % \membersection{wxSocketClient::WaitOnConnect}\label{wxsocketclientwaitonconnect} -\func{bool}{WaitOnConnect}{\param{long}{ seconds = -1}, \param{long}{ microseconds = 0}} +\func{bool}{WaitOnConnect}{\param{long}{ seconds = -1}, \param{long}{ milliseconds = 0}} + +Wait until a connection request completes, or until the specified timeout +elapses. Use this function after issuing a call to \helpref{Connect}{wxsocketclientconnect} +with {\it wait} set to FALSE. + +\wxheading{Parameters} + +\docparam{seconds}{Number of seconds to wait. +If -1, it will wait for the default timeout, +as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.} + +\docparam{millisecond}{Number of milliseconds to wait.} + +\wxheading{Return value} + +If the connection is succesfully established, returns TRUE. -Wait for a "connect" event. +If the timeout expires, or if the connection fails, returns FALSE. +To distinguish between these two conditions, use \helpref{IsConnected}{wxsocketbaseisconnected} \wxheading{See also} -\helpref{wxSocketBase::Wait}{wxsocketbasewait} for a detailed description. +\helpref{wxSocketClient::Connect}{wxsocketclientconnect}, +\helpref{wxSocketBase::IsConnected}{wxsocketbaseisconnected} % --------------------------------------------------------------------------- % CLASS: wxSocketEvent @@ -510,6 +926,10 @@ This event class contains information about socket events. \helpref{wxEvent}{wxevent} +\wxheading{Include files} + + + \wxheading{Event table macros} To process a socket event, use these event handler macros to direct input to member @@ -518,13 +938,12 @@ 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}% +\end{twocollist} \wxheading{See also} -\helpref{wxSocketHandler}{wxsockethandler},\rtfsp -\helpref{wxSocketBase}{wxsocketbase},\rtfsp -\helpref{wxSocketClient}{wxsocketclient},\rtfsp +\helpref{wxSocketBase}{wxsocketbase}, +\helpref{wxSocketClient}{wxsocketclient}, \helpref{wxSocketServer}{wxsocketserver} \latexignore{\rtfignore{\wxheading{Members}}} @@ -535,160 +954,19 @@ functions that take a wxSocketEvent argument. Constructor. -\membersection{wxSocketEvent::SocketEvent}\label{wxsocketeventsocketevent} - -\constfunc{wxSocketBase::wxRequestEvent}{SocketEvent}{\void} - -Returns the socket event type. - -% --------------------------------------------------------------------------- -% CLASS: wxSocketHandler -% --------------------------------------------------------------------------- -\section{\class{wxSocketHandler}}\label{wxsockethandler} - -\wxheading{Derived from} - -\helpref{wxObject}{wxobject} - -% --------------------------------------------------------------------------- -% Members -% --------------------------------------------------------------------------- -\latexignore{\rtfignore{\wxheading{Members}}} - -% -% wxSocketHandler -% -\membersection{wxSocketHandler::wxSocketHandler} - -\func{}{wxSocketHandler}{\void} - -Constructs a new wxSocketHandler. - -It is advised to use \helpref{wxSocketHandler::Master}{wxsockethandlermaster} to -get a socket handler. But creating a socket handler is useful to group -many sockets. - -% -% ~wxSocketHandler -% -\membersection{wxSocketHandler::\destruct{wxSocketHandler}} - -\func{}{\destruct{wxSocketHandler}}{\void} - -Destructs a wxSocketHandler object. - -% -% Register -% -\membersection{wxSocketHandler::Register} - -\func{void}{Register}{\param{wxSocketBase *}{socket}} +\membersection{wxSocketEvent::Socket}\label{wxsocketeventsocket} -Register a socket: if it is already registered in this handler it will just -return immediately. +\constfunc{wxSocketBase *}{Socket}{\void} -\wxheading{Parameters} - -\docparam{socket}{Socket to be registered.} - -% -% UnRegister -% -\membersection{wxSocketHandler::UnRegister} - -\func{void}{UnRegister}{\param{wxSocketBase *}{socket}} - -UnRegister a socket: if it isn't registered in this handler it will just -return. - -\wxheading{Parameters} - -\docparam{socket}{Socket to be unregistered.} - -% -% Count -% -\membersection{wxSocketHandler::Count} - -\constfunc{unsigned long}{Count}{\void} +Returns the socket object to which this event refers to. This makes +it possible to use the same event handler for different sockets. -Returns the number of sockets registered in the handler. - -\wxheading{Return value} - -Number of sockets registered. - -% -% CreateServer -% -\membersection{wxSocketHandler::CreateServer} - -\func{wxSocketServer *}{CreateServer}{\param{wxSockAddress\&}{ address}, \param{wxSocketBase::wxSockFlags}{ flags = wxSocketbase::NONE}} - -Creates a new wxSocketServer object. The object is automatically registered -to the current socket handler. -For a detailed description of the parameters, see \helpref{wxSocketServer::wxSocketServer}{wxsocketserverconstr}. - -\wxheading{Return value} - -Returns a new socket server. - -% -% CreateClient -% -\membersection{wxSocketHandler::CreateClient} - -\func{wxSocketServer *}{CreateClient}{\param{wxSocketBase::wxSockFlags}{ flags = wxSocketbase::NONE}} - -Creates a new wxSocketClient object. The object is automatically registered -to the current socket handler. - -For a detailed description of the parameters, see \helpref{wxSocketClient::Connect}{wxsocketclientconnect}. - -\wxheading{Return value} - -Returns a new socket client. - -% -% Master -% -\membersection{wxSocketHandler::Master}\label{wxsockethandlermaster} - -\func{static wxSocketHandler\&}{Master}{\void} - -Returns a default socket handler. - -% -% Wait -% -\membersection{wxSocketHandler::Wait} - -\func{int}{Wait}{\param{long}{ seconds},\param{long}{ microseconds}} - -Wait for an event on all registered sockets. - -\wxheading{Parameters} - -\docparam{seconds}{Number of seconds to wait. By default, it waits infinitely.} - -\docparam{microsecond}{Number of microseconds to wait.} - -\wxheading{Return value} - -Returns 0 if a timeout occured, else the number of events detected. - -\wxheading{See also} - -\helpref{wxSocketBase::Wait}{wxsocketbasewait} +\membersection{wxSocketEvent::SocketEvent}\label{wxsocketeventsocketevent} -% -% YieldSock -% -\membersection{wxSocketHandler::YieldSock} +\constfunc{wxSocketNotify}{SocketEvent}{\void} -\func{void}{YieldSock}{\void} +Returns the socket event type. -Execute pending requests in all registered sockets. % --------------------------------------------------------------------------- % CLASS: wxSocketServer % --------------------------------------------------------------------------- @@ -698,6 +976,10 @@ Execute pending requests in all registered sockets. \helpref{wxSocketBase}{wxsocketbase} +\wxheading{Include files} + + + % --------------------------------------------------------------------------- % Members % --------------------------------------------------------------------------- @@ -710,10 +992,9 @@ Execute pending requests in all registered sockets. \func{}{wxSocketServer}{\param{wxSockAddress\&}{ address}, \param{wxSockFlags}{ flags = wxSocketBase::NONE}} -Constructs a new wxSocketServer. - -{\bf Warning !} The created object needs to be registered to a socket handler -(see \helpref{wxSocketHandler}{wxsockethandler}). +Constructs a new server and tries to bind to the specified {\it address}. +Before trying to accept new connections, test whether it succeeded with +\helpref{wxSocketBase::Ok}{wxsocketbaseok}. \wxheading{Parameters} @@ -728,23 +1009,41 @@ Constructs a new wxSocketServer. \func{}{\destruct{wxSocketServer}}{\void} -Destructs a wxSocketServer object (it doesn't close the accepted connection). +Destructor (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} +Accepts an incoming connection request, and creates a new +\helpref{wxSocketBase}{wxsocketbase} object which represents +the server-side of the 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 \helpref{WaitForAccept}{wxsocketserverwaitforaccept} +or catch {\bf wxSOCKET\_CONNECTION} events, then call Accept() once you know +that there is an incoming connection waiting to be accepted. \wxheading{Return value} -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} % @@ -752,10 +1051,9 @@ Returns an opened socket connection. % \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} @@ -763,6 +1061,41 @@ This is useful when someone wants to inherit wxSocketBase. \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 +\helpref{Accept}{wxsocketserveraccept} or \helpref{AcceptWith}{wxsocketserveracceptwith} +with {\it wait} set to FALSE, to detect when an incoming connection is waiting +to be accepted. + +\wxheading{Parameters} + +\docparam{seconds}{Number of seconds to wait. +If -1, it will wait for the default timeout, +as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.} + +\docparam{millisecond}{Number of milliseconds to wait.} + +\wxheading{Return value} + +Returns TRUE if an incoming connection arrived, FALSE if the timeout elapsed. + +\wxheading{See also} + +\helpref{wxSocketServer::Accept}{wxsocketserveraccept}, +\helpref{wxSocketServer::AcceptWith}{wxsocketserveracceptwith}