]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/event.cpp
OpenVMS chokes on external templates
[wxWidgets.git] / src / common / event.cpp
index 72468e1a2e79f63980a546fd2d0410ad7038dd67..9e8fbdf5086fb10d8af4ad286e735b532ac11e6c 100644 (file)
 
 #include "wx/thread.h"
 
+#if wxUSE_BASE
+    #include "wx/ptr_scpd.h"
+
+    wxDECLARE_SCOPED_PTR(wxEvent, wxEventPtr)
+    wxDEFINE_SCOPED_PTR(wxEvent, wxEventPtr)
+#endif // wxUSE_BASE
+
 // ----------------------------------------------------------------------------
 // wxWin macros
 // ----------------------------------------------------------------------------
@@ -136,12 +143,13 @@ IMPLEMENT_DYNAMIC_CLASS(wxEventTableEntryModule, wxModule)
 // 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
-    wxCriticalSection *wxPendingEventsLocker = (wxCriticalSection *)NULL;
+    wxCriticalSection *wxPendingEventsLocker = NULL;
 #endif
 
 // common event types are defined here, other event types are defined by the
@@ -175,6 +183,7 @@ DEFINE_EVENT_TYPE(wxEVT_COMMAND_COMBOBOX_SELECTED)
 DEFINE_EVENT_TYPE(wxEVT_COMMAND_TOOL_RCLICKED)
 DEFINE_EVENT_TYPE(wxEVT_COMMAND_TOOL_ENTER)
 DEFINE_EVENT_TYPE(wxEVT_COMMAND_SPINCTRL_UPDATED)
+DEFINE_EVENT_TYPE(wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED)
 DEFINE_EVENT_TYPE(wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED)
 
 // Mouse event types
@@ -405,13 +414,15 @@ wxCommandEvent::wxCommandEvent(wxEventType commandType, int theId)
 
 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;
+    }
     else
     {
 #if wxUSE_TEXTCTRL
         wxTextCtrl *txt = wxDynamicCast(m_eventObject, wxTextCtrl);
-        if(txt)
+        if ( txt )
             return txt->GetValue();
         else
 #endif // wxUSE_TEXTCTRL
@@ -1011,7 +1022,6 @@ void wxEventHashTable::GrowEventTypeTable()
     delete[] oldEventTypeTable;
 }
 
-
 // ----------------------------------------------------------------------------
 // wxEvtHandler
 // ----------------------------------------------------------------------------
@@ -1022,16 +1032,13 @@ void wxEventHashTable::GrowEventTypeTable()
 
 wxEvtHandler::wxEvtHandler()
 {
+    m_beingDeleted = false;
+    
     m_nextHandler = (wxEvtHandler *) NULL;
     m_previousHandler = (wxEvtHandler *) 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;
@@ -1040,6 +1047,8 @@ wxEvtHandler::wxEvtHandler()
 
 wxEvtHandler::~wxEvtHandler()
 {
+    m_beingDeleted = true;
+    
     // Takes itself out of the list of handlers
     if (m_previousHandler)
         m_previousHandler->m_nextHandler = m_nextHandler;
@@ -1056,6 +1065,19 @@ wxEvtHandler::~wxEvtHandler()
         {
             wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)*it;
 
+            // Remove ourselves from sink destructor notifications
+            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;
             delete entry;
@@ -1064,25 +1086,39 @@ wxEvtHandler::~wxEvtHandler()
     };
 
     if (m_pendingEvents)
+    {
+        // At this time, we could still be used from other threads. 
+        // Continue to use sync objects.
+        wxENTER_CRIT_SECT( m_pendingEventsLock );
+        
         m_pendingEvents->DeleteContents(true);
-    delete m_pendingEvents;
-
-#if wxUSE_THREADS
-#  if !defined(__VISAGECPP__)
-    delete m_eventsLocker;
-#  endif
+        delete m_pendingEvents;
+        m_pendingEvents = NULL;
+        
+        wxLEAVE_CRIT_SECT( m_pendingEventsLock );
+    }
 
     // Remove us from wxPendingEvents if necessary.
-    if(wxPendingEventsLocker)
-        wxENTER_CRIT_SECT(*wxPendingEventsLocker);
     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
+
+        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 )
@@ -1102,35 +1138,24 @@ bool wxEvtHandler::ProcessThreadEvent(const wxEvent& event)
     return true;
 }
 
-void wxEvtHandler::ClearEventLocker()
-{
-#if !defined(__VISAGECPP__)
-    delete m_eventsLocker;
-    m_eventsLocker = NULL;
-#endif
-}
-
 #endif // wxUSE_THREADS
 
-void wxEvtHandler::AddPendingEvent(const wxEvent& event)
+void wxEvtHandler::QueueEvent(wxEvent *event)
 {
-    // 1) Add event to list of pending events of this event handler
+    wxCHECK_RET( event, "NULL event can't be posted" );
 
-    wxEvent *eventCopy = event.Clone();
+    // Catch the situation where destructor is already invoked (in another thread)
+    if( m_beingDeleted ) return;
 
-    // we must be able to copy the events here so the event class must
-    // implement Clone() properly instead of just providing a NULL stab for it
-    wxCHECK_RET( eventCopy,
-                 _T("events of this type aren't supposed to be posted") );
-
-    wxENTER_CRIT_SECT( Lock() );
+    // 1) Add this event to our list of pending events
+    wxENTER_CRIT_SECT( m_pendingEventsLock );
 
     if ( !m_pendingEvents )
       m_pendingEvents = new wxList;
 
-    m_pendingEvents->Append(eventCopy);
+    m_pendingEvents->Append(event);
 
-    wxLEAVE_CRIT_SECT( Lock() );
+    wxLEAVE_CRIT_SECT( m_pendingEventsLock );
 
     // 2) Add this event handler to list of event handlers that
     //    have pending events.
@@ -1139,7 +1164,8 @@ void wxEvtHandler::AddPendingEvent(const wxEvent& event)
 
     if ( !wxPendingEvents )
         wxPendingEvents = new wxList;
-    wxPendingEvents->Append(this);
+    if ( !wxPendingEvents->Find(this) )
+        wxPendingEvents->Append(this);
 
     wxLEAVE_CRIT_SECT(*wxPendingEventsLocker);
 
@@ -1150,43 +1176,54 @@ void wxEvtHandler::AddPendingEvent(const wxEvent& event)
 
 void wxEvtHandler::ProcessPendingEvents()
 {
-    // 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.
+    wxENTER_CRIT_SECT( m_pendingEventsLock );
 
-        m_pendingEvents->Erase(node);
+    // This method is only called by wxApp if this handler does have
+    // pending events, but it happens occasionally when using multi-
+    // threading and we don't want a crash due to that.
+    if( !m_pendingEvents  )
+    {
+        wxLEAVE_CRIT_SECT( m_pendingEventsLock );
+        return;
+    }
+    
+    if( m_pendingEvents->IsEmpty() )
+    {
+        wxPendingEvents->DeleteObject(this);
+        wxLEAVE_CRIT_SECT( m_pendingEventsLock );
+        return;
+    }
 
-        wxLEAVE_CRIT_SECT( Lock() );
+    wxList::compatibility_iterator node = m_pendingEvents->GetFirst();
+    wxEventPtr event(wx_static_cast(wxEvent *, node->GetData()));
 
-        ProcessEvent(*event);
+    // 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);
 
-        delete event;
+    // if there are no more pending events left, we don't need to stay in this
+    // list
+    if ( m_pendingEvents->IsEmpty() )
+    {
+#if wxUSE_THREADS
+        if (wxPendingEventsLocker)
+            wxENTER_CRIT_SECT(*wxPendingEventsLocker);
+#endif
+        wxPendingEvents->DeleteObject(this);
+#if wxUSE_THREADS
+        if (wxPendingEventsLocker)
+            wxLEAVE_CRIT_SECT(*wxPendingEventsLocker);
+#endif
+    }
 
-        wxENTER_CRIT_SECT( Lock() );
+    wxLEAVE_CRIT_SECT( m_pendingEventsLock );
 
-        if ( --n == 0 )
-            break;
-    }
+    ProcessEvent(*event);
 
-    wxLEAVE_CRIT_SECT( Lock() );
+    // 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
 }
 
 /*
@@ -1365,6 +1402,16 @@ void wxEvtHandler::Connect( int id, int lastId,
 
     // 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 && eventSink != this )
+    {
+        wxEventConnectionRef *evtConnRef = FindRefInTrackerList(eventSink);
+        if ( evtConnRef )
+            evtConnRef->IncRef( );
+        else
+            evtConnRef = new wxEventConnectionRef(this, eventSink);
+    }
 }
 
 bool wxEvtHandler::Disconnect( int id, int lastId, wxEventType eventType,
@@ -1375,6 +1422,14 @@ bool wxEvtHandler::Disconnect( int id, int lastId, wxEventType eventType,
     if (!m_dynamicEvents)
         return false;
 
+    // Remove connection from tracker node (wxEventConnectionRef)
+    if ( eventSink && eventSink != this )
+    {
+        wxEventConnectionRef *evtConnRef = FindRefInTrackerList(eventSink);
+        if ( evtConnRef )
+            evtConnRef->DecRef();
+    }
+
     wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
     while (node)
     {
@@ -1465,6 +1520,46 @@ void *wxEvtHandler::DoGetClientData() const
     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