X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/f24391587ce5794fac9043196bb04c0b4e293403..38aae140acbfd562df1388ae76108efcc52f871c:/src/common/evtloopcmn.cpp diff --git a/src/common/evtloopcmn.cpp b/src/common/evtloopcmn.cpp index 36ce381b8d..bcc3472e8f 100644 --- a/src/common/evtloopcmn.cpp +++ b/src/common/evtloopcmn.cpp @@ -2,21 +2,13 @@ // 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 +// Copyright: (c) 2006, 2013 Vadim Zeitlin +// (c) 2013 Rob Bresalier // Licence: wxWindows licence /////////////////////////////////////////////////////////////////////////////// -// ============================================================================ -// declarations -// ============================================================================ - -// ---------------------------------------------------------------------------- -// headers -// ---------------------------------------------------------------------------- - // for compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -25,16 +17,125 @@ #endif #include "wx/evtloop.h" -#include "wx/app.h" + +#ifndef WX_PRECOMP + #include "wx/app.h" +#endif //WX_PRECOMP + +#include "wx/scopeguard.h" +#include "wx/apptrait.h" +#include "wx/private/eventloopsourcesmanager.h" // ---------------------------------------------------------------------------- -// globals +// wxEventLoopBase // ---------------------------------------------------------------------------- -wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL; +wxEventLoopBase *wxEventLoopBase::ms_activeLoop = NULL; + +wxEventLoopBase::wxEventLoopBase() +{ + m_isInsideRun = false; + m_shouldExit = false; + + m_isInsideYield = false; + m_eventsToProcessInsideYield = wxEVT_CATEGORY_ALL; +} + +bool wxEventLoopBase::IsMain() const +{ + if (wxTheApp) + return wxTheApp->GetMainLoop() == this; + return false; +} + +/* static */ +void wxEventLoopBase::SetActive(wxEventLoopBase* loop) +{ + ms_activeLoop = loop; + + if (wxTheApp) + wxTheApp->OnEventLoopEnter(loop); +} + +int wxEventLoopBase::Run() +{ + // event loops are not recursive, you need to create another loop! + wxCHECK_MSG( !IsInsideRun(), -1, wxT("can't reenter a message loop") ); + + // 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); + + // We might be called again, after a previous call to ScheduleExit(), so + // reset this flag. + m_shouldExit = false; + + // Set this variable to true for the duration of this method. + m_isInsideRun = true; + wxON_BLOCK_EXIT_SET(m_isInsideRun, false); + + // Finally really run the loop. + return DoRun(); +} + +void wxEventLoopBase::Exit(int rc) +{ + wxCHECK_RET( IsRunning(), wxS("Use ScheduleExit() on not running loop") ); + + ScheduleExit(rc); +} + +void wxEventLoopBase::OnExit() +{ + if (wxTheApp) + wxTheApp->OnEventLoopExit(this); +} + +void wxEventLoopBase::WakeUpIdle() +{ + WakeUp(); +} + +bool wxEventLoopBase::ProcessIdle() +{ + return wxTheApp && wxTheApp->ProcessIdle(); +} + +bool wxEventLoopBase::Yield(bool onlyIfNeeded) +{ + if ( m_isInsideYield ) + { + if ( !onlyIfNeeded ) + { + wxFAIL_MSG( wxT("wxYield called recursively" ) ); + } + + return false; + } + + return YieldFor(wxEVT_CATEGORY_ALL); +} + +#if wxUSE_EVENTLOOP_SOURCE + +wxEventLoopSource* +wxEventLoopBase::AddSourceForFD(int fd, + wxEventLoopSourceHandler *handler, + int flags) +{ + // 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); +} + +#endif // wxUSE_EVENTLOOP_SOURCE // wxEventLoopManual is unused in the other ports -#if defined(__WXMSW__) || defined(__WXMAC__) +#if defined(__WINDOWS__) || defined(__WXDFB__) || ( ( defined(__UNIX__) && !defined(__WXOSX__) ) && wxUSE_BASE) // ============================================================================ // wxEventLoopManual implementation @@ -43,21 +144,35 @@ wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL; 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(wx_static_cast(wxEventLoop *, 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) @@ -76,29 +191,49 @@ int wxEventLoopManual::Run() // 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; @@ -129,9 +264,9 @@ int wxEventLoopManual::Run() 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; @@ -149,4 +284,5 @@ void wxEventLoopManual::Exit(int rc) WakeUp(); } -#endif // __WXMSW__ || __WXMAC__ +#endif // __WINDOWS__ || __WXMAC__ || __WXDFB__ +