// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
-// ============================================================================
-// declarations
-// ============================================================================
-
-// ----------------------------------------------------------------------------
-// headers
-// ----------------------------------------------------------------------------
-
// for compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#endif //WX_PRECOMP
// ----------------------------------------------------------------------------
-// globals
+// wxEventLoopBase
// ----------------------------------------------------------------------------
wxEventLoopBase *wxEventLoopBase::ms_activeLoop = NULL;
+wxEventLoopBase::wxEventLoopBase()
+{
+ 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);
+}
+
+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);
+}
+
// 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
m_shouldExit = false;
}
+bool wxEventLoopManual::ProcessEvents()
+{
+ // 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();
+
+ // 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::Run()
{
// event loops are not recursive, you need to create another loop!
- wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
+ wxCHECK_MSG( !IsRunning(), -1, wxT("can't reenter a message loop") );
- // ProcessIdle() and Dispatch() below may throw so the code here should
+ // 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 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;
void wxEventLoopManual::Exit(int rc)
{
- wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") );
+ wxCHECK_RET( IsRunning(), wxT("can't call Exit() if not running") );
m_exitcode = rc;
m_shouldExit = true;
WakeUp();
}
-#endif // __WXMSW__ || __WXMAC__ || __WXDFB__
+#endif // __WINDOWS__ || __WXMAC__ || __WXDFB__
projects / wxWidgets.git / blobdiff