Simplify wxEventLoopManual pending events processing logic.

Don't try to process any remaining pending events in ProcessEvents() itself as
this was inconsistent: we only processed low-level toolkit pending events in
the main event loop itself if the loop was exited from a normal event handler
but only processed the wxApp-level pending events if it was exited from a
pending event handler. It also required more code than the new version that
simply processes all the remaining pending events, of both kinds, after the
main event loop termination.

This corrects changes of r71304 and replaces those of r71329.

Closes #14250.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@71432 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/src/common/evtloopcmn.cpp b/src/common/evtloopcmn.cpp
index f6f7c4aa1f33e6a6d07b8a90826a169e9b232dfb..99f2d78f3dda3ebdda6111a3d7a6e689104ad81f 100644 (file)
--- a/src/common/evtloopcmn.cpp
+++ b/src/common/evtloopcmn.cpp
@@ -105,23 +105,13 @@ bool wxEventLoopManual::ProcessEvents()
     // executed)
     if ( wxTheApp )
     {
     // executed)
     if ( wxTheApp )
     {

-        const bool hadExitedBefore = m_shouldExit;
-

         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).
         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 ( !hadExitedBefore && 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();
-
+        if ( m_shouldExit )

             return false;
             return false;

-        }

     }
 
     return Dispatch();
     }
 
     return Dispatch();


@@ -157,19 +147,11 @@ 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() && ProcessIdle() && !m_shouldExit )
+                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() )
-                        ProcessEvents();
-

                     break;
                     break;

-                }

 
                 // a message came or no more idle processing to do, dispatch
                 // all the pending events and call Dispatch() to wait for the
 
                 // a message came or no more idle processing to do, dispatch
                 // all the pending events and call Dispatch() to wait for the


@@ -181,6 +163,33 @@ int wxEventLoopManual::Run()
                 }
             }
 
                 }
             }
 

+            // 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;