Fixed a rare wxAuiFloatingFrame dtor crash on MSW using a registration mechanism...

[wxWidgets.git] / src / common / event.cpp

diff --git a/src/common/event.cpp b/src/common/event.cpp
index 93eaa2e2349f26b71f818a0b8e71de23c127f889..a03b9fe1b92a9df9f9c84898cc5dd647763c8935 100644 (file)
--- a/src/common/event.cpp
+++ b/src/common/event.cpp
@@ -25,6 +25,7 @@
 #endif
 
 #include "wx/event.h"
 #endif
 
 #include "wx/event.h"

+#include "wx/evtloop.h"

 
 #ifndef WX_PRECOMP
     #include "wx/list.h"
 
 #ifndef WX_PRECOMP
     #include "wx/list.h"


@@ -42,6 +43,8 @@
     #endif // wxUSE_GUI
 #endif
 
     #endif // wxUSE_GUI
 #endif
 

+#include "wx/thread.h"
+

 // ----------------------------------------------------------------------------
 // wxWin macros
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxWin macros
 // ----------------------------------------------------------------------------


@@ -133,16 +136,15 @@ IMPLEMENT_DYNAMIC_CLASS(wxEventTableEntryModule, wxModule)
 // global variables
 // ----------------------------------------------------------------------------
 
 // global variables
 // ----------------------------------------------------------------------------
 

-// To put pending event handlers
-wxList *wxPendingEvents = (wxList *)NULL;
+// List containing event handlers with pending events (each handler can occur
+// at most once here)
+wxList *wxPendingEvents = NULL;

 
 #if wxUSE_THREADS
     // protects wxPendingEvents list
 
 #if wxUSE_THREADS
     // protects wxPendingEvents list

-    wxCriticalSection *wxPendingEventsLocker = (wxCriticalSection *)NULL;
+    wxCriticalSection *wxPendingEventsLocker = NULL;

 #endif
 
 #endif
 

-#if !WXWIN_COMPATIBILITY_EVENT_TYPES
-

 // common event types are defined here, other event types are defined by the
 // components which use them
 
 // common event types are defined here, other event types are defined by the
 // components which use them
 


@@ -154,14 +156,10 @@ DEFINE_EVENT_TYPE(wxEVT_IDLE)
 DEFINE_EVENT_TYPE(wxEVT_SOCKET)
 DEFINE_EVENT_TYPE(wxEVT_TIMER)
 
 DEFINE_EVENT_TYPE(wxEVT_SOCKET)
 DEFINE_EVENT_TYPE(wxEVT_TIMER)
 

-#endif // !WXWIN_COMPATIBILITY_EVENT_TYPES
-

 #endif // wxUSE_BASE
 
 #if wxUSE_GUI
 
 #endif // wxUSE_BASE
 
 #if wxUSE_GUI
 

-#if !WXWIN_COMPATIBILITY_EVENT_TYPES
-

 DEFINE_EVENT_TYPE(wxEVT_COMMAND_BUTTON_CLICKED)
 DEFINE_EVENT_TYPE(wxEVT_COMMAND_CHECKBOX_CLICKED)
 DEFINE_EVENT_TYPE(wxEVT_COMMAND_CHOICE_SELECTED)
 DEFINE_EVENT_TYPE(wxEVT_COMMAND_BUTTON_CLICKED)
 DEFINE_EVENT_TYPE(wxEVT_COMMAND_CHECKBOX_CLICKED)
 DEFINE_EVENT_TYPE(wxEVT_COMMAND_CHOICE_SELECTED)


@@ -264,7 +262,6 @@ DEFINE_EVENT_TYPE(wxEVT_END_SESSION)
 DEFINE_EVENT_TYPE(wxEVT_QUERY_END_SESSION)
 DEFINE_EVENT_TYPE(wxEVT_HIBERNATE)
 DEFINE_EVENT_TYPE(wxEVT_ACTIVATE_APP)
 DEFINE_EVENT_TYPE(wxEVT_QUERY_END_SESSION)
 DEFINE_EVENT_TYPE(wxEVT_HIBERNATE)
 DEFINE_EVENT_TYPE(wxEVT_ACTIVATE_APP)

-DEFINE_EVENT_TYPE(wxEVT_POWER)

 DEFINE_EVENT_TYPE(wxEVT_ACTIVATE)
 DEFINE_EVENT_TYPE(wxEVT_CREATE)
 DEFINE_EVENT_TYPE(wxEVT_DESTROY)
 DEFINE_EVENT_TYPE(wxEVT_ACTIVATE)
 DEFINE_EVENT_TYPE(wxEVT_CREATE)
 DEFINE_EVENT_TYPE(wxEVT_DESTROY)


@@ -316,8 +313,6 @@ DEFINE_EVENT_TYPE(wxEVT_COMMAND_ENTER)
 DEFINE_EVENT_TYPE(wxEVT_HELP)
 DEFINE_EVENT_TYPE(wxEVT_DETAILED_HELP)
 
 DEFINE_EVENT_TYPE(wxEVT_HELP)
 DEFINE_EVENT_TYPE(wxEVT_DETAILED_HELP)
 

-#endif // !WXWIN_COMPATIBILITY_EVENT_TYPES
-

 #endif // wxUSE_GUI
 
 #if wxUSE_BASE
 #endif // wxUSE_GUI
 
 #if wxUSE_BASE


@@ -411,13 +406,15 @@ wxCommandEvent::wxCommandEvent(wxEventType commandType, int theId)
 
 wxString wxCommandEvent::GetString() const
 {
 
 wxString wxCommandEvent::GetString() const
 {

-    if(m_eventType != wxEVT_COMMAND_TEXT_UPDATED || !m_eventObject)
+    if (m_eventType != wxEVT_COMMAND_TEXT_UPDATED || !m_eventObject)
+    {

         return m_cmdString;
         return m_cmdString;

+    }

     else
     {
 #if wxUSE_TEXTCTRL
         wxTextCtrl *txt = wxDynamicCast(m_eventObject, wxTextCtrl);
     else
     {
 #if wxUSE_TEXTCTRL
         wxTextCtrl *txt = wxDynamicCast(m_eventObject, wxTextCtrl);

-        if(txt)
+        if ( txt )

             return txt->GetValue();
         else
 #endif // wxUSE_TEXTCTRL
             return txt->GetValue();
         else
 #endif // wxUSE_TEXTCTRL


@@ -519,17 +516,23 @@ wxScrollWinEvent::wxScrollWinEvent(wxEventType commandType,
 wxMouseEvent::wxMouseEvent(wxEventType commandType)
 {
     m_eventType = commandType;
 wxMouseEvent::wxMouseEvent(wxEventType commandType)
 {
     m_eventType = commandType;

-    m_metaDown = false;
-    m_altDown = false;
-    m_controlDown = false;
-    m_shiftDown = false;
+
+    m_x = 0;
+    m_y = 0;
+

     m_leftDown = false;
     m_leftDown = false;

-    m_rightDown = false;

     m_middleDown = false;
     m_middleDown = false;

+    m_rightDown = false;

     m_aux1Down = false;
     m_aux2Down = false;
     m_aux1Down = false;
     m_aux2Down = false;

-    m_x = 0;
-    m_y = 0;
+
+    m_controlDown = false;
+    m_shiftDown = false;
+    m_altDown = false;
+    m_metaDown = false;
+
+    m_clickCount = -1;
+

     m_wheelRotation = 0;
     m_wheelDelta = 0;
     m_linesPerAction = 0;
     m_wheelRotation = 0;
     m_wheelDelta = 0;
     m_linesPerAction = 0;


@@ -770,13 +773,6 @@ wxKeyEvent::wxKeyEvent(const wxKeyEvent& evt)
 #endif
 }
 
 #endif
 }
 

-#if WXWIN_COMPATIBILITY_2_6
-long wxKeyEvent::KeyCode() const
-{
-    return m_keyCode;
-}
-#endif // WXWIN_COMPATIBILITY_2_6
-

 wxWindowCreateEvent::wxWindowCreateEvent(wxWindow *win)
 {
     SetEventType(wxEVT_CREATE);
 wxWindowCreateEvent::wxWindowCreateEvent(wxWindow *win)
 {
     SetEventType(wxEVT_CREATE);


@@ -1018,7 +1014,6 @@ void wxEventHashTable::GrowEventTypeTable()
     delete[] oldEventTypeTable;
 }
 
     delete[] oldEventTypeTable;
 }
 

-

 // ----------------------------------------------------------------------------
 // wxEvtHandler
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxEvtHandler
 // ----------------------------------------------------------------------------


@@ -1034,11 +1029,6 @@ wxEvtHandler::wxEvtHandler()
     m_enabled = true;
     m_dynamicEvents = (wxList *) NULL;
     m_pendingEvents = (wxList *) NULL;
     m_enabled = true;
     m_dynamicEvents = (wxList *) NULL;
     m_pendingEvents = (wxList *) NULL;

-#if wxUSE_THREADS
-#  if !defined(__VISAGECPP__)
-    m_eventsLocker = new wxCriticalSection;
-#  endif
-#endif

 
     // no client data (yet)
     m_clientData = NULL;
 
     // no client data (yet)
     m_clientData = NULL;


@@ -1061,11 +1051,21 @@ wxEvtHandler::~wxEvtHandler()
               it != end;
               ++it )
         {
               it != end;
               ++it )
         {

-#if WXWIN_COMPATIBILITY_EVENT_TYPES
-            wxEventTableEntry *entry = (wxEventTableEntry*)*it;
-#else // !WXWIN_COMPATIBILITY_EVENT_TYPES

             wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)*it;
             wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)*it;

-#endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
+
+            // Remove ourselves from sink destructor notifications
+            // (this has usually been been done, in wxTrackable destructor)
+            wxEvtHandler *eventSink = entry->m_eventSink;
+            if ( eventSink )
+            {
+                wxEventConnectionRef * const
+                    evtConnRef = FindRefInTrackerList(eventSink);
+                if ( evtConnRef )
+                {
+                    eventSink->RemoveNode(evtConnRef);
+                    delete evtConnRef;
+                }
+            }

 
             if (entry->m_callbackUserData)
                 delete entry->m_callbackUserData;
 
             if (entry->m_callbackUserData)
                 delete entry->m_callbackUserData;


@@ -1078,23 +1078,28 @@ wxEvtHandler::~wxEvtHandler()
         m_pendingEvents->DeleteContents(true);
     delete m_pendingEvents;
 
         m_pendingEvents->DeleteContents(true);
     delete m_pendingEvents;
 

-#if wxUSE_THREADS
-#  if !defined(__VISAGECPP__)
-    delete m_eventsLocker;
-#  endif
-

     // Remove us from wxPendingEvents if necessary.
     // Remove us from wxPendingEvents if necessary.

-    if(wxPendingEventsLocker)
-        wxENTER_CRIT_SECT(*wxPendingEventsLocker);

     if ( wxPendingEvents )
     {
     if ( wxPendingEvents )
     {

-        // Delete all occurences of this from the list of pending events
-        while (wxPendingEvents->DeleteObject(this)) { } // Do nothing
-    }
-    if(wxPendingEventsLocker)
-        wxLEAVE_CRIT_SECT(*wxPendingEventsLocker);
+#if wxUSE_THREADS
+        if (wxPendingEventsLocker)
+            wxENTER_CRIT_SECT(*wxPendingEventsLocker);

 #endif
 
 #endif
 

+        if ( wxPendingEvents->DeleteObject(this) )
+        {
+            // check that we were present only once in the list
+            wxASSERT_MSG( !wxPendingEvents->Find(this),
+                          "Handler occurs twice in wxPendingEvents list" );
+        }
+        //else: we weren't in this list at all, it's ok
+
+#if wxUSE_THREADS
+        if (wxPendingEventsLocker)
+            wxLEAVE_CRIT_SECT(*wxPendingEventsLocker);
+#endif
+    }
+

     // we only delete object data, not untyped
     if ( m_clientDataType == wxClientData_Object )
         delete m_clientObject;
     // we only delete object data, not untyped
     if ( m_clientDataType == wxClientData_Object )
         delete m_clientObject;


@@ -1113,14 +1118,6 @@ bool wxEvtHandler::ProcessThreadEvent(const wxEvent& event)
     return true;
 }
 
     return true;
 }
 

-void wxEvtHandler::ClearEventLocker()
-{
-#if !defined(__VISAGECPP__)
-    delete m_eventsLocker;
-    m_eventsLocker = NULL;
-#endif
-}
-

 #endif // wxUSE_THREADS
 
 void wxEvtHandler::AddPendingEvent(const wxEvent& event)
 #endif // wxUSE_THREADS
 
 void wxEvtHandler::AddPendingEvent(const wxEvent& event)


@@ -1134,14 +1131,14 @@ void wxEvtHandler::AddPendingEvent(const wxEvent& event)
     wxCHECK_RET( eventCopy,
                  _T("events of this type aren't supposed to be posted") );
 
     wxCHECK_RET( eventCopy,
                  _T("events of this type aren't supposed to be posted") );
 

-    wxENTER_CRIT_SECT( Lock() );
+    wxENTER_CRIT_SECT( m_pendingEventsLock );

 
     if ( !m_pendingEvents )
       m_pendingEvents = new wxList;
 
     m_pendingEvents->Append(eventCopy);
 
 
     if ( !m_pendingEvents )
       m_pendingEvents = new wxList;
 
     m_pendingEvents->Append(eventCopy);
 

-    wxLEAVE_CRIT_SECT( Lock() );
+    wxLEAVE_CRIT_SECT( m_pendingEventsLock );

 
     // 2) Add this event handler to list of event handlers that
     //    have pending events.
 
     // 2) Add this event handler to list of event handlers that
     //    have pending events.


@@ -1150,7 +1147,8 @@ void wxEvtHandler::AddPendingEvent(const wxEvent& event)
 
     if ( !wxPendingEvents )
         wxPendingEvents = new wxList;
 
     if ( !wxPendingEvents )
         wxPendingEvents = new wxList;

-    wxPendingEvents->Append(this);
+    if ( !wxPendingEvents->Find(this) )
+        wxPendingEvents->Append(this);

 
     wxLEAVE_CRIT_SECT(*wxPendingEventsLocker);
 
 
     wxLEAVE_CRIT_SECT(*wxPendingEventsLocker);
 


@@ -1161,43 +1159,35 @@ void wxEvtHandler::AddPendingEvent(const wxEvent& event)
 
 void wxEvtHandler::ProcessPendingEvents()
 {
 
 void wxEvtHandler::ProcessPendingEvents()
 {

+    wxENTER_CRIT_SECT( m_pendingEventsLock );
+

     // this method is only called by wxApp if this handler does have
     // pending events
     // this method is only called by wxApp if this handler does have
     // pending events

-    wxCHECK_RET( m_pendingEvents,
-                 wxT("Please call wxApp::ProcessPendingEvents() instead") );
-
-    wxENTER_CRIT_SECT( Lock() );
-
-    // we leave the loop once we have processed all events that were present at
-    // the start of ProcessPendingEvents because otherwise we could get into
-    // infinite loop if the pending event handler execution resulted in another
-    // event being posted
-    size_t n = m_pendingEvents->size();
-    for ( wxList::compatibility_iterator node = m_pendingEvents->GetFirst();
-          node;
-          node = m_pendingEvents->GetFirst() )
-    {
-        wxEvent *event = (wxEvent *)node->GetData();
-
-        // It's importan we remove event from list before processing it.
-        // Else a nested event loop, for example from a modal dialog, might
-        // process the same event again.
+    wxCHECK_RET( m_pendingEvents && !m_pendingEvents->IsEmpty(),
+                 "should have pending events if called" );

 
 

-        m_pendingEvents->Erase(node);
+    wxList::compatibility_iterator node = m_pendingEvents->GetFirst();
+    wxEvent * const event = wx_static_cast(wxEvent *, node->GetData());

 
 

-        wxLEAVE_CRIT_SECT( Lock() );
+    // it's important we remove event from list before processing it, else a
+    // nested event loop, for example from a modal dialog, might process the
+    // same event again.
+    m_pendingEvents->Erase(node);

 
 

-        ProcessEvent(*event);
+    // if there are no more pending events left, we don't need to stay in this
+    // list
+    if ( m_pendingEvents->IsEmpty() )
+        wxPendingEvents->DeleteObject(this);

 
 

-        delete event;
+    wxLEAVE_CRIT_SECT( m_pendingEventsLock );

 
 

-        wxENTER_CRIT_SECT( Lock() );
+    ProcessEvent(*event);

 
 

-        if ( --n == 0 )
-            break;
-    }
+    // careful: this object could have been deleted by the event handler
+    // executed by the above ProcessEvent() call, so we can't access any fields
+    // of this object any more

 
 

-    wxLEAVE_CRIT_SECT( Lock() );
+    delete event;

 }
 
 /*
 }
 
 /*


@@ -1309,6 +1299,42 @@ bool wxEvtHandler::ProcessEvent(wxEvent& event)
     return TryParent(event);
 }
 
     return TryParent(event);
 }
 

+bool wxEvtHandler::SafelyProcessEvent(wxEvent& event)
+{
+#if wxUSE_EXCEPTIONS
+    try
+    {
+#endif
+        return ProcessEvent(event);
+#if wxUSE_EXCEPTIONS
+    }
+    catch ( ... )
+    {
+        wxEventLoopBase *loop = wxEventLoopBase::GetActive();
+        try
+        {
+            if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() )
+            {
+                if ( loop )
+                    loop->Exit();
+            }
+            //else: continue running current event loop
+
+            return false;
+        }
+        catch ( ... )
+        {
+            // OnExceptionInMainLoop() threw, possibly rethrowing the same
+            // exception again: very good, but we still need Exit() to
+            // be called
+            if ( loop )
+                loop->Exit();
+            throw;
+        }
+    }
+#endif // wxUSE_EXCEPTIONS
+}
+

 
 bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
 {
 
 bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
 {


@@ -1332,23 +1358,24 @@ void wxEvtHandler::Connect( int id, int lastId,
                             wxObject *userData,
                             wxEvtHandler* eventSink )
 {
                             wxObject *userData,
                             wxEvtHandler* eventSink )
 {

-#if WXWIN_COMPATIBILITY_EVENT_TYPES
-    wxEventTableEntry *entry = new wxEventTableEntry;
-    entry->m_eventType = eventType;
-    entry->m_id = id;
-    entry->m_lastId = lastId;
-    entry->m_fn = func;
-    entry->m_callbackUserData = userData;
-#else // !WXWIN_COMPATIBILITY_EVENT_TYPES

     wxDynamicEventTableEntry *entry =
         new wxDynamicEventTableEntry(eventType, id, lastId, func, userData, eventSink);
     wxDynamicEventTableEntry *entry =
         new wxDynamicEventTableEntry(eventType, id, lastId, func, userData, eventSink);

-#endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES

 
     if (!m_dynamicEvents)
         m_dynamicEvents = new wxList;
 
     // Insert at the front of the list so most recent additions are found first
     m_dynamicEvents->Insert( (wxObject*) entry );
 
     if (!m_dynamicEvents)
         m_dynamicEvents = new wxList;
 
     // Insert at the front of the list so most recent additions are found first
     m_dynamicEvents->Insert( (wxObject*) entry );

+
+    // Make sure we get to know when a sink is destroyed
+    if ( eventSink )
+    {
+        wxEventConnectionRef *evtConnRef = FindRefInTrackerList(eventSink);
+        if ( evtConnRef )
+            evtConnRef->IncRef( );
+        else
+            evtConnRef = new wxEventConnectionRef(this, eventSink);
+    }

 }
 
 bool wxEvtHandler::Disconnect( int id, int lastId, wxEventType eventType,
 }
 
 bool wxEvtHandler::Disconnect( int id, int lastId, wxEventType eventType,


@@ -1359,14 +1386,18 @@ bool wxEvtHandler::Disconnect( int id, int lastId, wxEventType eventType,
     if (!m_dynamicEvents)
         return false;
 
     if (!m_dynamicEvents)
         return false;
 

+    // Remove connection from tracker node (wxEventConnectionRef)
+    if ( eventSink )
+    {
+        wxEventConnectionRef *evtConnRef = FindRefInTrackerList(eventSink);
+        if ( evtConnRef )
+            evtConnRef->DecRef();
+    }
+

     wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
     while (node)
     {
     wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
     while (node)
     {

-#if WXWIN_COMPATIBILITY_EVENT_TYPES
-            wxEventTableEntry *entry = (wxEventTableEntry*)node->GetData();
-#else // !WXWIN_COMPATIBILITY_EVENT_TYPES
-            wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
-#endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
+        wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();

 
         if ((entry->m_id == id) &&
             ((entry->m_lastId == lastId) || (lastId == wxID_ANY)) &&
 
         if ((entry->m_id == id) &&
             ((entry->m_lastId == lastId) || (lastId == wxID_ANY)) &&


@@ -1394,11 +1425,7 @@ bool wxEvtHandler::SearchDynamicEventTable( wxEvent& event )
     wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
     while (node)
     {
     wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
     while (node)
     {

-#if WXWIN_COMPATIBILITY_EVENT_TYPES
-        wxEventTableEntry *entry = (wxEventTableEntry*)node->GetData();
-#else // !WXWIN_COMPATIBILITY_EVENT_TYPES

         wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
         wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();

-#endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES

 
         // get next node before (maybe) calling the event handler as it could
         // call Disconnect() invalidating the current node
 
         // get next node before (maybe) calling the event handler as it could
         // call Disconnect() invalidating the current node


@@ -1406,17 +1433,10 @@ bool wxEvtHandler::SearchDynamicEventTable( wxEvent& event )
 
         if ((event.GetEventType() == entry->m_eventType) && (entry->m_fn != 0))
         {
 
         if ((event.GetEventType() == entry->m_eventType) && (entry->m_fn != 0))
         {

-            wxEvtHandler *handler =
-#if !WXWIN_COMPATIBILITY_EVENT_TYPES
-                                    entry->m_eventSink ? entry->m_eventSink
-                                                       :
-#endif
-                                                         this;
-
+            wxEvtHandler *handler = entry->m_eventSink ? entry->m_eventSink
+                                                       : this;

             if ( ProcessEventIfMatches(*entry, handler, event) )
             if ( ProcessEventIfMatches(*entry, handler, event) )

-            {

                 return true;
                 return true;

-            }

         }
     }
 
         }
     }
 


@@ -1464,6 +1484,46 @@ void *wxEvtHandler::DoGetClientData() const
     return m_clientData;
 }
 
     return m_clientData;
 }
 

+// A helper to find an wxEventConnectionRef object
+wxEventConnectionRef *
+wxEvtHandler::FindRefInTrackerList(wxEvtHandler *eventSink)
+{
+    for ( wxTrackerNode *node = eventSink->GetFirst(); node; node = node->m_nxt )
+    {
+        // we only want wxEventConnectionRef nodes here
+        wxEventConnectionRef *evtConnRef = node->ToEventConnection();
+        if ( evtConnRef && evtConnRef->m_src == this )
+        {
+            wxASSERT( evtConnRef->m_sink==eventSink );
+            return evtConnRef;
+        }
+    }
+
+    return NULL;
+}
+
+void wxEvtHandler::OnSinkDestroyed( wxEvtHandler *sink )
+{
+    wxASSERT(m_dynamicEvents);
+
+    // remove all connections with this sink
+    wxList::compatibility_iterator node = m_dynamicEvents->GetFirst(), node_nxt;
+    while (node)
+    {
+        wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
+        node_nxt = node->GetNext();
+
+        if ( entry->m_eventSink==sink )
+        {
+            if (entry->m_callbackUserData)
+                delete entry->m_callbackUserData;
+            m_dynamicEvents->Erase( node );
+            delete entry;
+        }
+        node = node_nxt;
+    }
+}
+

 #endif // wxUSE_BASE
 
 #if wxUSE_GUI
 #endif // wxUSE_BASE
 
 #if wxUSE_GUI