new docs for wxsocket in 2.1.10
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4287 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Guillermo Rodriguez Garcia
parent
36edded90c
commit
cf85cb95f1
@ -19,7 +19,8 @@
|
||||
\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}%
|
||||
|
||||
@ -27,21 +28,39 @@
|
||||
|
||||
\twocolwidtha{7cm}
|
||||
\begin{twocollist}\itemsep=0pt
|
||||
\twocolitem{{\bf wxSOCKET\_INPUT}}{Some data are ready to be got.}
|
||||
\twocolitem{{\bf wxSOCKET\_INPUT}}{Some data has arrived to the socket.}
|
||||
\twocolitem{{\bf wxSOCKET\_OUTPUT}}{The socket is ready to be written to.}
|
||||
\twocolitem{{\bf wxSOCKET\_CONNECTION}}{Someone want to connect our server.}
|
||||
\twocolitem{{\bf wxSOCKET\_LOST}}{The connection has been broken.}
|
||||
\twocolitem{{\bf wxSOCKET\_CONNECTION}}{Incoming connection arrival (server), or connection establishment (client).}
|
||||
\twocolitem{{\bf wxSOCKET\_LOST}}{The connection has been closed.}
|
||||
\twocolitem{{\bf wxSOCKET\_MAX\_EVENT}}{This should never happen but the compiler may complain about it.}
|
||||
\end{twocollist}%
|
||||
|
||||
A brief note on how to use these events:
|
||||
|
||||
The {\bf wxSOCKET\_INPUT} event will be issued when the incoming queue
|
||||
was empty and new data arrives, but NOT if new data arrives when there
|
||||
was data waiting in the incoming queue.
|
||||
|
||||
The {\bf wxSOCKET\_OUTPUT} event is issued when a socket is first connected
|
||||
with Connect or accepted with Accept, and then, only after an output operation
|
||||
fails because the output buffer was full, and buffer space becomes available
|
||||
again.
|
||||
|
||||
The {\bf wxSOCKET\_CONNECTION} event is issued when a connection request
|
||||
completes (client) or when a new connection arrives at the pending
|
||||
connections queue (server).
|
||||
|
||||
The {\bf wxSOCKET\_LOST} event is issued when a close indication is
|
||||
received for the socket. This means that the connection broke down or
|
||||
that it was closed by the peer.
|
||||
|
||||
% ---------------------------------------------------------------------------
|
||||
% Event handling
|
||||
% ---------------------------------------------------------------------------
|
||||
\wxheading{Event handling}
|
||||
|
||||
To process events from a socket, use the following event handler macro to direct
|
||||
input to member
|
||||
functions that take a \helpref{wxSocketEvent}{wxsocketevent} argument.
|
||||
input to member functions that take a \helpref{wxSocketEvent}{wxsocketevent} argument.
|
||||
|
||||
\twocolwidtha{7cm}%
|
||||
\begin{twocollist}\itemsep=0pt
|
||||
@ -66,7 +85,7 @@ functions that take a \helpref{wxSocketEvent}{wxsocketevent} argument.
|
||||
|
||||
\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}}
|
||||
@ -89,36 +108,75 @@ Destroys the wxSocketBase object.
|
||||
|
||||
\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 functionnality.}
|
||||
\twocolitem{{\bf wxSOCKET\_NOWAIT}}{Get the available data in the input queue and return immediately.}
|
||||
\twocolitem{{\bf wxSOCKET\_WAITALL}}{Wait for all required data unless an error occurs.}
|
||||
\twocolitem{{\bf wxSOCKET\_BLOCK}}{Block the GUI (do not wxYield) while reading / writing data.}
|
||||
\end{twocollist}
|
||||
|
||||
A brief overview on how to use these flags follows.
|
||||
|
||||
If no flag is specified (this is the same as {\bf wxSOCKET\_NONE}),
|
||||
IO calls will return after some data has been read or written, even
|
||||
when the transfer might not be complete. This is the same as issuing
|
||||
exactly one blocking low-level call to recv() or send(). Note that
|
||||
blocking here refers to when the function returns, not to whether
|
||||
the GUI blocks during this time.
|
||||
|
||||
If {\bf wxSOCKET\_NOWAIT} is specified, IO calls will return immediately.
|
||||
Read operations will retrieve only available data. Write operations will
|
||||
write as much data as possible, depending on how much space is available
|
||||
in the output buffer. This is the same as issuing exactly one nonblocking
|
||||
low-level call to recv() or send(). Note that nonblocking here refers to
|
||||
when the function returns, not to whether the GUI blocks during this time.
|
||||
|
||||
If {\bf wxSOCKET\_WAITALL} is specified, IO calls won't return until ALL
|
||||
the data has been read or written (or until an error occurs), blocking if
|
||||
necessary, and issuing several low level calls if necessary. This is the
|
||||
same as having a loop which makes as many blocking low-level calls to
|
||||
recv() or send() as needed so as to transfer all the data. Note that
|
||||
"blocking" here refers to when the function returns, not to whether
|
||||
the GUI blocks during this time.
|
||||
|
||||
The {\bf wxSOCKET\_BLOCK} controls whether the GUI blocks during IO
|
||||
operations. If this flag is not used, then the application must take
|
||||
extra care to avoid unwanted reentrance.
|
||||
|
||||
So:
|
||||
|
||||
{\bf wxSOCKET\_NONE} will try to read SOME data, no matter how much.
|
||||
{\bf wxSOCKET\_NOWAIT} will always return immediately, even if it cannot
|
||||
read or write ANY data.
|
||||
{\bf wxSOCKET\_WAITALL} will only return when it has read or written ALL
|
||||
the data.
|
||||
{\bf wxSOCKET\_BLOCK} has nothing to do with the previous flags and
|
||||
it control whether the GUI blocks.
|
||||
|
||||
%
|
||||
% SetNotify
|
||||
%
|
||||
\membersection{wxSocketBase::SetNotify}\label{wxsocketbasesetnotify}
|
||||
|
||||
\func{void}{SetNotify}{\param{wxSocketEventFlags}{ 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}
|
||||
\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.
|
||||
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}.
|
||||
|
||||
@ -129,7 +187,10 @@ For more information on socket events see \helpref{wxSocket events}{wxsocketbase
|
||||
|
||||
\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
|
||||
@ -156,7 +217,10 @@ cases.
|
||||
|
||||
\constfunc{bool}{Error}{\void}
|
||||
|
||||
Returns TRUE if an error occured.
|
||||
Returns TRUE if an error occured in the last IO operation.
|
||||
|
||||
The following operations update the Error() status:
|
||||
Read, Write, ReadMsg, WriteMsg, Peek, Unread, Discard.
|
||||
|
||||
\membersection{wxSocketBase::IsConnected}\label{wxsocketbaseconnected}
|
||||
|
||||
@ -168,7 +232,7 @@ 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}
|
||||
|
||||
@ -188,11 +252,21 @@ Returns TRUE if the socket mustn't wait.
|
||||
|
||||
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}{wxsocketbase}.
|
||||
Returns the last wxSocket error. See \helpref{wxSocket errors}{wxsocketbase}.
|
||||
|
||||
Please note that this function merely returns the last error code,
|
||||
but it should not be used to determine if an error has occured (this
|
||||
is because successful operations do not change tha LastError value).
|
||||
Use Error, instead of LastError, to determine if the last IO call
|
||||
failed. If Error returns TRUE, use LastError to discover the
|
||||
cause of the error.
|
||||
|
||||
% ---------------------------------------------------------------------------
|
||||
% IO calls
|
||||
@ -207,6 +281,10 @@ Returns the last occured wxSocket error. See \helpref{wxSocket errors}{wxsocketb
|
||||
This function peeks a buffer of {\it nbytes} bytes from the socket. Peeking a buffer
|
||||
doesn't delete it from the system socket in-queue.
|
||||
|
||||
Use LastCount to verify the number of bytes actually peeked.
|
||||
|
||||
Use Error to determine if the operation succeeded.
|
||||
|
||||
\wxheading{Parameters}
|
||||
|
||||
\docparam{buffer}{Buffer where to put peeked data.}
|
||||
@ -217,11 +295,17 @@ 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::LastError}{wxsocketbaselasterror}\\
|
||||
\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
|
||||
\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
|
||||
\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}
|
||||
|
||||
%
|
||||
% Read
|
||||
@ -232,6 +316,10 @@ Returns a reference to the current object.
|
||||
|
||||
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.}
|
||||
@ -244,23 +332,15 @@ Returns a reference to the current object.
|
||||
|
||||
\wxheading{Remark/Warning}
|
||||
|
||||
By default, Read uses an internal asynchronous manager: it will send data when
|
||||
the socket requests them. It is particularly interesting when you enter a long
|
||||
data transfer (e.g. a big file, an image, ...). But it is also buggy when you
|
||||
simply discuss with the peer using user data. In this case, wxSocket prepares
|
||||
itself to send data (Write wait for them to be sent) and during a GUI refresh
|
||||
the user enters new data, which involves a new Read call though the previous
|
||||
isn't finished. Well, in most cases it can work but it might fail too.
|
||||
So I advise you to use the SPEED flag, which disables the asynchronous manager,
|
||||
when you just want to discuss with the peer.
|
||||
|
||||
This remark is also valid for all IO call.
|
||||
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
|
||||
@ -269,23 +349,15 @@ This remark is also valid for all IO call.
|
||||
|
||||
\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.}
|
||||
|
||||
@ -293,11 +365,17 @@ when you just want to discuss with the peer.
|
||||
|
||||
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::LastError}{wxsocketbaselasterror}\\
|
||||
\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
|
||||
\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}
|
||||
\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}
|
||||
|
||||
%
|
||||
% WriteMsg
|
||||
@ -306,13 +384,19 @@ Returns a reference to the current object.
|
||||
|
||||
\func{wxSocketBase\&}{WriteMsg}{\param{const char *}{ buffer}, \param{wxUint32}{ nbytes}}
|
||||
|
||||
This function writes a buffer of {\it nbytes} bytes from the socket. But it
|
||||
This function writes a buffer of {\it nbytes} bytes from the socket, but it
|
||||
writes a short header before so that ReadMsg can alloc the right size for
|
||||
the buffer. So a buffer sent with WriteMsg {\bf must} be read with ReadMsg.
|
||||
the buffer. So, a buffer sent with WriteMsg {\bf must} be read with ReadMsg.
|
||||
This function always waits for the entire buffer to be sent, unless an
|
||||
error occurs.
|
||||
|
||||
Use LastCount to verify the number of bytes actually written.
|
||||
|
||||
Use Error to determine if the operation succeeded.
|
||||
|
||||
\wxheading{Parameters}
|
||||
|
||||
\docparam{buffer}{Buffer where to put data peeked.}
|
||||
\docparam{buffer}{Buffer with the data to be sent.}
|
||||
|
||||
\docparam{nbytes}{Number of bytes.}
|
||||
|
||||
@ -320,11 +404,18 @@ the buffer. So a buffer sent with WriteMsg {\bf must} be read with ReadMsg.
|
||||
|
||||
Returns a reference to the current object.
|
||||
|
||||
\wxheading{Remark/Warning}
|
||||
|
||||
wxSocketBase::WriteMsg() will behave as if the wxSOCKET_WAITALL flag was always set
|
||||
and it will always ignore the wxSOCKET_NOWAIT flag. The exact behaviour of WriteMsg
|
||||
depends on the wxSOCKET_BLOCK flag. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}.
|
||||
|
||||
\wxheading{See also}
|
||||
|
||||
\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\
|
||||
\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
|
||||
\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}\\
|
||||
\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
|
||||
\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}\\
|
||||
\helpref{wxSocketBase::ReadMsg}{wxsocketbasereadmsg}
|
||||
|
||||
%
|
||||
@ -335,8 +426,12 @@ Returns a reference to the current object.
|
||||
\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}
|
||||
|
||||
@ -348,11 +443,18 @@ bytes left. This function always wait for the buffer to be entirely filled.
|
||||
|
||||
Returns a reference to the current object.
|
||||
|
||||
\wxheading{Remark/Warning}
|
||||
|
||||
wxSocketBase::ReadMsg() will behave as if the wxSOCKET_WAITALL flag was always set
|
||||
and it will always ignore the wxSOCKET_NOWAIT flag. The exact behaviour of ReadMsg
|
||||
depends on the wxSOCKET_SPEED flag. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}.
|
||||
|
||||
\wxheading{See also}
|
||||
|
||||
\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\
|
||||
\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
|
||||
\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}\\
|
||||
\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\
|
||||
\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}\\
|
||||
\helpref{wxSocketBase::WriteMsg}{wxsocketbasewritemsg}
|
||||
|
||||
%
|
||||
@ -362,9 +464,12 @@ Returns a reference to the current object.
|
||||
|
||||
\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}
|
||||
|
||||
@ -390,7 +495,12 @@ 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.
|
||||
doesn't wait. That is, it will behave as if the wxSOCKET_NOWAIT flag was set. The
|
||||
wxSOCKET_SPEED and wxSOCKET_WAITALL flags have no effect on this function.
|
||||
|
||||
Use LastCount to see the number of bytes discarded.
|
||||
|
||||
If you use Error, it will always return FALSE.
|
||||
|
||||
% ---------------------------------------------------------------------------
|
||||
% Wait functions
|
||||
@ -399,13 +509,14 @@ doesn't wait.
|
||||
|
||||
\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).
|
||||
|
||||
\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.}
|
||||
|
||||
@ -426,17 +537,17 @@ Returns TRUE if an event occured, FALSE if the timeout was reached.
|
||||
|
||||
\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}
|
||||
|
||||
@ -451,17 +562,17 @@ Returns TRUE if a byte arrived, FALSE if the timeout was reached.
|
||||
|
||||
\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}
|
||||
|
||||
@ -476,18 +587,18 @@ Returns TRUE if a write event occured, FALSE if the timeout was reached.
|
||||
|
||||
\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}
|
||||
|
||||
@ -495,6 +606,10 @@ Returns TRUE if a "lost" event occured, FALSE if the timeout was reached.
|
||||
\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}\\
|
||||
\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}
|
||||
|
||||
% ---------------------------------------------------------------------------
|
||||
% Socket state
|
||||
% ---------------------------------------------------------------------------
|
||||
|
||||
%
|
||||
% RestoreState
|
||||
%
|
||||
@ -502,16 +617,15 @@ Returns TRUE if a "lost" event occured, FALSE if the timeout was reached.
|
||||
|
||||
\func{void}{RestoreState}{\void}
|
||||
|
||||
This function restores the previous state of the socket (include flags,
|
||||
notify flags, notify state, C callback function and data).
|
||||
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
|
||||
%
|
||||
@ -520,7 +634,10 @@ notify flags, notify state, C callback function and data).
|
||||
\func{void}{SaveState}{\void}
|
||||
|
||||
This function saves the current state of the socket object in a stack:
|
||||
actually it saves all flags and the state of the asynchronous callbacks.
|
||||
actually it saves all flags (those set with SetFlags, SetNotify, Notfy)
|
||||
and the state of the asynchronous callbacks (Callback, CallbackData).
|
||||
|
||||
Calls to SaveState / RestoreState can be nested.
|
||||
|
||||
\wxheading{See also}
|
||||
|
||||
@ -563,7 +680,12 @@ It returns TRUE if no errors happened, FALSE otherwise.
|
||||
|
||||
\func{void}{SetEventHandler}{\param{wxEvtHandler\&}{ evt\_hdlr}, \param{int}{ id = -1}}
|
||||
|
||||
Sets an event handler to be called when a socket event occured.
|
||||
Sets an event handler to be called when a socket event occurs. The handler
|
||||
will be called for those events for which notification is enabled with
|
||||
SetNotify and Notify.
|
||||
|
||||
You can also specify a C callback to be called when an event occurs. See
|
||||
Callback and CallbackData.
|
||||
|
||||
\wxheading{Parameters}
|
||||
|
||||
@ -573,43 +695,52 @@ Sets an event handler to be called when a socket event occured.
|
||||
|
||||
\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 C callback to be called when an event occurs. The callback
|
||||
will be called only for those events for which notification has been enabled
|
||||
with Notify and SetNotify. The prototype of the callback must be as follows:
|
||||
|
||||
\begin{verbatim}
|
||||
void SocketCallback(wxSocketBase& sock,wxSocketNotify evt,char *cdata);
|
||||
\end{verbatim}
|
||||
|
||||
The first parameter reminds you of the caller socket. The second parameter
|
||||
informs you about the current event (See \helpref{wxSocket events}{wxsocketbase}).
|
||||
The third parameters is the client data you specified using \helpref{CallbackData}{wxsocketcallbackdata}.
|
||||
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}{wxsocketcallbackdata}.
|
||||
|
||||
\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}{wxsocketbasecallback}.
|
||||
This function sets the the user data which will be passed to a \helpref{C callback}{wxsocketbasecallback}.
|
||||
|
||||
\wxheading{Return value}
|
||||
|
||||
This function returns the old value of the client data pointer.
|
||||
A pointer to the previous user data.
|
||||
|
||||
\helpref{wxSocketBase::Callback}{wxsocketbasecallback}\\
|
||||
\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}\\
|
||||
\helpref{wxSocketBase::Notify}{wxsocketbasenotify}
|
||||
|
||||
% ---------------------------------------------------------------------------
|
||||
% CLASS wxSocketClient
|
||||
@ -656,8 +787,18 @@ Destroys 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 and
|
||||
the socket is ready to send or receive data, or until an event occurs.
|
||||
{\bf Warning !} This will block the GUI.
|
||||
|
||||
If {\it wait} is FALSE, Connect will try to establish the connection and
|
||||
return immediately, without blocking the GUI. When used this way, even if
|
||||
Connect returns FALSE, the connection request can be completed later.
|
||||
To detect this, use WaitConnection, or watch "connection" events (for
|
||||
succesful establishment) and "lost" events (for connection failure)
|
||||
|
||||
|
||||
\wxheading{Parameters}
|
||||
|
||||
@ -669,9 +810,18 @@ will wait for the socket ready to send or receive data.
|
||||
|
||||
Returns TRUE if the connection is established and no error occurs.
|
||||
|
||||
If {\it wait} was TRUE, and Connect returns FALSE, an error occured
|
||||
and the connection failed.
|
||||
|
||||
If {\it wait} was FALSE, and Connect returns FALSE, you should still
|
||||
be prepared to handle the completion of this connection request, either
|
||||
with WaitOnConnect or by watching "connection" and "lost" events.
|
||||
|
||||
\wxheading{See also}
|
||||
|
||||
\helpref{wxSocketClient::WaitOnConnect}{wxsocketclientwaitonconnect}
|
||||
\helpref{wxSocketClient::WaitOnConnect}{wxsocketclientwaitonconnect}\\
|
||||
\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}\\
|
||||
\helpref{wxSocketBase::Notify}{wxsocketbasenotify}
|
||||
|
||||
%
|
||||
% WaitOnConnect
|
||||
@ -680,11 +830,24 @@ Returns TRUE if the connection is established and no error occurs.
|
||||
|
||||
\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
|
||||
@ -711,6 +874,10 @@ functions that take a wxSocketEvent argument.
|
||||
\twocolitem{{\bf EVT\_SOCKET(id, func)}}{Process a socket event, supplying the member function.}
|
||||
\end{twocollist}%
|
||||
|
||||
[TODO:]
|
||||
A brief note on how to use events.
|
||||
The wxSOCKET_INPUT event is generated when the
|
||||
|
||||
\wxheading{See also}
|
||||
|
||||
\helpref{wxSocketBase}{wxsocketbase},\rtfsp
|
||||
@ -771,23 +938,39 @@ Constructs a new wxSocketServer.
|
||||
|
||||
\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}
|
||||
|
||||
\func{wxSocketBase *}{Accept}{\void}
|
||||
\func{wxSocketBase *}{Accept}{\param{bool}{ wait = TRUE}}
|
||||
|
||||
Creates a new object wxSocketBase and accepts an incoming connection. {\bf Warning !} This function will block the GUI.
|
||||
Creates a new object wxSocketBase and accepts an incoming connection.
|
||||
|
||||
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
|
||||
"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}{wxsocketbasewaitforaccept}\\
|
||||
\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}\\
|
||||
\helpref{wxSocketBase::Notify}{wxsocketbasenotify}\\
|
||||
\helpref{wxSocketServer::AcceptWith}{wxsocketserveracceptwith}
|
||||
|
||||
%
|
||||
@ -795,7 +978,7 @@ 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.
|
||||
@ -806,5 +989,40 @@ 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}{wxsocketbasewaitforaccept}\\
|
||||
\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}
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user