deal with Cocoa as we do with Carbon, see #15008

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

diff --git a/src/common/evtloopcmn.cpp b/src/common/evtloopcmn.cpp
index 997718b44aedca26bf9b428d18a31e39f8084a5d..99f2d78f3dda3ebdda6111a3d7a6e689104ad81f 100644 (file)
--- a/src/common/evtloopcmn.cpp
+++ b/src/common/evtloopcmn.cpp
@@ -9,14 +9,6 @@
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 

-// ============================================================================
-// declarations
-// ============================================================================
-
-// ----------------------------------------------------------------------------
-// headers
-// ----------------------------------------------------------------------------
-

 // for compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // for compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -31,13 +23,66 @@
 #endif //WX_PRECOMP
 
 // ----------------------------------------------------------------------------
 #endif //WX_PRECOMP
 
 // ----------------------------------------------------------------------------

-// globals
+// wxEventLoopBase

 // ----------------------------------------------------------------------------
 
 wxEventLoopBase *wxEventLoopBase::ms_activeLoop = NULL;
 
 // ----------------------------------------------------------------------------
 
 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
 // 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 implementation


@@ -49,18 +94,41 @@ wxEventLoopManual::wxEventLoopManual()
     m_shouldExit = false;
 }
 
     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!
 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
     // 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)
     // 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)


@@ -79,29 +147,49 @@ int wxEventLoopManual::Run()
 
                 // generate and process idle events for as long as we don't
                 // have anything else to do
 
                 // 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 )
                 if ( m_shouldExit )

-                {
-                    while ( Pending() )
-                        Dispatch();
-

                     break;
                     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;
                 }
             }
 
                 {
                     // 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;
 #if wxUSE_EXCEPTIONS
             // exit the outer loop as well
             break;


@@ -134,7 +222,7 @@ int wxEventLoopManual::Run()
 
 void wxEventLoopManual::Exit(int rc)
 {
 
 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;
 
     m_exitcode = rc;
     m_shouldExit = true;


@@ -152,24 +240,5 @@ void wxEventLoopManual::Exit(int rc)
     WakeUp();
 }
 
     WakeUp();
 }
 

-#endif // __WXMSW__ || __WXMAC__ || __WXDFB__
-
-#ifdef wxNEEDS_GENERIC_DISPATCH_TIMEOUT
-
-int wxGUIEventLoop::DispatchTimeout(unsigned long timeout)
-{
-    // TODO: this is, of course, horribly inefficient and a proper wait with
-    //       timeout should be implemented for all ports natively...
-    const wxMilliClock_t timeEnd = wxGetLocalTimeMillis() + timeout;
-    for ( ;; )
-    {
-        if ( Pending() )
-            return Dispatch();
-
-        if ( wxGetLocalTimeMillis() >= timeEnd )
-            return -1;
-    }
-}
-
-#endif // wxNEEDS_GENERIC_DISPATCH_TIMEOUT
+#endif // __WINDOWS__ || __WXMAC__ || __WXDFB__