emulate scrolling in wxMSW header control; document the need to call ScrollWindow...

[wxWidgets.git] / include / wx / socket.h

diff --git a/include/wx/socket.h b/include/wx/socket.h
index 3d2fd861b1cbb354354232194191f13aaa799543..1b72a2cd56eb22b46cd6f850f768779616a6355d 100644 (file)
--- a/include/wx/socket.h
+++ b/include/wx/socket.h
@@ -9,12 +9,8 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-#ifndef _WX_NETWORK_SOCKET_H
-#define _WX_NETWORK_SOCKET_H
-
-#ifdef __GNUG__
-#pragma interface "socket.h"
-#endif
+#ifndef _WX_SOCKET_H_
+#define _WX_SOCKET_H_

 
 #include "wx/defs.h"
 
 
 #include "wx/defs.h"
 


@@ -24,113 +20,89 @@
 // wxSocket headers
 // ---------------------------------------------------------------------------
 
 // wxSocket headers
 // ---------------------------------------------------------------------------
 

-#ifdef WXPREC
-#  include "wx/wxprec.h"
-#else
-#  include "wx/event.h"
-#  include "wx/string.h"
-#endif
-
+#include "wx/event.h"

 #include "wx/sckaddr.h"
 #include "wx/sckaddr.h"

-#include "wx/gsocket.h"
+#include "wx/list.h"
+
+class wxSocketImpl;

 
 // ------------------------------------------------------------------------
 // Types and constants
 // ------------------------------------------------------------------------
 
 
 // ------------------------------------------------------------------------
 // Types and constants
 // ------------------------------------------------------------------------
 

+// Types of different socket notifications or events.
+//
+// NB: the values here should be consecutive and start with 0 as they are
+//     used to construct the wxSOCKET_XXX_FLAG bit mask values below

 enum wxSocketNotify
 {
 enum wxSocketNotify
 {

-  wxSOCKET_INPUT = GSOCK_INPUT,
-  wxSOCKET_OUTPUT = GSOCK_OUTPUT,
-  wxSOCKET_CONNECTION = GSOCK_CONNECTION,
-  wxSOCKET_LOST = GSOCK_LOST
+    wxSOCKET_INPUT,
+    wxSOCKET_OUTPUT,
+    wxSOCKET_CONNECTION,
+    wxSOCKET_LOST,
+    wxSOCKET_MAX_EVENT

 };
 
 enum
 {
 };
 
 enum
 {

-  wxSOCKET_INPUT_FLAG = GSOCK_INPUT_FLAG,
-  wxSOCKET_OUTPUT_FLAG = GSOCK_OUTPUT_FLAG,
-  wxSOCKET_CONNECTION_FLAG = GSOCK_CONNECTION_FLAG,
-  wxSOCKET_LOST_FLAG = GSOCK_LOST_FLAG
+    wxSOCKET_INPUT_FLAG = 1 << wxSOCKET_INPUT,
+    wxSOCKET_OUTPUT_FLAG = 1 << wxSOCKET_OUTPUT,
+    wxSOCKET_CONNECTION_FLAG = 1 << wxSOCKET_CONNECTION,
+    wxSOCKET_LOST_FLAG = 1 << wxSOCKET_LOST

 };
 
 };
 

-typedef GSocketEventFlags wxSocketEventFlags;
+// this is a combination of the bit masks defined above
+typedef int wxSocketEventFlags;

 
 enum wxSocketError
 {
 
 enum wxSocketError
 {

-  wxSOCKET_NOERROR = GSOCK_NOERROR,
-  wxSOCKET_INPOP = GSOCK_INVOP,
-  wxSOCKET_IOERR = GSOCK_IOERR,
-  wxSOCKET_INVADDR = GSOCK_INVADDR,
-  wxSOCKET_INVSOCK = GSOCK_INVSOCK,
-  wxSOCKET_NOHOST = GSOCK_NOHOST,
-  wxSOCKET_INVPORT = GSOCK_INVPORT,
-  wxSOCKET_WOULDBLOCK = GSOCK_WOULDBLOCK,
-  wxSOCKET_TIMEDOUT = GSOCK_TIMEDOUT,
-  wxSOCKET_MEMERR = GSOCK_MEMERR
+    wxSOCKET_NOERROR = 0,
+    wxSOCKET_INVOP,
+    wxSOCKET_IOERR,
+    wxSOCKET_INVADDR,
+    wxSOCKET_INVSOCK,
+    wxSOCKET_NOHOST,
+    wxSOCKET_INVPORT,
+    wxSOCKET_WOULDBLOCK,
+    wxSOCKET_TIMEDOUT,
+    wxSOCKET_MEMERR,
+    wxSOCKET_OPTERR

 };
 
 };
 

+// socket options/flags bit masks

 enum
 {
 enum
 {

-  wxSOCKET_NONE = 0,
-  wxSOCKET_NOWAIT = 1,
-  wxSOCKET_WAITALL = 2,
-  wxSOCKET_BLOCK = 4
+    wxSOCKET_NONE = 0,
+    wxSOCKET_NOWAIT = 1,
+    wxSOCKET_WAITALL = 2,
+    wxSOCKET_BLOCK = 4,
+    wxSOCKET_REUSEADDR = 8,
+    wxSOCKET_BROADCAST = 16,
+    wxSOCKET_NOBIND = 32

 };
 
 };
 

-// Type of socket
+typedef int wxSocketFlags;
+
+// socket kind values (badly defined, don't use)

 enum wxSocketType
 {
 enum wxSocketType
 {

-  wxSOCKET_UNINIT,
-  wxSOCKET_CLIENT,
-  wxSOCKET_SERVER,
-  wxSOCKET_BASE,
-  wxSOCKET_DATAGRAM
+    wxSOCKET_UNINIT,
+    wxSOCKET_CLIENT,
+    wxSOCKET_SERVER,
+    wxSOCKET_BASE,
+    wxSOCKET_DATAGRAM

 };
 
 };
 

-typedef int wxSocketFlags;
-
-
-// old names
-
-#if WXWIN_COMPATIBILITY

 
 

-typedef wxSocketType wxSockType;
-typedef wxSocketFlags wxSockFlags;
-
-#endif // WXWIN_COMPATIBILITY

 
 // --------------------------------------------------------------------------
 // wxSocketBase
 // --------------------------------------------------------------------------
 
 
 // --------------------------------------------------------------------------
 // wxSocketBase
 // --------------------------------------------------------------------------
 

-class WXDLLEXPORT wxSocketBase : public wxObject
+class WXDLLIMPEXP_NET wxSocketBase : public wxObject

 {
   DECLARE_CLASS(wxSocketBase)
 
 {
   DECLARE_CLASS(wxSocketBase)
 

-public:
-
-#if WXWIN_COMPATIBILITY
-  enum
-  {
-    NONE = wxSOCKET_NONE,
-    NOWAIT = wxSOCKET_NOWAIT,
-    WAITALL = wxSOCKET_WAITALL,
-    SPEED = wxSOCKET_BLOCK
-  };
-
-  enum
-  {
-    SOCK_UNINIT = wxSOCKET_UNINIT,
-    SOCK_CLIENT = wxSOCKET_CLIENT,
-    SOCK_SERVER = wxSOCKET_SERVER,
-    SOCK_INTERNAL = wxSOCKET_BASE,
-    SOCK_DATAGRAM = wxSOCKET_DATAGRAM
-  };
-#endif // WXWIN_COMPATIBILITY
-
-  typedef void (*wxSockCbk)(wxSocketBase& sock, wxSocketNotify evt, char *cdata);
-

 public:
 
   // Public interface
 public:
 
   // Public interface


@@ -144,19 +116,22 @@ public:
   bool Destroy();
 
   // state
   bool Destroy();
 
   // state

-  inline bool Ok() const { return (m_socket != NULL); };
-  inline bool Error() const { return m_error; };
-  inline bool IsConnected() const { return m_connected; };
-  inline bool IsData() { return WaitForRead(0, 0); };
-  inline bool IsDisconnected() const { return !IsConnected(); };
-  inline wxUint32 LastCount() const { return m_lcount; }
-  inline wxSocketError LastError() const { return (wxSocketError)GSocket_GetError(m_socket); }
+  bool Ok() const { return IsOk(); }
+  bool IsOk() const { return m_impl != NULL; }
+  bool Error() const { return m_error; }
+  bool IsClosed() const { return m_closed; }
+  bool IsConnected() const { return m_connected; }
+  bool IsData() { return WaitForRead(0, 0); }
+  bool IsDisconnected() const { return !IsConnected(); }
+  wxUint32 LastCount() const { return m_lcount; }
+  wxSocketError LastError() const;

   void SaveState();
   void RestoreState();
 
   // addresses
   virtual bool GetLocal(wxSockAddress& addr_man) const;
   virtual bool GetPeer(wxSockAddress& addr_man) const;
   void SaveState();
   void RestoreState();
 
   // addresses
   virtual bool GetLocal(wxSockAddress& addr_man) const;
   virtual bool GetPeer(wxSockAddress& addr_man) const;

+  virtual bool SetLocal(const wxIPV4address& local);

 
   // base IO
   virtual bool  Close();
 
   // base IO
   virtual bool  Close();


@@ -168,37 +143,57 @@ public:
   wxSocketBase& Write(const void *buffer, wxUint32 nbytes);
   wxSocketBase& WriteMsg(const void *buffer, wxUint32 nbytes);
 
   wxSocketBase& Write(const void *buffer, wxUint32 nbytes);
   wxSocketBase& WriteMsg(const void *buffer, wxUint32 nbytes);
 

-  void InterruptAllWaits() { m_interrupt = TRUE; };
+  // all Wait() functions wait until their condition is satisfied or the
+  // timeout expires; if seconds == -1 (default) then m_timeout value is used
+  //
+  // it is also possible to call InterruptWait() to cancel any current Wait()
+
+  // wait for anything at all to happen with this socket

   bool Wait(long seconds = -1, long milliseconds = 0);
   bool Wait(long seconds = -1, long milliseconds = 0);

+
+  // wait until we can read from or write to the socket without blocking
+  // (notice that this does not mean that the operation will succeed but only
+  // that it will return immediately)

   bool WaitForRead(long seconds = -1, long milliseconds = 0);
   bool WaitForWrite(long seconds = -1, long milliseconds = 0);
   bool WaitForRead(long seconds = -1, long milliseconds = 0);
   bool WaitForWrite(long seconds = -1, long milliseconds = 0);

+
+  // wait until the connection is terminated

   bool WaitForLost(long seconds = -1, long milliseconds = 0);
 
   bool WaitForLost(long seconds = -1, long milliseconds = 0);
 

-  inline wxSocketFlags GetFlags() const { return m_flags; }
+  void InterruptWait() { m_interrupt = true; }
+
+
+  wxSocketFlags GetFlags() const { return m_flags; }

   void SetFlags(wxSocketFlags flags);
   void SetTimeout(long seconds);
   void SetFlags(wxSocketFlags flags);
   void SetTimeout(long seconds);

+  long GetTimeout() const { return m_timeout; }
+
+  bool GetOption(int level, int optname, void *optval, int *optlen);
+  bool SetOption(int level, int optname, const void *optval, int optlen);
+  wxUint32 GetLastIOSize() const { return m_lcount; }

 
   // event handling
   void *GetClientData() const { return m_clientData; }
   void SetClientData(void *data) { m_clientData = data; }
 
   // event handling
   void *GetClientData() const { return m_clientData; }
   void SetClientData(void *data) { m_clientData = data; }

-  void SetEventHandler(wxEvtHandler& handler, int id = -1);
+  void SetEventHandler(wxEvtHandler& handler, int id = wxID_ANY);

   void SetNotify(wxSocketEventFlags flags);
   void Notify(bool notify);
 
   void SetNotify(wxSocketEventFlags flags);
   void Notify(bool notify);
 

-  // callbacks - deprecated, avoid if possible
-  wxSockCbk Callback(wxSockCbk cbk_);
-  char *CallbackData(char *data);
+  // initialize/shutdown the sockets (usually called automatically)
+  static bool IsInitialized();
+  static bool Initialize();
+  static void Shutdown();

 
 
   // Implementation from now on
   // --------------------------
 
 
 
   // Implementation from now on
   // --------------------------
 

-  // do not use, this should be private
-  void OnRequest(wxSocketNotify req_evt);
+  // do not use, should be private (called from wxSocketImpl only)
+  void OnRequest(wxSocketNotify notify);

 
   // do not use, not documented nor supported
 
   // do not use, not documented nor supported

-  inline bool IsNoWait() const { return ((m_flags & wxSOCKET_NOWAIT) != 0); };
-  inline wxSocketType GetType() const { return m_type; }
+  bool IsNoWait() const { return ((m_flags & wxSOCKET_NOWAIT) != 0); }
+  wxSocketType GetType() const { return m_type; }

 
 private:
   friend class wxSocketClient;
 
 private:
   friend class wxSocketClient;


@@ -206,16 +201,27 @@ private:
   friend class wxDatagramSocket;
 
   // low level IO
   friend class wxDatagramSocket;
 
   // low level IO

-  wxUint32 _Read(void* buffer, wxUint32 nbytes);
-  wxUint32 _Write(const void *buffer, wxUint32 nbytes);
-  bool _Wait(long seconds, long milliseconds, wxSocketEventFlags flags);
+  wxUint32 DoRead(void* buffer, wxUint32 nbytes);
+  wxUint32 DoWrite(const void *buffer, wxUint32 nbytes);
+
+  // wait until the given flags are set for this socket or the given timeout
+  // (or m_timeout) expires
+  //
+  // notice that wxSOCKET_LOST_FLAG is always taken into account but the return
+  // value depends on whether it is included in flags or not: if it is, and the
+  // connection is indeed lost, true is returned, but if it isn't then the
+  // function returns false in this case
+  //
+  // false is always returned if we returned because of the timeout expiration
+  bool DoWait(long seconds, long milliseconds, wxSocketEventFlags flags);

 
   // pushback buffer
 
   // pushback buffer

-  void Pushback(const void *buffer, wxUint32 size);
+  void     Pushback(const void *buffer, wxUint32 size);

   wxUint32 GetPushback(void *buffer, wxUint32 size, bool peek);
 
 private:
   wxUint32 GetPushback(void *buffer, wxUint32 size, bool peek);
 
 private:

-  GSocket      *m_socket;           // GSocket
+  // socket
+  wxSocketImpl *m_impl;             // port-specific implementation

   wxSocketType  m_type;             // wxSocket type
 
   // state
   wxSocketType  m_type;             // wxSocket type
 
   // state


@@ -225,11 +231,14 @@ private:
   bool          m_reading;          // busy reading?
   bool          m_writing;          // busy writing?
   bool          m_error;            // did last IO call fail?
   bool          m_reading;          // busy reading?
   bool          m_writing;          // busy writing?
   bool          m_error;            // did last IO call fail?

+  bool          m_closed;           // was the other end closed?
+                                    // (notice that m_error is also set then)

   wxUint32      m_lcount;           // last IO transaction size
   wxUint32      m_lcount;           // last IO transaction size

-  unsigned long m_timeout;          // IO timeout value
+  unsigned long m_timeout;          // IO timeout value in seconds

   wxList        m_states;           // stack of states
   bool          m_interrupt;        // interrupt ongoing wait operations?
   bool          m_beingDeleted;     // marked for delayed deletion?
   wxList        m_states;           // stack of states
   bool          m_interrupt;        // interrupt ongoing wait operations?
   bool          m_beingDeleted;     // marked for delayed deletion?

+  wxIPV4address m_localAddress;     // bind to local address?

 
   // pushback buffer
   void         *m_unread;           // pushback buffer
 
   // pushback buffer
   void         *m_unread;           // pushback buffer


@@ -240,12 +249,13 @@ private:
   int           m_id;               // socket id
   wxEvtHandler *m_handler;          // event handler
   void         *m_clientData;       // client data for events
   int           m_id;               // socket id
   wxEvtHandler *m_handler;          // event handler
   void         *m_clientData;       // client data for events

-  bool          m_notify_state;     // notify events to users?
-  wxSocketEventFlags  m_neededreq;  // event mask
+  bool          m_notify;           // notify events to users?
+  wxSocketEventFlags  m_eventmask;  // which events to notify?

 
 

-  // callbacks - deprecated, avoid if possible
-  wxSockCbk     m_cbk;              // callback
-  char         *m_cdata;            // callback data
+  // the initialization count, GSocket is initialized if > 0
+  static size_t m_countInit;
+
+  DECLARE_NO_COPY_CLASS(wxSocketBase)

 };
 
 
 };
 
 


@@ -253,17 +263,19 @@ private:
 // wxSocketServer
 // --------------------------------------------------------------------------
 
 // wxSocketServer
 // --------------------------------------------------------------------------
 

-class WXDLLEXPORT wxSocketServer : public wxSocketBase
+class WXDLLIMPEXP_NET wxSocketServer : public wxSocketBase

 {
   DECLARE_CLASS(wxSocketServer)
 
 public:
 {
   DECLARE_CLASS(wxSocketServer)
 
 public:

-  wxSocketServer(wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE);
+  wxSocketServer(const wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE);

 
 

-  wxSocketBase* Accept(bool wait = TRUE);
-  bool AcceptWith(wxSocketBase& socket, bool wait = TRUE);
+  wxSocketBase* Accept(bool wait = true);
+  bool AcceptWith(wxSocketBase& socket, bool wait = true);

 
   bool WaitForAccept(long seconds = -1, long milliseconds = 0);
 
   bool WaitForAccept(long seconds = -1, long milliseconds = 0);

+
+  DECLARE_NO_COPY_CLASS(wxSocketServer)

 };
 
 
 };
 
 


@@ -271,7 +283,7 @@ public:
 // wxSocketClient
 // --------------------------------------------------------------------------
 
 // wxSocketClient
 // --------------------------------------------------------------------------
 

-class WXDLLEXPORT wxSocketClient : public wxSocketBase
+class WXDLLIMPEXP_NET wxSocketClient : public wxSocketBase

 {
   DECLARE_CLASS(wxSocketClient)
 
 {
   DECLARE_CLASS(wxSocketClient)
 


@@ -279,9 +291,30 @@ public:
   wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE);
   virtual ~wxSocketClient();
 
   wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE);
   virtual ~wxSocketClient();
 

-  virtual bool Connect(wxSockAddress& addr, bool wait = TRUE);
+  virtual bool Connect(const wxSockAddress& addr, bool wait = true);
+  bool Connect(const wxSockAddress& addr, const wxSockAddress& local,
+               bool wait = true);

 
   bool WaitOnConnect(long seconds = -1, long milliseconds = 0);
 
   bool WaitOnConnect(long seconds = -1, long milliseconds = 0);

+
+  // Sets initial socket buffer sizes using the SO_SNDBUF and SO_RCVBUF options
+  // before calling connect (either one can be -1 to leave it unchanged)
+  void SetInitialSocketBuffers(int recv, int send)
+  {
+      m_initialRecvBufferSize = recv;
+      m_initialSendBufferSize = send;
+  }
+
+private:
+  virtual bool DoConnect(const wxSockAddress& addr,
+                         const wxSockAddress* local,
+                         bool wait = true);
+
+  // buffer sizes, -1 if unset and defaults should be used
+  int m_initialRecvBufferSize;
+  int m_initialSendBufferSize;
+
+  DECLARE_NO_COPY_CLASS(wxSocketClient)

 };
 
 
 };
 
 


@@ -291,19 +324,24 @@ public:
 
 // WARNING: still in alpha stage
 
 
 // WARNING: still in alpha stage
 

-class wxDatagramSocket : public wxSocketBase
+class WXDLLIMPEXP_NET wxDatagramSocket : public wxSocketBase

 {
   DECLARE_CLASS(wxDatagramSocket)
 
 public:
 {
   DECLARE_CLASS(wxDatagramSocket)
 
 public:

-  wxDatagramSocket(wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE);
+  wxDatagramSocket(const wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE);

 
   wxDatagramSocket& RecvFrom( wxSockAddress& addr,
                               void* buf,
                               wxUint32 nBytes );
 
   wxDatagramSocket& RecvFrom( wxSockAddress& addr,
                               void* buf,
                               wxUint32 nBytes );

-  wxDatagramSocket& SendTo( wxSockAddress& addr,
+  wxDatagramSocket& SendTo( const wxSockAddress& addr,

                             const void* buf,
                             wxUint32 nBytes );
                             const void* buf,
                             wxUint32 nBytes );

+
+/* TODO:
+  bool Connect(wxSockAddress& addr);
+*/
+  DECLARE_NO_COPY_CLASS(wxDatagramSocket)

 };
 
 
 };
 
 


@@ -311,38 +349,37 @@ public:
 // wxSocketEvent
 // --------------------------------------------------------------------------
 
 // wxSocketEvent
 // --------------------------------------------------------------------------
 

-class WXDLLEXPORT wxSocketEvent : public wxEvent
+class WXDLLIMPEXP_NET wxSocketEvent : public wxEvent

 {
 {

-  DECLARE_DYNAMIC_CLASS(wxSocketEvent)
-

 public:
 public:

-  wxSocketEvent(int id = 0);
+  wxSocketEvent(int id = 0)
+      : wxEvent(id, wxEVT_SOCKET)
+      {
+      }

 
   wxSocketNotify  GetSocketEvent() const { return m_event; }
   wxSocketBase   *GetSocket() const      { return (wxSocketBase *) GetEventObject(); }
   void           *GetClientData() const  { return m_clientData; }
 
 
   wxSocketNotify  GetSocketEvent() const { return m_event; }
   wxSocketBase   *GetSocket() const      { return (wxSocketBase *) GetEventObject(); }
   void           *GetClientData() const  { return m_clientData; }
 

-  // backwards compatibility
-  wxSocketNotify  SocketEvent() const    { return m_event; }
-  wxSocketBase   *Socket() const         { return (wxSocketBase *) GetEventObject(); }
-
-  void CopyObject(wxObject& object_dest) const;
+  virtual wxEvent *Clone() const { return new wxSocketEvent(*this); }

 
 public:
   wxSocketNotify  m_event;
   void           *m_clientData;
 
 public:
   wxSocketNotify  m_event;
   void           *m_clientData;

+
+  DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSocketEvent)

 };
 
 
 typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&);
 
 };
 
 
 typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&);
 

-#define EVT_SOCKET(id, func) { wxEVT_SOCKET, id, -1, \
-  (wxObjectEventFunction) (wxEventFunction) (wxSocketEventFunction) & func, \
-  (wxObject *) NULL },
+#define wxSocketEventHandler(func) \
+    (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxSocketEventFunction, &func)
+
+#define EVT_SOCKET(id, func) \
+    wx__DECLARE_EVT1(wxEVT_SOCKET, id, wxSocketEventHandler(func))

 
 

+#endif // wxUSE_SOCKETS

 
 

-#endif
-  // wxUSE_SOCKETS
+#endif // _WX_SOCKET_H_

 
 

-#endif
-  // _WX_NETWORK_SOCKET_H