// Name: src/common/evtloopcmn.cpp
// Purpose: common wxEventLoop-related stuff
// Author: Vadim Zeitlin
-// Modified by:
// Created: 2006-01-12
// RCS-ID: $Id$
-// Copyright: (c) 2006 Vadim Zeitlin <vadim@wxwindows.org>
+// Copyright: (c) 2006, 2013 Vadim Zeitlin <vadim@wxwindows.org>
+// (c) 2013 Rob Bresalier
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#include "wx/app.h"
#endif //WX_PRECOMP
+#include "wx/scopeguard.h"
+#include "wx/apptrait.h"
+#include "wx/private/eventloopsourcesmanager.h"
+
// ----------------------------------------------------------------------------
// wxEventLoopBase
// ----------------------------------------------------------------------------
wxEventLoopBase::wxEventLoopBase()
{
+ m_isInsideRun = false;
+ m_shouldExit = false;
+
m_isInsideYield = false;
m_eventsToProcessInsideYield = wxEVT_CATEGORY_ALL;
}
-void wxEventLoopBase::DelayPendingEventHandler(wxEvtHandler* toDelay)
+bool wxEventLoopBase::IsMain() const
{
- wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
-
- // move the handler from the list of handlers with processable pending events
- // to the list of handlers with pending events which needs to be processed later
- m_handlersWithPendingEvents.Remove(toDelay);
-
- if (m_handlersWithPendingDelayedEvents.Index(toDelay) == wxNOT_FOUND)
- m_handlersWithPendingDelayedEvents.Add(toDelay);
-
- wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
+ if (wxTheApp)
+ return wxTheApp->GetMainLoop() == this;
+ return false;
}
-void wxEventLoopBase::RemovePendingEventHandler(wxEvtHandler* toRemove)
+/* static */
+void wxEventLoopBase::SetActive(wxEventLoopBase* loop)
{
- wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
-
- if (m_handlersWithPendingEvents.Index(toRemove) != wxNOT_FOUND)
- {
- m_handlersWithPendingEvents.Remove(toRemove);
+ ms_activeLoop = loop;
- // check that the handler was present only once in the list
- wxASSERT_MSG( m_handlersWithPendingEvents.Index(toRemove) == wxNOT_FOUND,
- "Handler occurs twice in the m_handlersWithPendingEvents list!" );
- }
- //else: it wasn't in this list at all, it's ok
-
- if (m_handlersWithPendingDelayedEvents.Index(toRemove) != wxNOT_FOUND)
- {
- m_handlersWithPendingDelayedEvents.Remove(toRemove);
-
- // check that the handler was present only once in the list
- wxASSERT_MSG( m_handlersWithPendingDelayedEvents.Index(toRemove) == wxNOT_FOUND,
- "Handler occurs twice in m_handlersWithPendingDelayedEvents list!" );
- }
- //else: it wasn't in this list at all, it's ok
-
- wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
+ if (wxTheApp)
+ wxTheApp->OnEventLoopEnter(loop);
}
-void wxEventLoopBase::AppendPendingEventHandler(wxEvtHandler* toAppend)
+int wxEventLoopBase::Run()
{
- wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
-
- if ( m_handlersWithPendingEvents.Index(toAppend) == wxNOT_FOUND )
- m_handlersWithPendingEvents.Add(toAppend);
-
- wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
-}
+ // event loops are not recursive, you need to create another loop!
+ wxCHECK_MSG( !IsInsideRun(), -1, wxT("can't reenter a message loop") );
-bool wxEventLoopBase::HasPendingEvents() const
-{
- wxENTER_CRIT_SECT(const_cast<wxEventLoopBase*>(this)->m_handlersWithPendingEventsLocker);
+ // ProcessIdle() and ProcessEvents() below may throw so the code here should
+ // be exception-safe, hence we must use local objects for all actions we
+ // should undo
+ wxEventLoopActivator activate(this);
- bool has = !m_handlersWithPendingEvents.IsEmpty();
+ // We might be called again, after a previous call to ScheduleExit(), so
+ // reset this flag.
+ m_shouldExit = false;
- wxLEAVE_CRIT_SECT(const_cast<wxEventLoopBase*>(this)->m_handlersWithPendingEventsLocker);
+ // Set this variable to true for the duration of this method.
+ m_isInsideRun = true;
+ wxON_BLOCK_EXIT_SET(m_isInsideRun, false);
- return has;
+ // Finally really run the loop.
+ return DoRun();
}
-void wxEventLoopBase::SuspendProcessingOfPendingEvents()
+void wxEventLoopBase::Exit(int rc)
{
- wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
-}
+ wxCHECK_RET( IsRunning(), wxS("Use ScheduleExit() on not running loop") );
-void wxEventLoopBase::ResumeProcessingOfPendingEvents()
-{
- wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
+ ScheduleExit(rc);
}
-void wxEventLoopBase::ProcessPendingEvents()
+void wxEventLoopBase::OnExit()
{
- wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
-
- wxCHECK_RET( m_handlersWithPendingDelayedEvents.IsEmpty(),
- "this helper list should be empty" );
-
- // iterate until the list becomes empty: the handlers remove themselves
- // from it when they don't have any more pending events
- while (!m_handlersWithPendingEvents.IsEmpty())
- {
- // In ProcessPendingEvents(), new handlers might be added
- // and we can safely leave the critical section here.
- wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
-
- // NOTE: we always call ProcessPendingEvents() on the first event handler
- // with pending events because handlers auto-remove themselves
- // from this list (see RemovePendingEventHandler) if they have no
- // more pending events.
- m_handlersWithPendingEvents[0]->ProcessPendingEvents();
-
- wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
- }
-
- // now the wxHandlersWithPendingEvents is surely empty; however some event
- // handlers may have moved themselves into wxHandlersWithPendingDelayedEvents
- // because of a selective wxYield call in progress.
- // Now we need to move them back to wxHandlersWithPendingEvents so the next
- // call to this function has the chance of processing them:
- if (!m_handlersWithPendingDelayedEvents.IsEmpty())
- {
- WX_APPEND_ARRAY(m_handlersWithPendingEvents, m_handlersWithPendingDelayedEvents);
- m_handlersWithPendingDelayedEvents.Clear();
- }
-
- wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
+ if (wxTheApp)
+ wxTheApp->OnEventLoopExit(this);
}
void wxEventLoopBase::WakeUpIdle()
bool wxEventLoopBase::ProcessIdle()
{
- // process pending wx events before sending idle events
- ProcessPendingEvents();
-
- wxIdleEvent event;
-
- event.SetEventObject(wxTheApp);
- wxTheApp->ProcessEvent(event);
- return event.MoreRequested();
+ return wxTheApp && wxTheApp->ProcessIdle();
}
bool wxEventLoopBase::Yield(bool onlyIfNeeded)
return YieldFor(wxEVT_CATEGORY_ALL);
}
+#if wxUSE_EVENTLOOP_SOURCE
+
+wxEventLoopSource*
+wxEventLoopBase::AddSourceForFD(int fd,
+ wxEventLoopSourceHandler *handler,
+ int flags)
+{
+#if wxUSE_CONSOLE_EVENTLOOP
+ // Delegate to the event loop sources manager defined by it.
+ wxEventLoopSourcesManagerBase* const
+ manager = wxApp::GetValidTraits().GetEventLoopSourcesManager();
+ wxCHECK_MSG( manager, NULL, wxS("Must have wxEventLoopSourcesManager") );
+
+ return manager->AddSourceForFD(fd, handler, flags);
+#else // !wxUSE_CONSOLE_EVENTLOOP
+ return NULL;
+#endif // wxUSE_CONSOLE_EVENTLOOP/!wxUSE_CONSOLE_EVENTLOOP
+}
+
+#endif // wxUSE_EVENTLOOP_SOURCE
+
// wxEventLoopManual is unused in the other ports
-#if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXDFB__) || (defined(__UNIX__) && wxUSE_BASE)
+#if defined(__WINDOWS__) || defined(__WXDFB__) || ( ( defined(__UNIX__) && !defined(__WXOSX__) ) && wxUSE_BASE)
// ============================================================================
// wxEventLoopManual implementation
wxEventLoopManual::wxEventLoopManual()
{
m_exitcode = 0;
- m_shouldExit = false;
}
-int wxEventLoopManual::Run()
+bool wxEventLoopManual::ProcessEvents()
{
- // event loops are not recursive, you need to create another loop!
- wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
+ // process pending wx events first as they correspond to low-level events
+ // which happened before, i.e. typically pending events were queued by a
+ // previous call to Dispatch() and if we didn't process them now the next
+ // call to it might enqueue them again (as happens with e.g. socket events
+ // which would be generated as long as there is input available on socket
+ // and this input is only removed from it when pending event handlers are
+ // executed)
+ if ( wxTheApp )
+ {
+ wxTheApp->ProcessPendingEvents();
- // ProcessIdle() and Dispatch() below may throw so the code here should
- // be exception-safe, hence we must use local objects for all actions we
- // should undo
- wxEventLoopActivator activate(this);
+ // One of the pending event handlers could have decided to exit the
+ // loop so check for the flag before trying to dispatch more events
+ // (which could block indefinitely if no more are coming).
+ if ( m_shouldExit )
+ return false;
+ }
+ return Dispatch();
+}
+
+int wxEventLoopManual::DoRun()
+{
// we must ensure that OnExit() is called even if an exception is thrown
- // from inside Dispatch() but we must call it from Exit() in normal
+ // from inside ProcessEvents() but we must call it from Exit() in normal
// situations because it is supposed to be called synchronously,
// wxModalEventLoop depends on this (so we can't just use ON_BLOCK_EXIT or
// something similar here)
// generate and process idle events for as long as we don't
// have anything else to do
- while ( !Pending() && (wxTheApp && wxTheApp->ProcessIdle()) )
+ while ( !m_shouldExit && !Pending() && ProcessIdle() )
;
- // if the "should exit" flag is set, the loop should terminate
- // but not before processing any remaining messages so while
- // Pending() returns true, do process them
if ( m_shouldExit )
- {
- while ( Pending() )
- Dispatch();
-
break;
- }
- // a message came or no more idle processing to do, sit in
- // Dispatch() waiting for the next message
- if ( !Dispatch() )
+ // a message came or no more idle processing to do, dispatch
+ // all the pending events and call Dispatch() to wait for the
+ // next message
+ if ( !ProcessEvents() )
{
// we got WM_QUIT
break;
}
}
+ // Process the remaining queued messages, both at the level of the
+ // underlying toolkit level (Pending/Dispatch()) and wx level
+ // (Has/ProcessPendingEvents()).
+ //
+ // We do run the risk of never exiting this loop if pending event
+ // handlers endlessly generate new events but they shouldn't do
+ // this in a well-behaved program and we shouldn't just discard the
+ // events we already have, they might be important.
+ for ( ;; )
+ {
+ bool hasMoreEvents = false;
+ if ( wxTheApp && wxTheApp->HasPendingEvents() )
+ {
+ wxTheApp->ProcessPendingEvents();
+ hasMoreEvents = true;
+ }
+
+ if ( Pending() )
+ {
+ Dispatch();
+ hasMoreEvents = true;
+ }
+
+ if ( !hasMoreEvents )
+ break;
+ }
+
#if wxUSE_EXCEPTIONS
// exit the outer loop as well
break;
return m_exitcode;
}
-void wxEventLoopManual::Exit(int rc)
+void wxEventLoopManual::ScheduleExit(int rc)
{
- wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") );
+ wxCHECK_RET( IsInsideRun(), wxT("can't call ScheduleExit() if not running") );
m_exitcode = rc;
m_shouldExit = true;
WakeUp();
}
-#endif // __WXMSW__ || __WXMAC__ || __WXDFB__
+#endif // __WINDOWS__ || __WXMAC__ || __WXDFB__
projects / wxWidgets.git / blobdiff