From 71622a7ac0a6e92528a4fc13d1ceb87a486e491d Mon Sep 17 00:00:00 2001 From: Guillermo Rodriguez Garcia Date: Tue, 7 Mar 2000 16:11:58 +0000 Subject: [PATCH] First set of changes toward wxBase compliance :-) git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@6506 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- include/wx/socket.h | 268 ++++++++++++++++++++++-------------------- src/common/socket.cpp | 191 +++++++++++++----------------- 2 files changed, 221 insertions(+), 238 deletions(-) diff --git a/include/wx/socket.h b/include/wx/socket.h index d991e85afb..f8f5575aca 100644 --- a/include/wx/socket.h +++ b/include/wx/socket.h @@ -21,7 +21,7 @@ #if wxUSE_SOCKETS // --------------------------------------------------------------------------- -// wxSocket headers (generic) +// wxSocket headers // --------------------------------------------------------------------------- #ifdef WXPREC @@ -35,7 +35,7 @@ #include "wx/gsocket.h" // ------------------------------------------------------------------------ -// constants +// Types and constants // ------------------------------------------------------------------------ enum wxSocketNotify @@ -67,8 +67,7 @@ enum wxSocketError wxSOCKET_INVPORT = GSOCK_INVPORT, wxSOCKET_WOULDBLOCK = GSOCK_WOULDBLOCK, wxSOCKET_TIMEDOUT = GSOCK_TIMEDOUT, - wxSOCKET_MEMERR = GSOCK_MEMERR, - wxSOCKET_BUSY + wxSOCKET_MEMERR = GSOCK_MEMERR }; enum @@ -80,29 +79,38 @@ enum }; // Type of socket -enum wxSockType +enum wxSocketType { - SOCK_CLIENT, - SOCK_SERVER, - SOCK_DATAGRAM, - SOCK_INTERNAL, - SOCK_UNINIT + wxSOCKET_UNINIT, + wxSOCKET_CLIENT, + wxSOCKET_SERVER, + wxSOCKET_BASE, + wxSOCKET_DATAGRAM }; -typedef int wxSockFlags; +typedef int wxSocketFlags; -// ------------------------------------------------------------------------ -// wxSocket base -// ------------------------------------------------------------------------ -class WXDLLEXPORT wxTimer; -class WXDLLEXPORT wxSocketEvent; +// old names + +#if WXWIN_COMPATIBILITY + +typedef wxSocketType wxSockType; +typedef wxSocketFlags wxSockFlags; + +#endif // WXWIN_COMPATIBILITY -class WXDLLEXPORT wxSocketBase : public wxEvtHandler +// -------------------------------------------------------------------------- +// wxSocketBase +// -------------------------------------------------------------------------- + +class WXDLLEXPORT wxSocketBase : public wxObject { DECLARE_CLASS(wxSocketBase) + public: +#if WXWIN_COMPATIBILITY enum { NONE = wxSOCKET_NONE, @@ -111,179 +119,178 @@ public: SPEED = wxSOCKET_BLOCK }; - typedef void (*wxSockCbk)(wxSocketBase& sock, wxSocketNotify evt, char *cdata); + enum + { + SOCK_UNINIT = wxSOCKET_UNINIT, + SOCK_CLIENT = wxSOCKET_CLIENT, + SOCK_SERVER = wxSOCKET_SERVER, + SOCK_INTERNAL = wxSOCKET_BASE, + SOCK_DATAGRAM = wxSOCKET_DATAGRAM + }; +#endif // WXWIN_COMPATIBILITY -protected: - GSocket *m_socket; // GSocket - wxEvtHandler *m_evt_handler; // event handler - int m_id; // Socket id (for event handler) - - // Attributes - wxSockFlags m_flags; // wxSocket flags - wxSockType m_type; // wxSocket type - wxSocketEventFlags m_neededreq; // Event mask - bool m_notify_state; // Notify events to users? - - // State - 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? - 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 + typedef void (*wxSockCbk)(wxSocketBase& sock, wxSocketNotify evt, char *cdata); - // Pushback buffer - char *m_unread; // Pushback buffer - wxUint32 m_unrd_size; // Pushback buffer size - wxUint32 m_unrd_cur; // Pushback pointer (index into buffer) +public: - // Callback - wxSockCbk m_cbk; // C callback - char *m_cdata; // C callback data + // Public interface + // ---------------- -public: + // ctors and dtors wxSocketBase(); + wxSocketBase(wxSocketFlags flags, wxSocketType type); virtual ~wxSocketBase(); - virtual bool Destroy(); - - // Base IO - virtual bool Close(); - wxSocketBase& Peek(char* buffer, wxUint32 nbytes); - wxSocketBase& Read(char* buffer, wxUint32 nbytes); - wxSocketBase& Write(const char *buffer, wxUint32 nbytes); - wxSocketBase& Unread(const char *buffer, wxUint32 nbytes); - wxSocketBase& ReadMsg(char *buffer, wxUint32 nbytes); - wxSocketBase& WriteMsg(const char *buffer, wxUint32 nbytes); - wxSocketBase& Discard(); + void Init(); + bool Destroy(); - // Status + // 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 IsDisconnected() const { return !IsConnected(); }; - inline bool IsNoWait() const { return ((m_flags & NOWAIT) != 0); }; 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); } - inline wxSockType GetType() const { return m_type; } + void SaveState(); + void RestoreState(); - // Addresses - virtual bool GetPeer(wxSockAddress& addr_man) const; + // addresses virtual bool GetLocal(wxSockAddress& addr_man) const; + virtual bool GetPeer(wxSockAddress& addr_man) const; - // Set attributes and flags - void SetTimeout(long seconds); - void SetFlags(wxSockFlags flags); - inline wxSockFlags GetFlags() const { return m_flags; }; - - /* Wait functions - * seconds = -1 means default timeout (change with SetTimeout) - * seconds, milliseconds = 0 means no wait - * seconds, milliseconds > 0 means specified wait - */ + // base IO + virtual bool Close(); + wxSocketBase& Discard(); + wxSocketBase& Peek(char* buffer, wxUint32 nbytes); + wxSocketBase& Read(char* buffer, wxUint32 nbytes); + wxSocketBase& ReadMsg(char *buffer, wxUint32 nbytes); + wxSocketBase& Unread(const char *buffer, wxUint32 nbytes); + wxSocketBase& Write(const char *buffer, wxUint32 nbytes); + wxSocketBase& WriteMsg(const char *buffer, wxUint32 nbytes); + + void InterruptAllWaits() { 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); - /* This function interrupts all ongoing wait operations for this - * socket; use it only as an escape mechanism (for example to close - * an app or to abort an operation). Reception of LOST events and - * calls to Close() automatically call this. - */ - void InterruptAllWaits() { m_interrupt = TRUE; }; - - // Save the current state of Socket - void SaveState(); - void RestoreState(); - - // Setup event handler - void SetEventHandler(wxEvtHandler& evt_hdlr, int id = -1); + inline wxSocketFlags GetFlags() const { return m_flags; }; + void SetFlags(wxSocketFlags flags); + void SetTimeout(long seconds); - // Tell wxSocket which events to notify + // event handling + void SetEventHandler(wxEvtHandler& handler, int id = -1); void SetNotify(wxSocketEventFlags flags); void Notify(bool notify); - static wxSocketEventFlags EventToNotify(wxSocketNotify evt); - inline wxSocketEventFlags NeededReq() const { return m_neededreq; } - // External callback + // callbacks - deprecated, avoid if possible wxSockCbk Callback(wxSockCbk cbk_); char *CallbackData(char *data); - // Public internal callback - virtual void OldOnNotify(wxSocketNotify WXUNUSED(evt)); - // Do NOT use this function; it should be protected! - void OnRequest(wxSocketNotify req_evt); - -protected: - friend class wxSocketServer; - friend class wxSocketClient; - friend class wxSocketHandler; + // Implementation from now on + // -------------------------- -#ifdef __SALFORDC__ -public: -#endif + // do not use, this should be private + void OnRequest(wxSocketNotify req_evt); - wxSocketBase(wxSockFlags flags, wxSockType type); + // do not use, not documented nor supported + inline bool IsNoWait() const { return ((m_flags & wxSOCKET_NOWAIT) != 0); }; + inline wxSocketType GetType() const { return m_type; } -#ifdef __SALFORDC__ protected: -#endif - // Low level IO + // low level IO wxUint32 _Read(char* buffer, wxUint32 nbytes); wxUint32 _Write(const char *buffer, wxUint32 nbytes); bool _Wait(long seconds, long milliseconds, wxSocketEventFlags flags); - // Pushbacks + // pushback buffer void Pushback(const char *buffer, wxUint32 size); wxUint32 GetPushback(char *buffer, wxUint32 size, bool peek); + +protected: + + 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? + 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 + char *m_unread; // pushback buffer + wxUint32 m_unrd_size; // pushback buffer size + wxUint32 m_unrd_cur; // pushback pointer (index into buffer) + + // events + wxEvtHandler *m_handler; // event handler + int m_id; // socket id + bool m_notify_state; // notify events to users? + wxSocketEventFlags + m_neededreq; // event mask + wxSockCbk m_cbk; // callback + char *m_cdata; // callback data }; -//////////////////////////////////////////////////////////////////////// + +// -------------------------------------------------------------------------- +// wxSocketServer +// -------------------------------------------------------------------------- class WXDLLEXPORT wxSocketServer : public wxSocketBase { DECLARE_CLASS(wxSocketServer) -public: - // 'service' can be a name or a port-number - wxSocketServer(wxSockAddress& addr_man, wxSockFlags flags = wxSOCKET_NONE); +public: + wxSocketServer(wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE); wxSocketBase* Accept(bool wait = TRUE); - bool AcceptWith(wxSocketBase& sock, bool wait = TRUE); + bool AcceptWith(wxSocketBase& socket, bool wait = TRUE); bool WaitForAccept(long seconds = -1, long milliseconds = 0); }; -//////////////////////////////////////////////////////////////////////// + +// -------------------------------------------------------------------------- +// wxSocketClient +// -------------------------------------------------------------------------- class WXDLLEXPORT wxSocketClient : public wxSocketBase { DECLARE_CLASS(wxSocketClient) -public: - wxSocketClient(wxSockFlags flags = wxSOCKET_NONE); +public: + wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE); virtual ~wxSocketClient(); - virtual bool Connect(wxSockAddress& addr_man, bool wait = TRUE); + virtual bool Connect(wxSockAddress& addr, bool wait = TRUE); bool WaitOnConnect(long seconds = -1, long milliseconds = 0); }; -//////////////////////////////////////////////////////////////////////// + +// -------------------------------------------------------------------------- +// wxDatagramSocket +// -------------------------------------------------------------------------- + +// WARNING: still in alpha stage class wxDatagramSocket : public wxSocketBase { DECLARE_CLASS(wxDatagramSocket) public: - wxDatagramSocket( wxSockAddress& addr, wxSockFlags flags = wxSOCKET_NONE ); + wxDatagramSocket(wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE); wxDatagramSocket& RecvFrom( wxSockAddress& addr, char* buf, @@ -293,29 +300,36 @@ public: wxUint32 nBytes ); }; -//////////////////////////////////////////////////////////////////////// -class WXDLLEXPORT wxSocketEvent : public wxEvent { +// -------------------------------------------------------------------------- +// wxSocketEvent +// -------------------------------------------------------------------------- + +class WXDLLEXPORT wxSocketEvent : public wxEvent +{ DECLARE_DYNAMIC_CLASS(wxSocketEvent) + public: wxSocketEvent(int id = 0); - wxSocketNotify SocketEvent() const { return m_skevt; } - wxSocketBase *Socket() const { return m_socket; } + wxSocketNotify SocketEvent() const { return m_event; } + wxSocketBase *Socket() const { return m_socket; } - void CopyObject(wxObject& obj_d) const; + void CopyObject(wxObject& object_dest) const; public: - wxSocketNotify m_skevt; - wxSocketBase *m_socket; + wxSocketNotify m_event; + wxSocketBase *m_socket; }; + typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&); #define EVT_SOCKET(id, func) { wxEVT_SOCKET, id, -1, \ (wxObjectEventFunction) (wxEventFunction) (wxSocketEventFunction) & func, \ (wxObject *) NULL }, + #endif // wxUSE_SOCKETS diff --git a/src/common/socket.cpp b/src/common/socket.cpp index 9436c636b6..4cefd26bc9 100644 --- a/src/common/socket.cpp +++ b/src/common/socket.cpp @@ -37,6 +37,7 @@ #include "wx/intl.h" #if wxUSE_GUI + #include "wx/event.h" #include "wx/gdicmn.h" // for wxPendingDelete #endif // wxUSE_GUI @@ -68,7 +69,7 @@ class wxSocketState : public wxObject public: bool m_notify_state; wxSocketEventFlags m_neededreq; - wxSockFlags m_flags; + wxSocketFlags m_flags; wxSocketBase::wxSockCbk m_cbk; char *m_cdata; @@ -85,32 +86,44 @@ public: // Ctor and dtor // -------------------------------------------------------------------------- -wxSocketBase::wxSocketBase(wxSockFlags _flags, wxSockType _type) : - wxEvtHandler(), - m_socket(NULL), m_evt_handler(NULL), m_id(-1), - m_flags(_flags), m_type(_type), - m_neededreq(0), m_notify_state(FALSE), - m_connected(FALSE), m_establishing(FALSE), - m_reading(FALSE), m_writing(FALSE), - m_error(FALSE), m_lcount(0), m_timeout(600), - m_states(), m_beingDeleted(FALSE), - m_unread(NULL), m_unrd_size(0), m_unrd_cur(0), - m_cbk(NULL), m_cdata(NULL) +void wxSocketBase::Init() { + m_socket = NULL; + m_type = wxSOCKET_UNINIT; + + // state + m_flags = 0; + m_connected = + m_establishing = + m_reading = + m_writing = + m_error = FALSE; + m_lcount = 0; + m_timeout = 600; + m_beingDeleted = FALSE; + + // pushback buffer + m_unread = NULL; + m_unrd_size = 0; + m_unrd_cur = 0; + + // events + m_handler = NULL; + m_id = -1; + m_notify_state = FALSE; + m_neededreq = 0; + m_cbk = NULL; + m_cdata = NULL; } -wxSocketBase::wxSocketBase() : - wxEvtHandler(), - m_socket(NULL), m_evt_handler(NULL), m_id(-1), - m_flags(NONE), m_type(SOCK_UNINIT), - m_neededreq(0), m_notify_state(FALSE), - m_connected(FALSE), m_establishing(FALSE), - m_reading(FALSE), m_writing(FALSE), - m_error(FALSE), m_lcount(0), m_timeout(600), - m_states(), m_beingDeleted(FALSE), - m_unread(NULL), m_unrd_size(0), m_unrd_cur(0), - m_cbk(NULL), m_cdata(NULL) +wxSocketBase::wxSocketBase() { Init(); } + +wxSocketBase::wxSocketBase(wxSocketFlags flags, wxSocketType type) { + Init(); + + m_flags = flags; + m_type = type; } wxSocketBase::~wxSocketBase() @@ -565,33 +578,11 @@ wxSocketBase& wxSocketBase::Discard() // timeout elapses. The polling loop calls PROCESS_EVENTS(), so // this won't block the GUI. -#if wxUSE_GUI - -class _wxSocketInternalTimer: public wxTimer -{ -public: - int *m_state; - unsigned long m_new_val; - - void Notify() - { - *m_state = (int)m_new_val; // Change the value - } -}; - -#endif // wxUSE_GUI - bool wxSocketBase::_Wait(long seconds, long milliseconds, wxSocketEventFlags flags) { GSocketEventFlags result; -#if wxUSE_GUI - _wxSocketInternalTimer timer; - wxTimerRunner runTimer(timer); -#endif // wxUSE_GUI - long timeout; - int state = -1; // Set this to TRUE to interrupt ongoing waits m_interrupt = FALSE; @@ -600,22 +591,12 @@ bool wxSocketBase::_Wait(long seconds, long milliseconds, if (!m_socket) return FALSE; - // Check for valid timeout value + // Check for valid timeout value. if (seconds != -1) timeout = seconds * 1000 + milliseconds; else timeout = m_timeout * 1000; - // Activate timer - if (timeout) - { -#if wxUSE_GUI - timer.m_state = &state; - timer.m_new_val = 0; - runTimer.Start((int)timeout, TRUE); -#endif // wxUSE_GUI - } - // Active polling (without using events) // // NOTE: this duplicates some of the code in OnRequest (lost @@ -628,7 +609,10 @@ bool wxSocketBase::_Wait(long seconds, long milliseconds, // Do this at least once (important if timeout == 0, when // we are just polling). Also, if just polling, do not yield. - while (state == -1) + wxStopWatch chrono; + bool done = FALSE; + + while (!done) { result = GSocket_Select(m_socket, flags | GSOCK_LOST_FLAG); @@ -655,8 +639,8 @@ bool wxSocketBase::_Wait(long seconds, long milliseconds, } // Wait more? - if ((timeout == 0) || (m_interrupt)) - break; + if ((!timeout) || (chrono.Time() > timeout) || (m_interrupt)) + done = TRUE; else PROCESS_EVENTS(); } @@ -785,9 +769,9 @@ void wxSocketBase::SetTimeout(long seconds) GSocket_SetTimeout(m_socket, m_timeout * 1000); } -void wxSocketBase::SetFlags(wxSockFlags _flags) +void wxSocketBase::SetFlags(wxSocketFlags flags) { - m_flags = _flags; + m_flags = flags; } // -------------------------------------------------------------------------- @@ -827,18 +811,6 @@ static void LINKAGEMODE wx_socket_callback(GSocket * WXUNUSED(socket), sckobj->OnRequest((wxSocketNotify)event); } -wxSocketEventFlags wxSocketBase::EventToNotify(wxSocketNotify evt) -{ - switch (evt) - { - case GSOCK_INPUT: return GSOCK_INPUT_FLAG; - case GSOCK_OUTPUT: return GSOCK_OUTPUT_FLAG; - case GSOCK_CONNECTION: return GSOCK_CONNECTION_FLAG; - case GSOCK_LOST: return GSOCK_LOST_FLAG; - } - return 0; -} - void wxSocketBase::SetNotify(wxSocketEventFlags flags) { m_neededreq = flags; @@ -851,8 +823,15 @@ void wxSocketBase::Notify(bool notify) void wxSocketBase::OnRequest(wxSocketNotify req_evt) { - wxSocketEvent event(m_id); - wxSocketEventFlags flag = EventToNotify(req_evt); + wxSocketEventFlags flag = -1; + + switch (req_evt) + { + case GSOCK_INPUT: flag = GSOCK_INPUT_FLAG; break; + case GSOCK_OUTPUT: flag = GSOCK_OUTPUT_FLAG; break; + case GSOCK_CONNECTION: flag = GSOCK_CONNECTION_FLAG; break; + case GSOCK_LOST: flag = GSOCK_LOST_FLAG; break; + } // This duplicates some code in _Wait, but this doesn't // hurt. It has to be here because we don't know whether @@ -891,34 +870,28 @@ void wxSocketBase::OnRequest(wxSocketNotify req_evt) if (((m_neededreq & flag) == flag) && m_notify_state) { - event.m_socket = this; - event.m_skevt = req_evt; - - if (m_evt_handler) + if (m_handler) { + wxSocketEvent event(m_id); + event.m_socket = this; + event.m_event = req_evt; + #if USE_DELAYED_EVENTS - wxPostEvent(m_evt_handler, event); + wxPostEvent(m_handler, event); #else - ProcessEvent(event); + m_handler->ProcessEvent(event); #endif } - OldOnNotify(req_evt); if (m_cbk) m_cbk(*this, req_evt, m_cdata); } } -void wxSocketBase::OldOnNotify(wxSocketNotify WXUNUSED(evt)) -{ -} - -void wxSocketBase::SetEventHandler(wxEvtHandler& h_evt, int id) +void wxSocketBase::SetEventHandler(wxEvtHandler& handler, int id) { - m_evt_handler = &h_evt; - m_id = id; - - SetNextHandler(&h_evt); + m_handler = &handler; + m_id = id; } // -------------------------------------------------------------------------- @@ -981,8 +954,8 @@ wxUint32 wxSocketBase::GetPushback(char *buffer, wxUint32 size, bool peek) // -------------------------------------------------------------------------- wxSocketServer::wxSocketServer(wxSockAddress& addr_man, - wxSockFlags flags) - : wxSocketBase(flags, SOCK_SERVER) + wxSocketFlags flags) + : wxSocketBase(flags, wxSOCKET_SERVER) { // Create the socket m_socket = GSocket_new(); @@ -1032,7 +1005,7 @@ bool wxSocketServer::AcceptWith(wxSocketBase& sock, bool wait) if (!child_socket) return FALSE; - sock.m_type = SOCK_INTERNAL; + sock.m_type = wxSOCKET_BASE; sock.m_socket = child_socket; sock.m_connected = TRUE; @@ -1048,7 +1021,7 @@ wxSocketBase *wxSocketServer::Accept(bool wait) { wxSocketBase* sock = new wxSocketBase(); - sock->SetFlags((wxSockFlags)m_flags); + sock->SetFlags(m_flags); if (!AcceptWith(*sock, wait)) return NULL; @@ -1069,12 +1042,11 @@ bool wxSocketServer::WaitForAccept(long seconds, long milliseconds) // Ctor and dtor // -------------------------------------------------------------------------- -wxSocketClient::wxSocketClient(wxSockFlags _flags) - : wxSocketBase(_flags, SOCK_CLIENT) +wxSocketClient::wxSocketClient(wxSocketFlags flags) + : wxSocketBase(flags, wxSOCKET_CLIENT) { } -// XXX: What is this for ? wxSocketClient::~wxSocketClient() { } @@ -1149,8 +1121,9 @@ bool wxSocketClient::WaitOnConnect(long seconds, long milliseconds) /* NOTE: experimental stuff - might change */ -wxDatagramSocket::wxDatagramSocket( wxSockAddress& addr, wxSockFlags flags ) - : wxSocketBase( flags, SOCK_DATAGRAM ) +wxDatagramSocket::wxDatagramSocket( wxSockAddress& addr, + wxSocketFlags flags ) + : wxSocketBase( flags, wxSOCKET_DATAGRAM ) { // Create the socket m_socket = GSocket_new(); @@ -1199,26 +1172,22 @@ wxDatagramSocket& wxDatagramSocket::SendTo( wxSockAddress& addr, // wxSocketEvent // ========================================================================== -// XXX: Should be moved to event.cpp ? - -wxSocketEvent::wxSocketEvent(int id) - : wxEvent(id) +wxSocketEvent::wxSocketEvent(int id) : wxEvent(id) { - wxEventType type = (wxEventType)wxEVT_SOCKET; - - SetEventType(type); + SetEventType( (wxEventType)wxEVT_SOCKET ); } -void wxSocketEvent::CopyObject(wxObject& obj_d) const +void wxSocketEvent::CopyObject(wxObject& object_dest) const { - wxSocketEvent *event = (wxSocketEvent *)&obj_d; + wxSocketEvent *event = (wxSocketEvent *)&object_dest; - wxEvent::CopyObject(obj_d); + wxEvent::CopyObject(object_dest); - event->m_skevt = m_skevt; + event->m_event = m_event; event->m_socket = m_socket; } + // ========================================================================== // wxSocketModule // ========================================================================== -- 2.45.2