// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
-// ============================================================================
-// declarations
-// ============================================================================
-
-// ----------------------------------------------------------------------------
-// headers
-// ----------------------------------------------------------------------------
-
// for compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#pragma hdrstop
#endif
+#include "wx/evtloop.h"
+
#ifndef WX_PRECOMP
#include "wx/app.h"
- #include "wx/event.h"
#endif //WX_PRECOMP
-#include "wx/evtloop.h"
-
// ----------------------------------------------------------------------------
-// globals
+// wxEventLoopBase
// ----------------------------------------------------------------------------
wxEventLoopBase *wxEventLoopBase::ms_activeLoop = NULL;
m_eventsToProcessInsideYield = wxEVT_CATEGORY_ALL;
}
-void wxEventLoopBase::DelayPendingEventHandler(wxEvtHandler* toDelay)
-{
- 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);
-}
-
-void wxEventLoopBase::RemovePendingEventHandler(wxEvtHandler* toRemove)
-{
- wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
-
- if (m_handlersWithPendingEvents.Index(toRemove) != wxNOT_FOUND)
- {
- m_handlersWithPendingEvents.Remove(toRemove);
-
- // 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);
-}
-
-void wxEventLoopBase::AppendPendingEventHandler(wxEvtHandler* toAppend)
-{
- wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
-
- if ( m_handlersWithPendingEvents.Index(toAppend) == wxNOT_FOUND )
- m_handlersWithPendingEvents.Add(toAppend);
-
- wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
-}
-
-bool wxEventLoopBase::HasPendingEvents() const
+bool wxEventLoopBase::IsMain() const
{
- wxENTER_CRIT_SECT(const_cast<wxEventLoopBase*>(this)->m_handlersWithPendingEventsLocker);
-
- bool has = !m_handlersWithPendingEvents.IsEmpty();
-
- wxLEAVE_CRIT_SECT(const_cast<wxEventLoopBase*>(this)->m_handlersWithPendingEventsLocker);
-
- return has;
+ if (wxTheApp)
+ return wxTheApp->GetMainLoop() == this;
+ return false;
}
-void wxEventLoopBase::SuspendProcessingOfPendingEvents()
+/* static */
+void wxEventLoopBase::SetActive(wxEventLoopBase* loop)
{
- wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
-}
+ ms_activeLoop = loop;
-void wxEventLoopBase::ResumeProcessingOfPendingEvents()
-{
- wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
+ if (wxTheApp)
+ wxTheApp->OnEventLoopEnter(loop);
}
-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.
- wxENTER_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();
-
- wxLEAVE_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)
}
// 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 )
+ {
+ // We still need to dispatch any remaining pending events, just as
+ // we do in the event loop in Run() if the loop is exited from a
+ // normal event handler.
+ while ( wxTheApp->HasPendingEvents() )
+ wxTheApp->ProcessPendingEvents();
+
+ 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 ( !Pending() && ProcessIdle() && !m_shouldExit )
;
// if the "should exit" flag is set, the loop should terminate
if ( m_shouldExit )
{
while ( Pending() )
- Dispatch();
+ ProcessEvents();
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;
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