WIP remove all idles and replace with zero timeouts

Terminal.Gui/App/Application.cs

@@ -252,10 +252,4 @@ internal static void ResetState (bool ignoreDisposed = false)
         // (https://github.com/gui-cs/Terminal.Gui/issues/1084).
         SynchronizationContext.SetSynchronizationContext (null);
     }
-
-    /// <summary>
-    ///     Adds specified idle handler function to main iteration processing. The handler function will be called
-    ///     once per iteration of the main loop after other events have been handled.
-    /// </summary>
-    public static void AddIdle (Func<bool> func) { ApplicationImpl.Instance.AddIdle (func); }
 }

Terminal.Gui/App/ApplicationImpl.cs

@@ -261,7 +261,7 @@ public virtual void RequestStop (Toplevel? top)
     /// <inheritdoc />
     public virtual void Invoke (Action action)
     {
-        Application.MainLoop?.AddIdle (
+        Application.AddTimeout (TimeSpan.Zero,
                            () =>
                            {
                                action ();
@@ -274,20 +274,6 @@ public virtual void Invoke (Action action)
     /// <inheritdoc />
     public bool IsLegacy { get; protected set; } = true;
 
-    /// <inheritdoc />
-    public virtual void AddIdle (Func<bool> func)
-    {
-        if (Application.MainLoop is null)
-        {
-            throw new NotInitializedException ("Cannot add idle before main loop is initialized");
-        }
-
-        // Yes in this case we cannot go direct via TimedEvents because legacy main loop
-        // has established behaviour to do other stuff too e.g. 'wake up'.
-        Application.MainLoop.AddIdle (func);
-
-    }
-
     /// <inheritdoc />
     public virtual object AddTimeout (TimeSpan time, Func<bool> callback)
     {

Terminal.Gui/App/IApplication.cs

@@ -156,13 +156,7 @@ public T Run<T> (Func<Exception, bool>? errorHandler = null, IConsoleDriver? dri
     /// is cutting edge.
     /// </summary>
     bool IsLegacy { get; }
-
-    /// <summary>
-    ///     Adds specified idle handler function to main iteration processing. The handler function will be called
-    ///     once per iteration of the main loop after other events have been handled.
-    /// </summary>
-    void AddIdle (Func<bool> func);
-
+
     /// <summary>Adds a timeout to the application.</summary>
     /// <remarks>
     ///     When time specified passes, the callback will be invoked. If the callback returns true, the timeout will be

Terminal.Gui/App/ITimedEvents.cs

@@ -8,34 +8,11 @@ namespace Terminal.Gui.App;
 /// </summary>
 public interface ITimedEvents
 {
-    /// <summary>
-    ///     Adds specified idle handler function to main iteration processing. The handler function will be called
-    ///     once per iteration of the main loop after other events have been handled.
-    /// </summary>
-    /// <param name="idleHandler"></param>
-    void AddIdle (Func<bool> idleHandler);
-
-    /// <summary>
-    /// Runs all idle hooks
-    /// </summary>
-    void LockAndRunIdles ();
-
     /// <summary>
     /// Runs all timeouts that are due
     /// </summary>
     void LockAndRunTimers ();
 
-    /// <summary>
-    ///     Called from <see cref="IMainLoopDriver.EventsPending"/> to check if there are any outstanding timers or idle
-    ///     handlers.
-    /// </summary>
-    /// <param name="waitTimeout">
-    ///     Returns the number of milliseconds remaining in the current timer (if any). Will be -1 if
-    ///     there are no active timers.
-    /// </param>
-    /// <returns><see langword="true"/> if there is a timer or idle handler active.</returns>
-    bool CheckTimersAndIdleHandlers (out int waitTimeout);
-
     /// <summary>Adds a timeout to the application.</summary>
     /// <remarks>
     ///     When time specified passes, the callback will be invoked. If the callback returns true, the timeout will be
@@ -58,33 +35,28 @@ public interface ITimedEvents
     /// </returns>
     bool RemoveTimeout (object token);
 
-    /// <summary>
-    /// Returns all currently registered idles. May not include
-    /// actively executing idles.
-    /// </summary>
-    ReadOnlyCollection<Func<bool>> IdleHandlers { get;}
-
     /// <summary>
     /// Returns the next planned execution time (key - UTC ticks)
     /// for each timeout that is not actively executing.
     /// </summary>
     SortedList<long, Timeout> Timeouts { get; }
 
-
-    /// <summary>Removes an idle handler added with <see cref="AddIdle(Func{bool})"/> from processing.</summary>
-    /// <returns>
-    /// <see langword="true"/>
-    /// if the idle handler is successfully removed; otherwise,
-    /// <see langword="false"/>
-    /// .
-    /// This method also returns
-    /// <see langword="false"/>
-    /// if the idle handler is not found.</returns>
-    bool RemoveIdle (Func<bool> fnTrue);
-
     /// <summary>
     ///     Invoked when a new timeout is added. To be used in the case when
     ///     <see cref="Application.EndAfterFirstIteration"/> is <see langword="true"/>.
     /// </summary>
     event EventHandler<TimeoutEventArgs>? TimeoutAdded;
+
+
+
+    /// <summary>
+    ///     Called from <see cref="IMainLoopDriver.EventsPending"/> to check if there are any outstanding timers
+    ///     handlers.
+    /// </summary>
+    /// <param name="waitTimeout">
+    ///     Returns the number of milliseconds remaining in the current timer (if any). Will be -1 if
+    ///     there are no active timers.
+    /// </param>
+    /// <returns><see langword="true"/> if there is a timer active.</returns>
+    bool CheckTimers (out int waitTimeout);
 }

Terminal.Gui/App/MainLoop.cs

@@ -75,32 +75,6 @@ public void Dispose ()
         MainLoopDriver = null;
     }
 
-    /// <summary>
-    ///     Adds specified idle handler function to <see cref="MainLoop"/> processing. The handler function will be called
-    ///     once per iteration of the main loop after other events have been handled.
-    /// </summary>
-    /// <remarks>
-    ///     <para>Remove an idle handler by calling <see cref="TimedEvents.RemoveIdle(Func{bool})"/> with the token this method returns.</para>
-    ///     <para>
-    ///         If the <paramref name="idleHandler"/> returns  <see langword="false"/> it will be removed and not called
-    ///         subsequently.
-    ///     </para>
-    /// </remarks>
-    /// <param name="idleHandler">Token that can be used to remove the idle handler with <see cref="TimedEvents.RemoveIdle(Func{bool})"/> .</param>
-    // QUESTION: Why are we re-inventing the event wheel here?
-    // PERF: This is heavy.
-    // CONCURRENCY: Race conditions exist here.
-    // CONCURRENCY: null delegates will hose this.
-    // 
-    internal Func<bool> AddIdle (Func<bool> idleHandler)
-    {
-        TimedEvents.AddIdle (idleHandler);
-
-        MainLoopDriver?.Wakeup ();
-
-        return idleHandler;
-    }
-
 
     /// <summary>Determines whether there are pending events to be processed.</summary>
     /// <remarks>
@@ -139,8 +113,6 @@ internal void RunIteration ()
         MainLoopDriver?.Iteration ();
 
         TimedEvents.LockAndRunTimers ();
-
-        TimedEvents.LockAndRunIdles ();
     }
 
     private void RunAnsiScheduler ()

Terminal.Gui/App/MainLoopSyncContext.cs

@@ -10,7 +10,7 @@ internal sealed class MainLoopSyncContext : SynchronizationContext
 
     public override void Post (SendOrPostCallback d, object state)
     {
-        Application.MainLoop?.AddIdle (
+        Application.MainLoop?.TimedEvents.AddTimeout (TimeSpan.Zero,
                                        () =>
                                        {
                                            d (state);

Terminal.Gui/App/TimedEvents.cs

@@ -8,42 +8,15 @@ namespace Terminal.Gui.App;
 /// </summary>
 public class TimedEvents : ITimedEvents
 {
-    internal List<Func<bool>> _idleHandlers = new ();
     internal SortedList<long, Timeout> _timeouts = new ();
-
-    /// <summary>The idle handlers and lock that must be held while manipulating them</summary>
-    private readonly object _idleHandlersLock = new ();
-
     private readonly object _timeoutsLockToken = new ();
 
-
-    /// <summary>Gets a copy of the list of all idle handlers.</summary>
-    public ReadOnlyCollection<Func<bool>> IdleHandlers
-    {
-        get
-        {
-            lock (_idleHandlersLock)
-            {
-                return new List<Func<bool>> (_idleHandlers).AsReadOnly ();
-            }
-        }
-    }
-
     /// <summary>
     ///     Gets the list of all timeouts sorted by the <see cref="TimeSpan"/> time ticks. A shorter limit time can be
     ///     added at the end, but it will be called before an earlier addition that has a longer limit time.
     /// </summary>
     public SortedList<long, Timeout> Timeouts => _timeouts;
 
-    /// <inheritdoc />
-    public void AddIdle (Func<bool> idleHandler)
-    {
-        lock (_idleHandlersLock)
-        {
-            _idleHandlers.Add (idleHandler);
-        }
-    }
-
     /// <inheritdoc/>
     public event EventHandler<TimeoutEventArgs>? TimeoutAdded;
 
@@ -77,32 +50,6 @@ private long NudgeToUniqueKey (long k)
         return k;
     }
 
-
-    // PERF: This is heavier than it looks.
-    // CONCURRENCY: Potential deadlock city here.
-    // CONCURRENCY: Multiple concurrency pitfalls on the delegates themselves.
-    // INTENT: It looks like the general architecture here is trying to be a form of publisher/consumer pattern.
-    private void RunIdle ()
-    {
-        Func<bool> [] iterate;
-        lock (_idleHandlersLock)
-        {
-            iterate = _idleHandlers.ToArray ();
-            _idleHandlers = new List<Func<bool>> ();
-        }
-
-        foreach (Func<bool> idle in iterate)
-        {
-            if (idle ())
-            {
-                lock (_idleHandlersLock)
-                {
-                    _idleHandlers.Add (idle);
-                }
-            }
-        }
-    }
-
     /// <inheritdoc/>
     public void LockAndRunTimers ()
     {
@@ -116,21 +63,6 @@ public void LockAndRunTimers ()
 
     }
 
-    /// <inheritdoc/>
-    public void LockAndRunIdles ()
-    {
-        bool runIdle;
-
-        lock (_idleHandlersLock)
-        {
-            runIdle = _idleHandlers.Count > 0;
-        }
-
-        if (runIdle)
-        {
-            RunIdle ();
-        }
-    }
     private void RunTimers ()
     {
         long now = DateTime.UtcNow.Ticks;
@@ -165,15 +97,6 @@ private void RunTimers ()
         }
     }
 
-    /// <inheritdoc/>
-    public bool RemoveIdle (Func<bool> token)
-    {
-        lock (_idleHandlersLock)
-        {
-            return _idleHandlers.Remove (token);
-        }
-    }
-
     /// <summary>Removes a previously scheduled timeout</summary>
     /// <remarks>The token parameter is the value returned by AddTimeout.</remarks>
     /// Returns
@@ -219,7 +142,7 @@ public object AddTimeout (TimeSpan time, Func<bool> callback)
     }
 
     /// <inheritdoc/>
-    public bool CheckTimersAndIdleHandlers (out int waitTimeout)
+    public bool CheckTimers(out int waitTimeout)
     {
         long now = DateTime.UtcNow.Ticks;
 
@@ -247,11 +170,6 @@ public bool CheckTimersAndIdleHandlers (out int waitTimeout)
             waitTimeout = -1;
         }
 
-        // There are no timers set, check if there are any idle handlers
-
-        lock (_idleHandlersLock)
-        {
-            return _idleHandlers.Count > 0;
-        }
+        return false;
     }
 }

Terminal.Gui/Drivers/CursesDriver/UnixMainLoop.cs

@@ -104,7 +104,7 @@ bool IMainLoopDriver.EventsPending ()
 
         UpdatePollMap ();
 
-        bool checkTimersResult = _mainLoop!.TimedEvents.CheckTimersAndIdleHandlers (out int pollTimeout);
+        bool checkTimersResult = _mainLoop!.TimedEvents.CheckTimers (out int pollTimeout);
 
         int n = poll (_pollMap!, (uint)_pollMap!.Length, pollTimeout);
 

Terminal.Gui/Drivers/EscSeqUtils/EscSeqUtils.cs

@@ -902,7 +902,7 @@ Action<MouseFlags, Point> continuousButtonPressedHandler
 
             if ((mouseFlags [0] & MouseFlags.ReportMousePosition) == 0)
             {
-                Application.MainLoop?.AddIdle (
+                Application.MainLoop?.TimedEvents.AddTimeout (TimeSpan.Zero,
                                               () =>
                                               {
                                                   // INTENT: What's this trying to do?
@@ -945,7 +945,7 @@ Action<MouseFlags, Point> continuousButtonPressedHandler
             _isButtonClicked = false;
             _isButtonDoubleClicked = true;
 
-            Application.MainLoop?.AddIdle (
+            Application.MainLoop?.TimedEvents.AddTimeout (TimeSpan.Zero,
                                           () =>
                                           {
                                               Task.Run (async () => await ProcessButtonDoubleClickedAsync ());
@@ -959,7 +959,7 @@ Action<MouseFlags, Point> continuousButtonPressedHandler
         //	lastMouseButtonReleased = null;
         //	isButtonReleased = false;
         //	isButtonClicked = true;
-        //	Application.MainLoop.AddIdle (() => {
+        //	Application.MainLoop.AddTimeout (() => {
         //		Task.Run (async () => await ProcessButtonClickedAsync ());
         //		return false;
         //	});
@@ -984,7 +984,7 @@ Action<MouseFlags, Point> continuousButtonPressedHandler
                 mouseFlags.Add (GetButtonClicked (buttonState));
                 _isButtonClicked = true;
 
-                Application.MainLoop?.AddIdle (
+                Application.MainLoop?.TimedEvents.AddTimeout (TimeSpan.Zero,
                                               () =>
                                               {
                                                   Task.Run (async () => await ProcessButtonClickedAsync ());

Terminal.Gui/Drivers/NetDriver/NetMainLoop.cs

@@ -57,7 +57,7 @@ bool IMainLoopDriver.EventsPending ()
 
         _waitForProbe.Set ();
 
-        if (_resultQueue.Count > 0 || _mainLoop!.TimedEvents.CheckTimersAndIdleHandlers (out int waitTimeout))
+        if (_resultQueue.Count > 0 || _mainLoop!.TimedEvents.CheckTimers (out int waitTimeout))
         {
             return true;
         }
@@ -84,7 +84,7 @@ bool IMainLoopDriver.EventsPending ()
 
         if (!_eventReadyTokenSource.IsCancellationRequested)
         {
-            return _resultQueue.Count > 0 || _mainLoop.TimedEvents.CheckTimersAndIdleHandlers (out _);
+            return _resultQueue.Count > 0 || _mainLoop.TimedEvents.CheckTimers (out _);
         }
 
         // If cancellation was requested then always return true