X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/bfa7bf7d6b75e4fa31db205cf0b339c28ea6d090..77dd7daad2df0faac2b4e846ac9bb6aff588278c:/include/wx/socket.h

diff --git a/include/wx/socket.h b/include/wx/socket.h
index 7b153c09d9..5181d3b475 100644
--- a/include/wx/socket.h
+++ b/include/wx/socket.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        socket.h
+// Name:        wx/socket.h
 // Purpose:     Socket handling classes
 // Authors:     Guilhem Lavaux, Guillermo Rodriguez Garcia
 // Modified by:
@@ -9,12 +9,8 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
-#ifndef _WX_NETWORK_SOCKET_H
-#define _WX_NETWORK_SOCKET_H
-
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-  #pragma interface "socket.h"
-#endif
+#ifndef _WX_SOCKET_H_
+#define _WX_SOCKET_H_
 
 #include "wx/defs.h"
 
@@ -24,77 +20,86 @@
 // 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/gsocket.h"
 #include "wx/list.h"
 
+class wxSocketImpl;
+
 // ------------------------------------------------------------------------
 // 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
 {
-  wxSOCKET_INPUT = GSOCK_INPUT,
-  wxSOCKET_OUTPUT = GSOCK_OUTPUT,
-  wxSOCKET_CONNECTION = GSOCK_CONNECTION,
-  wxSOCKET_LOST = GSOCK_LOST
+    wxSOCKET_INPUT,
+    wxSOCKET_OUTPUT,
+    wxSOCKET_CONNECTION,
+    wxSOCKET_LOST
 };
 
 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
 {
-  // from GSocket
-  wxSOCKET_NOERROR = GSOCK_NOERROR,
-  wxSOCKET_INVOP = 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-specific (not yet implemented)
-  wxSOCKET_DUMMY
+    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
 {
-  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,
+    wxSOCKET_NOWAIT_READ = 64,
+    wxSOCKET_WAITALL_READ = 128,
+    wxSOCKET_NOWAIT_WRITE = 256,
+    wxSOCKET_WAITALL_WRITE = 512
 };
 
+typedef int wxSocketFlags;
+
+// socket kind values (badly defined, don't use)
 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;
-
 
+// event
+class WXDLLIMPEXP_FWD_NET wxSocketEvent;
+wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_NET, wxEVT_SOCKET, wxSocketEvent);
 
 // --------------------------------------------------------------------------
 // wxSocketBase
@@ -102,131 +107,189 @@ typedef int wxSocketFlags;
 
 class WXDLLIMPEXP_NET wxSocketBase : public wxObject
 {
-  DECLARE_CLASS(wxSocketBase)
-
 public:
-
-  // Public interface
-  // ----------------
-
-  // ctors and dtors
-  wxSocketBase();
-  wxSocketBase(wxSocketFlags flags, wxSocketType type);
-  virtual ~wxSocketBase();
-  void Init();
-  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); }
-  void SaveState();
-  void RestoreState();
-
-  // addresses
-  virtual bool GetLocal(wxSockAddress& addr_man) const;
-  virtual bool GetPeer(wxSockAddress& addr_man) const;
-
-  // base IO
-  virtual bool  Close();
-  wxSocketBase& Discard();
-  wxSocketBase& Peek(void* buffer, wxUint32 nbytes);
-  wxSocketBase& Read(void* buffer, wxUint32 nbytes);
-  wxSocketBase& ReadMsg(void *buffer, wxUint32 nbytes);
-  wxSocketBase& Unread(const void *buffer, wxUint32 nbytes);
-  wxSocketBase& Write(const void *buffer, wxUint32 nbytes);
-  wxSocketBase& WriteMsg(const void *buffer, wxUint32 nbytes);
-
-  void InterruptWait() { m_interrupt = TRUE; };
-  bool Wait(long seconds = -1, long milliseconds = 0);
-  bool WaitForRead(long seconds = -1, long milliseconds = 0);
-  bool WaitForWrite(long seconds = -1, long milliseconds = 0);
-  bool WaitForLost(long seconds = -1, long milliseconds = 0);
-
-  inline wxSocketFlags GetFlags() const { return m_flags; }
-  void SetFlags(wxSocketFlags flags);
-  void SetTimeout(long seconds);
-
-  bool GetOption(int level, int optname, void *optval, int *optlen);
-  bool SetOption(int level, int optname, const void *optval, int optlen);
-  inline wxUint32 GetLastIOSize() const { return m_lcount; };
-
-  // event handling
-  void *GetClientData() const { return m_clientData; }
-  void SetClientData(void *data) { m_clientData = data; }
-  void SetEventHandler(wxEvtHandler& handler, int id = -1);
-  void SetNotify(wxSocketEventFlags flags);
-  void Notify(bool notify);
-
-  // initialize/shutdown the sockets (usually called automatically)
-  static bool IsInitialized();
-  static bool Initialize();
-  static void Shutdown();
-
-
-  // Implementation from now on
-  // --------------------------
-
-  // do not use, should be private (called from GSocket)
-  void OnRequest(wxSocketNotify notify);
-
-  // do not use, not documented nor supported
-  inline bool IsNoWait() const { return ((m_flags & wxSOCKET_NOWAIT) != 0); }
-  inline wxSocketType GetType() const { return m_type; }
+    // Public interface
+    // ----------------
+
+    // ctors and dtors
+    wxSocketBase();
+    wxSocketBase(wxSocketFlags flags, wxSocketType type);
+    virtual ~wxSocketBase();
+    void Init();
+    bool Destroy();
+
+    // state
+    bool Ok() const { return IsOk(); }
+    bool IsOk() const { return m_impl != NULL; }
+    bool Error() const { return LastError() != wxSOCKET_NOERROR; }
+    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; }
+    wxUint32 LastReadCount() const { return m_lcount_read; }
+    wxUint32 LastWriteCount() const { return m_lcount_write; }
+    wxSocketError LastError() 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();
+    void ShutdownOutput();
+    wxSocketBase& Discard();
+    wxSocketBase& Peek(void* buffer, wxUint32 nbytes);
+    wxSocketBase& Read(void* buffer, wxUint32 nbytes);
+    wxSocketBase& ReadMsg(void *buffer, wxUint32 nbytes);
+    wxSocketBase& Unread(const void *buffer, wxUint32 nbytes);
+    wxSocketBase& Write(const void *buffer, wxUint32 nbytes);
+    wxSocketBase& WriteMsg(const void *buffer, wxUint32 nbytes);
+
+    // 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);
+
+    // 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);
+
+    // wait until the connection is terminated
+    bool WaitForLost(long seconds = -1, long milliseconds = 0);
+
+    void InterruptWait() { m_interrupt = true; }
+
+
+    wxSocketFlags GetFlags() const { return m_flags; }
+    void SetFlags(wxSocketFlags flags);
+    virtual 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; }
+    wxUint32 GetLastIOReadSize() const { return m_lcount_read; }
+    wxUint32 GetLastIOWriteSize() const { return m_lcount_write; }
+
+    // event handling
+    void *GetClientData() const { return m_clientData; }
+    void SetClientData(void *data) { m_clientData = data; }
+    void SetEventHandler(wxEvtHandler& handler, int id = wxID_ANY);
+    void SetNotify(wxSocketEventFlags flags);
+    void Notify(bool notify);
+
+    // initialize/shutdown the sockets (done automatically so there is no need
+    // to call these functions usually)
+    //
+    // should always be called from the main thread only so one of the cases
+    // where they should indeed be called explicitly is when the first wxSocket
+    // object in the application is created in a different thread
+    static bool Initialize();
+    static void Shutdown();
+
+    // check if wxSocket had been already initialized
+    //
+    // notice that this function should be only called from the main thread as
+    // otherwise it is inherently unsafe because Initialize/Shutdown() may be
+    // called concurrently with it in the main thread
+    static bool IsInitialized();
+
+    // Implementation from now on
+    // --------------------------
+
+    // do not use, should be private (called from wxSocketImpl only)
+    void OnRequest(wxSocketNotify notify);
+
+    // do not use, not documented nor supported
+    bool IsNoWait() const { return ((m_flags & wxSOCKET_NOWAIT) != 0); }
+    wxSocketType GetType() const { return m_type; }
 
 private:
-  friend class wxSocketClient;
-  friend class wxSocketServer;
-  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);
-
-  // pushback buffer
-  void     Pushback(const void *buffer, wxUint32 size);
-  wxUint32 GetPushback(void *buffer, wxUint32 size, bool peek);
+    friend class wxSocketClient;
+    friend class wxSocketServer;
+    friend class wxDatagramSocket;
+
+    // low level IO
+    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 and the
+    // function returns -1 if the connection was lost; otherwise it returns
+    // true if any of the events specified by flags argument happened or false
+    // if the timeout expired
+    int DoWait(long timeout, wxSocketEventFlags flags);
+
+    // a helper calling DoWait() using the same convention as the public
+    // WaitForXXX() functions use, i.e. use our timeout if seconds == -1 or the
+    // specified timeout otherwise
+    int DoWait(long seconds, long milliseconds, wxSocketEventFlags flags);
+
+    // another helper calling DoWait() using our m_timeout
+    int DoWaitWithTimeout(wxSocketEventFlags flags)
+    {
+        return DoWait(m_timeout*1000, flags);
+    }
+
+    // pushback buffer
+    void     Pushback(const void *buffer, wxUint32 size);
+    wxUint32 GetPushback(void *buffer, wxUint32 size, bool peek);
+
+    // store the given error as the LastError()
+    void SetError(wxSocketError error);
 
 private:
-  // socket
-  GSocket      *m_socket;           // GSocket
-  wxSocketType  m_type;             // wxSocket type
-
-  // state
-  wxSocketFlags m_flags;            // wxSocket flags
-  bool          m_connected;        // connected?
-  bool          m_establishing;     // establishing connection?
-  bool          m_reading;          // busy reading?
-  bool          m_writing;          // busy writing?
-  bool          m_error;            // did last IO call fail?
-  wxSocketError m_lasterror;        // last error (not cleared on success)
-  wxUint32      m_lcount;           // last IO transaction size
-  unsigned long m_timeout;          // IO timeout value
-  wxList        m_states;           // stack of states
-  bool          m_interrupt;        // interrupt ongoing wait operations?
-  bool          m_beingDeleted;     // marked for delayed deletion?
-
-  // pushback buffer
-  void         *m_unread;           // pushback buffer
-  wxUint32      m_unrd_size;        // pushback buffer size
-  wxUint32      m_unrd_cur;         // pushback pointer (index into buffer)
-
-  // events
-  int           m_id;               // socket id
-  wxEvtHandler *m_handler;          // event handler
-  void         *m_clientData;       // client data for events
-  bool          m_notify;           // notify events to users?
-  wxSocketEventFlags  m_eventmask;  // which events to notify?
-
-  // the initialization count, GSocket is initialized if > 0
-  static size_t m_countInit;
-
-    DECLARE_NO_COPY_CLASS(wxSocketBase)
+    // socket
+    wxSocketImpl *m_impl;             // port-specific implementation
+    wxSocketType  m_type;             // wxSocket type
+
+    // state
+    wxSocketFlags m_flags;            // wxSocket flags
+    bool          m_connected;        // connected?
+    bool          m_establishing;     // establishing connection?
+    bool          m_reading;          // busy reading?
+    bool          m_writing;          // busy writing?
+    bool          m_closed;           // was the other end closed?
+    wxUint32      m_lcount;           // last IO transaction size
+    wxUint32      m_lcount_read;      // last IO transaction size of Read() direction.
+    wxUint32      m_lcount_write;     // last IO transaction size of Write() direction.
+    unsigned long m_timeout;          // IO timeout value in seconds
+                                      // (TODO: remove, wxSocketImpl has it too)
+    wxList        m_states;           // stack of states (TODO: remove!)
+    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
+    wxUint32      m_unrd_size;        // pushback buffer size
+    wxUint32      m_unrd_cur;         // pushback pointer (index into buffer)
+
+    // events
+    int           m_id;               // socket id
+    wxEvtHandler *m_handler;          // event handler
+    void         *m_clientData;       // client data for events
+    bool          m_notify;           // notify events to users?
+    wxSocketEventFlags  m_eventmask;  // which events to notify?
+    wxSocketEventFlags  m_eventsgot;  // collects events received in OnRequest()
+
+
+    friend class wxSocketReadGuard;
+    friend class wxSocketWriteGuard;
+
+    wxDECLARE_NO_COPY_CLASS(wxSocketBase);
+    DECLARE_CLASS(wxSocketBase)
 };
 
 
@@ -236,17 +299,17 @@ private:
 
 class WXDLLIMPEXP_NET wxSocketServer : public wxSocketBase
 {
-  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)
+    wxDECLARE_NO_COPY_CLASS(wxSocketServer);
+    DECLARE_CLASS(wxSocketServer)
 };
 
 
@@ -256,17 +319,36 @@ public:
 
 class WXDLLIMPEXP_NET wxSocketClient : public wxSocketBase
 {
-  DECLARE_CLASS(wxSocketClient)
-
 public:
-  wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE);
-  virtual ~wxSocketClient();
+    wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE);
+
+    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);
 
-  virtual bool Connect(wxSockAddress& addr, bool wait = TRUE);
+    // 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;
+    }
 
-  bool WaitOnConnect(long seconds = -1, long milliseconds = 0);
+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)
+    wxDECLARE_NO_COPY_CLASS(wxSocketClient);
+    DECLARE_CLASS(wxSocketClient)
 };
 
 
@@ -278,22 +360,24 @@ public:
 
 class WXDLLIMPEXP_NET wxDatagramSocket : public wxSocketBase
 {
-  DECLARE_CLASS(wxDatagramSocket)
-
 public:
-  wxDatagramSocket(wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE);
-
-  wxDatagramSocket& RecvFrom( wxSockAddress& addr,
-                              void* buf,
-                              wxUint32 nBytes );
-  wxDatagramSocket& SendTo( wxSockAddress& addr,
-                            const void* buf,
-                            wxUint32 nBytes );
-
-/* TODO:
-  bool Connect(wxSockAddress& addr);
-*/
-  DECLARE_NO_COPY_CLASS(wxDatagramSocket)
+    wxDatagramSocket(const wxSockAddress& addr,
+                     wxSocketFlags flags = wxSOCKET_NONE);
+
+    wxDatagramSocket& RecvFrom(wxSockAddress& addr,
+                               void *buf,
+                               wxUint32 nBytes);
+    wxDatagramSocket& SendTo(const wxSockAddress& addr,
+                             const void* buf,
+                             wxUint32 nBytes);
+
+    /* TODO:
+       bool Connect(wxSockAddress& addr);
+     */
+
+private:
+    wxDECLARE_NO_COPY_CLASS(wxDatagramSocket);
+    DECLARE_CLASS(wxDatagramSocket)
 };
 
 
@@ -304,35 +388,36 @@ public:
 class WXDLLIMPEXP_NET wxSocketEvent : public wxEvent
 {
 public:
-  wxSocketEvent(int id = 0)
-      : wxEvent(id, wxEVT_SOCKET)
-      {
-      }
+    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; }
 
-  virtual wxEvent *Clone() const { return new wxSocketEvent(*this); }
+    virtual wxEvent *Clone() const { return new wxSocketEvent(*this); }
+    virtual wxEventCategory GetEventCategory() const { return wxEVT_CATEGORY_SOCKET; }
 
 public:
-  wxSocketNotify  m_event;
-  void           *m_clientData;
+    wxSocketNotify  m_event;
+    void           *m_clientData;
 
-  DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSocketEvent)
+    DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSocketEvent)
 };
 
 
 typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&);
 
+#define wxSocketEventHandler(func) \
+    wxEVENT_HANDLER_CAST(wxSocketEventFunction, func)
+
 #define EVT_SOCKET(id, func) \
-    DECLARE_EVENT_TABLE_ENTRY( wxEVT_SOCKET, id, -1, \
-        (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxSocketEventFunction, & func ), \
-        (wxObject *) NULL ),
+    wx__DECLARE_EVT1(wxEVT_SOCKET, id, wxSocketEventHandler(func))
 
+#endif // wxUSE_SOCKETS
 
-#endif
-  // wxUSE_SOCKETS
+#endif // _WX_SOCKET_H_
 
-#endif
-  // _WX_NETWORK_SOCKET_H