unused variable

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

diff --git a/src/common/event.cpp b/src/common/event.cpp
index ce2a0815261caa50d60075b8bca6ef45b74338a3..7d98a3e6d0f8bff41f0da0ab31eef7929dd8de39 100644 (file)
--- a/src/common/event.cpp
+++ b/src/common/event.cpp
@@ -29,6 +29,7 @@
 
 #ifndef WX_PRECOMP
     #include "wx/list.h"
 
 #ifndef WX_PRECOMP
     #include "wx/list.h"

+    #include "wx/log.h"

     #include "wx/app.h"
     #include "wx/utils.h"
     #include "wx/stopwatch.h"
     #include "wx/app.h"
     #include "wx/utils.h"
     #include "wx/stopwatch.h"


@@ -145,16 +146,6 @@ IMPLEMENT_DYNAMIC_CLASS(wxEventTableEntryModule, wxModule)
 // global variables
 // ----------------------------------------------------------------------------
 
 // global variables
 // ----------------------------------------------------------------------------
 

-// List containing event handlers with pending events (each handler can occur
-// at most once here)
-wxList *wxHandlersWithPendingEvents = NULL;
-wxList *wxHandlersWithPendingDelayedEvents = NULL;
-
-#if wxUSE_THREADS
-    // protects wxHandlersWithPendingEvents list
-    wxCriticalSection *wxHandlersWithPendingEventsLocker = NULL;
-#endif
-

 // 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
 


@@ -770,7 +761,6 @@ wxKeyEvent::wxKeyEvent(wxEventType type)
 {
     m_eventType = type;
     m_keyCode = 0;
 {
     m_eventType = type;
     m_keyCode = 0;

-    m_scanCode = 0;

 #if wxUSE_UNICODE
     m_uniChar = 0;
 #endif
 #if wxUSE_UNICODE
     m_uniChar = 0;
 #endif


@@ -784,8 +774,6 @@ wxKeyEvent::wxKeyEvent(const wxKeyEvent& evt)
     m_y = evt.m_y;
 
     m_keyCode = evt.m_keyCode;
     m_y = evt.m_y;
 
     m_keyCode = evt.m_keyCode;

-
-    m_scanCode = evt.m_scanCode;

     m_rawCode = evt.m_rawCode;
     m_rawFlags = evt.m_rawFlags;
 
     m_rawCode = evt.m_rawCode;
     m_rawFlags = evt.m_rawFlags;
 


@@ -1037,10 +1025,6 @@ void wxEventHashTable::GrowEventTypeTable()
 // wxEvtHandler
 // ----------------------------------------------------------------------------
 
 // wxEvtHandler
 // ----------------------------------------------------------------------------
 

-/*
- * Event handler
- */
-

 wxEvtHandler::wxEvtHandler()
 {
     m_nextHandler = NULL;
 wxEvtHandler::wxEvtHandler()
 {
     m_nextHandler = NULL;


@@ -1085,41 +1069,16 @@ wxEvtHandler::~wxEvtHandler()
             delete entry;
         }
         delete m_dynamicEvents;
             delete entry;
         }
         delete m_dynamicEvents;

-    };
+    }

 
     if (m_pendingEvents)
         m_pendingEvents->DeleteContents(true);
     delete m_pendingEvents;
 
 
     if (m_pendingEvents)
         m_pendingEvents->DeleteContents(true);
     delete m_pendingEvents;
 

-    // Remove us from wxHandlersWithPendingEvents if necessary.
-    if ( wxHandlersWithPendingEvents )
-    {
-#if wxUSE_THREADS
-        if (wxHandlersWithPendingEventsLocker)
-            wxENTER_CRIT_SECT(*wxHandlersWithPendingEventsLocker);
-#endif
-
-        if ( wxHandlersWithPendingEvents->DeleteObject(this) )
-        {
-            // check that we were present only once in the list
-            wxASSERT_MSG( !wxHandlersWithPendingEvents->Find(this),
-                          "Handler occurs twice in wxHandlersWithPendingEvents list" );
-        }
-        //else: we weren't in this list at all, it's ok
-
-        if ( wxHandlersWithPendingDelayedEvents->DeleteObject(this) )
-        {
-            // check that we were present only once in the list
-            wxASSERT_MSG( !wxHandlersWithPendingDelayedEvents->Find(this),
-                          "Handler occurs twice in wxHandlersWithPendingDelayedEvents list" );
-        }
-        //else: we weren't in this list at all, it's ok
-
-#if wxUSE_THREADS
-        if (wxHandlersWithPendingEventsLocker)
-            wxLEAVE_CRIT_SECT(*wxHandlersWithPendingEventsLocker);
-#endif
-    }
+    // Remove us from the list of the pending events if necessary.
+    wxEventLoopBase *loop = wxEventLoopBase::GetActive();
+    if (loop)
+        loop->RemovePendingEventHandler(this);

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


@@ -1165,6 +1124,15 @@ void wxEvtHandler::QueueEvent(wxEvent *event)
 {
     wxCHECK_RET( event, "NULL event can't be posted" );
 
 {
     wxCHECK_RET( event, "NULL event can't be posted" );
 

+    wxEventLoopBase* loop = wxEventLoopBase::GetActive();
+    if (!loop)
+    {
+        // we need an event loop which manages the list of event handlers with
+        // pending events... cannot proceed without it!
+        wxLogDebug("No event loop is running!");
+        return;
+    }
+

     // 1) Add this event to our list of pending events
     wxENTER_CRIT_SECT( m_pendingEventsLock );
 
     // 1) Add this event to our list of pending events
     wxENTER_CRIT_SECT( m_pendingEventsLock );
 


@@ -1176,14 +1144,7 @@ void wxEvtHandler::QueueEvent(wxEvent *event)
     // 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.
 

-    wxENTER_CRIT_SECT(*wxHandlersWithPendingEventsLocker);
-
-    if ( !wxHandlersWithPendingEvents )
-        wxHandlersWithPendingEvents = new wxList;
-    if ( !wxHandlersWithPendingEvents->Find(this) )
-        wxHandlersWithPendingEvents->Append(this);
-
-    wxLEAVE_CRIT_SECT(*wxHandlersWithPendingEventsLocker);
+    loop->AppendPendingEventHandler(this);

 
     // only release m_pendingEventsLock now because otherwise there is a race
     // condition as described in the ticket #9093: we could process the event
 
     // only release m_pendingEventsLock now because otherwise there is a race
     // condition as described in the ticket #9093: we could process the event


@@ -1200,6 +1161,15 @@ void wxEvtHandler::QueueEvent(wxEvent *event)
 
 void wxEvtHandler::ProcessPendingEvents()
 {
 
 void wxEvtHandler::ProcessPendingEvents()
 {

+    wxEventLoopBase* loop = wxEventLoopBase::GetActive();
+    if (!loop)
+    {
+        // we need an event loop which manages the list of event handlers with
+        // pending events... cannot proceed without it!
+        wxLogDebug("No event loop is running!");
+        return;
+    }
+

     // we need to process only a single pending event in this call because
     // each call to ProcessEvent() could result in the destruction of this
     // same event handler (see the comment at the end of this function)
     // we need to process only a single pending event in this call because
     // each call to ProcessEvent() could result in the destruction of this
     // same event handler (see the comment at the end of this function)


@@ -1215,9 +1185,10 @@ void wxEvtHandler::ProcessPendingEvents()
     wxEvent* pEvent = static_cast<wxEvent *>(node->GetData());
 
     // find the first event which can be processed now:
     wxEvent* pEvent = static_cast<wxEvent *>(node->GetData());
 
     // find the first event which can be processed now:

-    if (wxTheApp && wxTheApp->IsYielding())
+    wxEventLoopBase* evtLoop = wxEventLoopBase::GetActive();
+    if (evtLoop && evtLoop->IsYielding())

     {
     {

-        while (node && pEvent && !wxTheApp->IsEventAllowedInsideYield(pEvent->GetEventCategory()))
+        while (node && pEvent && !evtLoop->IsEventAllowedInsideYield(pEvent->GetEventCategory()))

         {
             node = node->GetNext();
             pEvent = node ? static_cast<wxEvent *>(node->GetData()) : NULL;
         {
             node = node->GetNext();
             pEvent = node ? static_cast<wxEvent *>(node->GetData()) : NULL;


@@ -1226,19 +1197,11 @@ void wxEvtHandler::ProcessPendingEvents()
         if (!node)
         {
             // all our events are NOT processable now... signal this:
         if (!node)
         {
             // all our events are NOT processable now... signal this:

-#if wxUSE_THREADS
-            if (wxHandlersWithPendingEventsLocker)
-                wxENTER_CRIT_SECT(*wxHandlersWithPendingEventsLocker);
-#endif
-            // move us from the list of handlers with processable pending events
-            // to the list of handlers with pending events which needs to be processed later
-            wxHandlersWithPendingEvents->DeleteObject(this);
-            if ( !wxHandlersWithPendingDelayedEvents->Find(this) )
-                wxHandlersWithPendingDelayedEvents->Append(this);
-#if wxUSE_THREADS
-            if (wxHandlersWithPendingEventsLocker)
-                wxLEAVE_CRIT_SECT(*wxHandlersWithPendingEventsLocker);
-#endif
+            loop->DelayPendingEventHandler(this);
+
+            // see the comment at the beginning of evtloop.h header for the
+            // logic behind YieldFor() and behind DelayPendingEventHandler()
+

             wxLEAVE_CRIT_SECT( m_pendingEventsLock );
 
             return;
             wxLEAVE_CRIT_SECT( m_pendingEventsLock );
 
             return;


@@ -1252,19 +1215,11 @@ void wxEvtHandler::ProcessPendingEvents()
     // same event again.
     m_pendingEvents->Erase(node);
 
     // same event again.
     m_pendingEvents->Erase(node);
 

-    // if there are no more pending events left, we don't need to stay in this
-    // list

     if ( m_pendingEvents->IsEmpty() )
     {
     if ( m_pendingEvents->IsEmpty() )
     {

-#if wxUSE_THREADS
-        if (wxHandlersWithPendingEventsLocker)
-            wxENTER_CRIT_SECT(*wxHandlersWithPendingEventsLocker);
-#endif
-        wxHandlersWithPendingEvents->DeleteObject(this);
-#if wxUSE_THREADS
-        if (wxHandlersWithPendingEventsLocker)
-            wxLEAVE_CRIT_SECT(*wxHandlersWithPendingEventsLocker);
-#endif
+        // if there are no more pending events left, we don't need to
+        // stay in this list
+        loop->RemovePendingEventHandler(this);

     }
 
     wxLEAVE_CRIT_SECT( m_pendingEventsLock );
     }
 
     wxLEAVE_CRIT_SECT( m_pendingEventsLock );


@@ -1355,27 +1310,6 @@ bool wxEvtHandler::ProcessEvent(wxEvent& event)
     {
         if ( wxTheApp )
         {
     {
         if ( wxTheApp )
         {

-/*
-    CANNOT ENABLE: ProcessEvent() must always immediately process the event!
-
-            if (wxTheApp->IsYielding() &&
-                !wxTheApp->IsEventAllowedInsideYield(event.GetEventCategory()))
-            {
-                wxEvent* queuedEv = event.Clone();
-
-                // queue this event rather than processing it now
-                QueueEvent(queuedEv);
-                    // the wxWakeUpIdle call shouldn't probably be done
-                    // in this context (there's wxYield in the call stack)
-
-                return true;
-                    // it's not completely true that the event was processed;
-                    // but we cannot even say it was skipped or discarded...
-            }
-            //else: either we're not inside a wxYield() call or if we are,
-            //      we can process this event immediately.
-*/
-

             int rc = wxTheApp->FilterEvent(event);
             if ( rc != -1 )
             {
             int rc = wxTheApp->FilterEvent(event);
             if ( rc != -1 )
             {