Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Finally deprecated callbacks.

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@6580 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Guillermo Rodriguez Garcia
2000-03-10 05:31:53 +00:00
parent cdc59bb69e
commit bffc1eaaf5
2 changed files with 115 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
include/wx/socket.h
View File

@@ -13,7 +13,7 @@
#define _WX_NETWORK_SOCKET_H #define _WX_NETWORK_SOCKET_H
#ifdef __GNUG__ #ifdef __GNUG__
#pragma interface "socket.h" #pragma interface "socket.h"
#endif #endif
#include "wx/defs.h" #include "wx/defs.h"
@@ -25,10 +25,10 @@
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
#ifdef WXPREC #ifdef WXPREC
# include "wx/wxprec.h" #include "wx/wxprec.h"
#else #else
# include "wx/event.h" #include "wx/event.h"
# include "wx/string.h" #include "wx/string.h"
#endif #endif
#include "wx/sckaddr.h" #include "wx/sckaddr.h"
@@ -78,7 +78,6 @@ enum
wxSOCKET_BLOCK = 4 wxSOCKET_BLOCK = 4
}; };
// Type of socket
enum wxSocketType enum wxSocketType
{ {
wxSOCKET_UNINIT, wxSOCKET_UNINIT,
@@ -91,15 +90,12 @@ enum wxSocketType
typedef int wxSocketFlags; typedef int wxSocketFlags;
// old names
#if WXWIN_COMPATIBILITY #if WXWIN_COMPATIBILITY
typedef wxSocketType wxSockType;
typedef wxSocketType wxSockType; typedef wxSocketFlags wxSockFlags;
typedef wxSocketFlags wxSockFlags;
#endif // WXWIN_COMPATIBILITY #endif // WXWIN_COMPATIBILITY
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// wxSocketBase // wxSocketBase
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -127,9 +123,9 @@ public:
SOCK_INTERNAL = wxSOCKET_BASE, SOCK_INTERNAL = wxSOCKET_BASE,
SOCK_DATAGRAM = wxSOCKET_DATAGRAM SOCK_DATAGRAM = wxSOCKET_DATAGRAM
}; };
#endif // WXWIN_COMPATIBILITY
typedef void (*wxSockCbk)(wxSocketBase& sock, wxSocketNotify evt, char *cdata); typedef void (*wxSockCbk)(wxSocketBase& sock, wxSocketNotify evt, char *cdata);
#endif // WXWIN_COMPATIBILITY
public: public:
@@ -168,7 +164,7 @@ public:
wxSocketBase& Write(const void *buffer, wxUint32 nbytes); wxSocketBase& Write(const void *buffer, wxUint32 nbytes);
wxSocketBase& WriteMsg(const void *buffer, wxUint32 nbytes); wxSocketBase& WriteMsg(const void *buffer, wxUint32 nbytes);
void InterruptAllWaits() { m_interrupt = TRUE; }; void InterruptWait() { m_interrupt = TRUE; };
bool Wait(long seconds = -1, long milliseconds = 0); bool Wait(long seconds = -1, long milliseconds = 0);
bool WaitForRead(long seconds = -1, long milliseconds = 0); bool WaitForRead(long seconds = -1, long milliseconds = 0);
bool WaitForWrite(long seconds = -1, long milliseconds = 0); bool WaitForWrite(long seconds = -1, long milliseconds = 0);
@@ -185,19 +181,21 @@ public:
void SetNotify(wxSocketEventFlags flags); void SetNotify(wxSocketEventFlags flags);
void Notify(bool notify); void Notify(bool notify);
// callbacks - deprecated, avoid if possible // callbacks are deprecated, use events instead
#if WXWIN_COMPATIBILITY
wxSockCbk Callback(wxSockCbk cbk_); wxSockCbk Callback(wxSockCbk cbk_);
char *CallbackData(char *data); char *CallbackData(char *data);
#endif // WXWIN_COMPATIBILITY
// Implementation from now on // Implementation from now on
// -------------------------- // --------------------------
// do not use, this should be private // do not use, should be private
void OnRequest(wxSocketNotify req_evt); 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 bool IsNoWait() const { return ((m_flags & wxSOCKET_NOWAIT) != 0); }
inline wxSocketType GetType() const { return m_type; } inline wxSocketType GetType() const { return m_type; }
private: private:
@@ -240,12 +238,14 @@ private:
int m_id; // socket id int m_id; // socket id
wxEvtHandler *m_handler; // event handler wxEvtHandler *m_handler; // event handler
void *m_clientData; // client data for events void *m_clientData; // client data for events
bool m_notify_state; // notify events to users? bool m_notify; // notify events to users?
wxSocketEventFlags m_neededreq; // event mask wxSocketEventFlags m_eventmask; // which events to notify?
// callbacks - deprecated, avoid if possible // callbacks are deprecated, use events instead
#if WXWIN_COMPATIBILITY
wxSockCbk m_cbk; // callback wxSockCbk m_cbk; // callback
char *m_cdata; // callback data char *m_cdata; // callback data
#endif // WXWIN_COMPATIBILITY
}; };

161
src/common/socket.cpp
View File

@@ -9,6 +9,10 @@
// License: see wxWindows license // License: see wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// ==========================================================================
// Declarations
// ==========================================================================
#ifdef __GNUG__ #ifdef __GNUG__
#pragma implementation "socket.h" #pragma implementation "socket.h"
#endif #endif
@@ -22,10 +26,6 @@
#if wxUSE_SOCKETS #if wxUSE_SOCKETS
// ==========================================================================
// Headers and constants
// ==========================================================================
#include "wx/app.h" #include "wx/app.h"
#include "wx/defs.h" #include "wx/defs.h"
#include "wx/object.h" #include "wx/object.h"
@@ -44,6 +44,9 @@
#include "wx/sckaddr.h" #include "wx/sckaddr.h"
#include "wx/socket.h" #include "wx/socket.h"
// --------------------------------------------------------------------------
// macros and constants
// --------------------------------------------------------------------------
// discard buffer // discard buffer
#define MAX_DISCARD_SIZE (10 * 1024) #define MAX_DISCARD_SIZE (10 * 1024)
@@ -55,12 +58,8 @@
#define PROCESS_EVENTS() #define PROCESS_EVENTS()
#endif #endif
// use wxPostEvent or not
#define USE_DELAYED_EVENTS 1
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// ClassInfos // wxWin macros
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
IMPLEMENT_CLASS(wxSocketBase, wxObject) IMPLEMENT_CLASS(wxSocketBase, wxObject)
@@ -69,20 +68,26 @@ IMPLEMENT_CLASS(wxSocketClient, wxSocketBase)
IMPLEMENT_CLASS(wxDatagramSocket, wxSocketBase) IMPLEMENT_CLASS(wxDatagramSocket, wxSocketBase)
IMPLEMENT_DYNAMIC_CLASS(wxSocketEvent, wxEvent) IMPLEMENT_DYNAMIC_CLASS(wxSocketEvent, wxEvent)
// --------------------------------------------------------------------------
// private classes
// --------------------------------------------------------------------------
class wxSocketState : public wxObject class wxSocketState : public wxObject
{ {
public: public:
bool m_notify_state;
wxSocketEventFlags m_neededreq;
wxSocketFlags m_flags; wxSocketFlags m_flags;
wxSocketEventFlags m_eventmask;
bool m_notify;
void *m_clientData;
#if WXWIN_COMPATIBILITY
wxSocketBase::wxSockCbk m_cbk; wxSocketBase::wxSockCbk m_cbk;
char *m_cdata; char *m_cdata;
#endif // WXWIN_COMPATIBILITY
public: public:
wxSocketState() : wxObject() {} wxSocketState() : wxObject() {}
}; };
// ========================================================================== // ==========================================================================
// wxSocketBase // wxSocketBase
// ========================================================================== // ==========================================================================
@@ -116,10 +121,12 @@ void wxSocketBase::Init()
m_id = -1; m_id = -1;
m_handler = NULL; m_handler = NULL;
m_clientData = NULL; m_clientData = NULL;
m_notify_state = FALSE; m_notify = FALSE;
m_neededreq = 0; m_eventmask = 0;
#if WXWIN_COMPATIBILITY
m_cbk = NULL; m_cbk = NULL;
m_cdata = NULL; m_cdata = NULL;
#endif // WXWIN_COMPATIBILITY
} }
wxSocketBase::wxSocketBase() wxSocketBase::wxSocketBase()
@@ -166,9 +173,12 @@ bool wxSocketBase::Destroy()
// Shutdown and close the socket // Shutdown and close the socket
Close(); Close();
// Supress events from now on
Notify(FALSE);
#if wxUSE_GUI #if wxUSE_GUI
if ( wxPendingDelete.Member(this) ) if ( !wxPendingDelete.Member(this) )
wxPendingDelete.Append(this); wxPendingDelete.Append(this);
#else #else
delete this; delete this;
#endif #endif
@@ -176,9 +186,8 @@ bool wxSocketBase::Destroy()
return TRUE; return TRUE;
} }
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Basic IO operations // Basic IO calls
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// The following IO operations update m_error and m_lcount: // The following IO operations update m_error and m_lcount:
@@ -588,7 +597,8 @@ wxSocketBase& wxSocketBase::Discard()
// timeout elapses. The polling loop calls PROCESS_EVENTS(), so // timeout elapses. The polling loop calls PROCESS_EVENTS(), so
// this won't block the GUI. // this won't block the GUI.
bool wxSocketBase::_Wait(long seconds, long milliseconds, bool wxSocketBase::_Wait(long seconds,
long milliseconds,
wxSocketEventFlags flags) wxSocketEventFlags flags)
{ {
GSocketEventFlags result; GSocketEventFlags result;
@@ -607,14 +617,12 @@ bool wxSocketBase::_Wait(long seconds, long milliseconds,
else else
timeout = m_timeout * 1000; timeout = m_timeout * 1000;
// Active polling (without using events) // Wait in an active polling loop.
// //
// NOTE: this duplicates some of the code in OnRequest (lost // NOTE: We duplicate some of the code in OnRequest, but this doesn't
// connection and connection establishment handling) but // hurt. It has to be here because the (GSocket) event might arrive
// this doesn't hurt. It has to be here because the event // a bit delayed, and it has to be in OnRequest as well because we
// might be a bit delayed, and it has to be in OnRequest // don't know whether the Wait functions are being used.
// as well because maybe the Wait functions are not being
// used.
// //
// Do this at least once (important if timeout == 0, when // Do this at least once (important if timeout == 0, when
// we are just polling). Also, if just polling, do not yield. // we are just polling). Also, if just polling, do not yield.
@@ -737,11 +745,14 @@ void wxSocketBase::SaveState()
state = new wxSocketState(); state = new wxSocketState();
state->m_notify_state = m_notify_state; state->m_flags = m_flags;
state->m_neededreq = m_neededreq; state->m_notify = m_notify;
state->m_flags = m_flags; state->m_eventmask = m_eventmask;
state->m_cbk = m_cbk; state->m_clientData = m_clientData;
state->m_cdata = m_cdata; #if WXWIN_COMPATIBILITY
state->m_cbk = m_cbk;
state->m_cdata = m_cdata;
#endif // WXWIN_COMPATIBILITY
m_states.Append(state); m_states.Append(state);
} }
@@ -757,11 +768,14 @@ void wxSocketBase::RestoreState()
state = (wxSocketState *)node->Data(); state = (wxSocketState *)node->Data();
SetFlags(state->m_flags); m_flags = state->m_flags;
m_cbk = state->m_cbk; m_notify = state->m_notify;
m_cdata = state->m_cdata; m_eventmask = state->m_eventmask;
m_neededreq = state->m_neededreq; m_clientData = state->m_clientData;
Notify(state->m_notify_state); #if WXWIN_COMPATIBILITY
m_cbk = state->m_cbk;
m_cdata = state->m_cdata;
#endif // WXWIN_COMPATIBILITY
delete node; delete node;
delete state; delete state;
@@ -789,6 +803,8 @@ void wxSocketBase::SetFlags(wxSocketFlags flags)
// Callbacks (now obsolete - use events instead) // Callbacks (now obsolete - use events instead)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
#if WXWIN_COMPATIBILITY
wxSocketBase::wxSockCbk wxSocketBase::Callback(wxSockCbk cbk_) wxSocketBase::wxSockCbk wxSocketBase::Callback(wxSockCbk cbk_)
{ {
wxSockCbk old_cbk = cbk_; wxSockCbk old_cbk = cbk_;
@@ -805,31 +821,47 @@ char *wxSocketBase::CallbackData(char *data)
return old_data; return old_data;
} }
#endif // WXWIN_COMPATIBILITY
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Event handling // Event handling
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Callback function from GSocket. All events are internally // A note on how events are processed, which is probably the most
// monitored, but users only get these they are interested in. // difficult thing to get working right while keeping the same API
// and functionality for all platforms.
//
// When GSocket detects an event, it calls wx_socket_callback, which in
// turn just calls wxSocketBase::OnRequest in the corresponding wxSocket
// object. OnRequest does some housekeeping, and if the event is to be
// propagated to the user, it creates a new wxSocketEvent object and
// posts it. The event is not processed immediately, but delayed with
// AddPendingEvent instead. This is necessary in order to decouple the
// event processing from wx_socket_callback; otherwise, subsequent IO
// calls made from the user event handler would fail, as gtk callbacks
// are not reentrant.
//
// Note that, unlike events, user callbacks (now deprecated) are _not_
// decoupled from wx_socket_callback and thus they suffer from a variety
// of problems. Avoid them where possible and use events instead.
static void LINKAGEMODE wx_socket_callback(GSocket * WXUNUSED(socket), static void LINKAGEMODE wx_socket_callback(GSocket * WXUNUSED(socket),
GSocketEvent notify, GSocketEvent notification,
char *cdata) char *cdata)
{ {
wxSocketBase *sckobj = (wxSocketBase *)cdata; wxSocketBase *sckobj = (wxSocketBase *)cdata;
sckobj->OnRequest((wxSocketNotify) notify); sckobj->OnRequest((wxSocketNotify) notification);
} }
void wxSocketBase::OnRequest(wxSocketNotify notification)
void wxSocketBase::OnRequest(wxSocketNotify req_evt)
{ {
// This duplicates some code in _Wait, but this doesn't // NOTE: We duplicate some of the code in _Wait, but this doesn't
// hurt. It has to be here because we don't know whether // hurt. It has to be here because the (GSocket) event might arrive
// the Wait functions will be used, and it has to be in // a bit delayed, and it has to be in _Wait as well because we don't
// _Wait as well because the event might be a bit delayed. // know whether the Wait functions are being used.
switch(req_evt) switch(notification)
{ {
case wxSOCKET_CONNECTION: case wxSOCKET_CONNECTION:
m_establishing = FALSE; m_establishing = FALSE;
@@ -862,7 +894,7 @@ void wxSocketBase::OnRequest(wxSocketNotify req_evt)
// Schedule the event // Schedule the event
wxSocketEventFlags flag = -1; wxSocketEventFlags flag = -1;
switch (req_evt) switch (notification)
{ {
case GSOCK_INPUT: flag = GSOCK_INPUT_FLAG; break; case GSOCK_INPUT: flag = GSOCK_INPUT_FLAG; break;
case GSOCK_OUTPUT: flag = GSOCK_OUTPUT_FLAG; break; case GSOCK_OUTPUT: flag = GSOCK_OUTPUT_FLAG; break;
@@ -870,34 +902,33 @@ void wxSocketBase::OnRequest(wxSocketNotify req_evt)
case GSOCK_LOST: flag = GSOCK_LOST_FLAG; break; case GSOCK_LOST: flag = GSOCK_LOST_FLAG; break;
} }
if (((m_neededreq & flag) == flag) && m_notify_state) if (((m_eventmask & flag) == flag) && m_notify)
{ {
wxSocketEvent event(m_id);
event.m_event = req_evt;
event.m_clientData = m_clientData;
event.SetEventObject(this);
if (m_handler) if (m_handler)
#if USE_DELAYED_EVENTS {
m_handler->AddPendingEvent(event); wxSocketEvent event(m_id);
#else event.m_event = notification;
m_handler->ProcessEvent(event); event.m_clientData = m_clientData;
#endif event.SetEventObject(this);
m_handler->AddPendingEvent(event);
}
#if WXWIN_COMPATIBILITY
if (m_cbk) if (m_cbk)
m_cbk(*this, req_evt, m_cdata); m_cbk(*this, notification, m_cdata);
#endif // WXWIN_COMPATIBILITY
} }
} }
void wxSocketBase::Notify(bool notify) void wxSocketBase::Notify(bool notify)
{ {
m_notify_state = notify; m_notify = notify;
} }
void wxSocketBase::SetNotify(wxSocketEventFlags flags) void wxSocketBase::SetNotify(wxSocketEventFlags flags)
{ {
m_neededreq = flags; m_eventmask = flags;
} }
void wxSocketBase::SetEventHandler(wxEvtHandler& handler, int id) void wxSocketBase::SetEventHandler(wxEvtHandler& handler, int id)
@@ -906,7 +937,6 @@ void wxSocketBase::SetEventHandler(wxEvtHandler& handler, int id)
m_id = id; m_id = id;
} }
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Pushback buffer // Pushback buffer
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -1201,12 +1231,11 @@ void wxSocketEvent::CopyObject(wxObject& object_dest) const
event->m_clientData = m_clientData; event->m_clientData = m_clientData;
} }
// ========================================================================== // ==========================================================================
// wxSocketModule // wxSocketModule
// ========================================================================== // ==========================================================================
class WXDLLEXPORT wxSocketModule: public wxModule class WXDLLEXPORT wxSocketModule : public wxModule
{ {
DECLARE_DYNAMIC_CLASS(wxSocketModule) DECLARE_DYNAMIC_CLASS(wxSocketModule)