Add more exciting timeouts

Examples/UICatalog/Scenarios/Threading.cs

@@ -19,6 +19,16 @@ public class Threading : Scenario
     private ListView _logJob;
     private Action _sync;
 
+    private LogarithmicTimeout _logarithmicTimeout;
+    private NumericUpDown _numberLog;
+    private Button _btnLogarithmic;
+    private object _timeoutObj;
+
+    private SmoothAcceleratingTimeout _smoothTimeout;
+    private NumericUpDown _numberSmooth;
+    private Button _btnSmooth;
+    private object _timeoutObjSmooth;
+
     public override void Main ()
     {
         Application.Init ();
@@ -82,6 +92,35 @@ public override void Main ()
 
         var text = new TextField { X = 1, Y = 3, Width = 100, Text = "Type anything after press the button" };
 
+        _btnLogarithmic = new Button ()
+        {
+            X = 50,
+            Y = 4,
+            Text = "Start Log Counter"
+        };
+        _btnLogarithmic.Accepting += StartStopLogTimeout;
+
+        _numberLog = new NumericUpDown ()
+        {
+            X = Pos.Right (_btnLogarithmic),
+            Y = 4,
+        };
+
+        _btnSmooth = new Button ()
+        {
+            X = Pos.Right (_numberLog),
+            Y = 4,
+            Text = "Start Smooth Counter"
+        };
+        _btnSmooth.Accepting += StartStopSmoothTimeout;
+
+        _numberSmooth = new NumericUpDown ()
+        {
+            X = Pos.Right (_btnSmooth),
+            Y = 4,
+        };
+
+
         var btnAction = new Button { X = 80, Y = 10, Text = "Load Data Action" };
         btnAction.Accepting += (s, e) => _action.Invoke ();
         var btnLambda = new Button { X = 80, Y = 12, Text = "Load Data Lambda" };
@@ -107,6 +146,10 @@ public override void Main ()
                  _btnActionCancel,
                  _logJob,
                  text,
+                 _btnLogarithmic,
+                 _numberLog,
+                 _btnSmooth,
+                 _numberSmooth,
                  btnAction,
                  btnLambda,
                  btnHandler,
@@ -129,6 +172,51 @@ void Win_Loaded (object sender, EventArgs args)
         Application.Shutdown ();
     }
 
+    private bool LogTimeout ()
+    {
+        _numberLog.Value++;
+        _logarithmicTimeout.AdvanceStage ();
+        return true;
+    }
+    private bool SmoothTimeout ()
+    {
+        _numberSmooth.Value++;
+        _smoothTimeout.AdvanceStage ();
+        return true;
+    }
+
+    private void StartStopLogTimeout (object sender, CommandEventArgs e)
+    {
+        if (_timeoutObj != null)
+        {
+            _btnLogarithmic.Text = "Start Log Counter";
+            Application.TimedEvents.RemoveTimeout (_timeoutObj);
+            _timeoutObj = null;
+        }
+        else
+        {
+            _btnLogarithmic.Text = "Stop Log Counter";
+            _logarithmicTimeout = new LogarithmicTimeout (TimeSpan.FromMilliseconds (500), LogTimeout);
+            _timeoutObj = Application.TimedEvents.AddTimeout (_logarithmicTimeout);
+        }
+    }
+
+    private void StartStopSmoothTimeout (object sender, CommandEventArgs e)
+    {
+        if (_timeoutObjSmooth != null)
+        {
+            _btnSmooth.Text = "Start Smooth Counter";
+            Application.TimedEvents.RemoveTimeout (_timeoutObjSmooth);
+            _timeoutObjSmooth = null;
+        }
+        else
+        {
+            _btnSmooth.Text = "Stop Smooth Counter";
+            _smoothTimeout = new SmoothAcceleratingTimeout (TimeSpan.FromMilliseconds (500), TimeSpan.FromMilliseconds (50), 0.5, SmoothTimeout);
+            _timeoutObjSmooth = Application.TimedEvents.AddTimeout (_smoothTimeout);
+        }
+    }
+
     private async void CallLoadItemsAsync ()
     {
         _cancellationTokenSource = new CancellationTokenSource ();

Terminal.Gui/App/ITimedEvents.cs

@@ -21,6 +21,9 @@ public interface ITimedEvents
     /// </remarks>
     object AddTimeout (TimeSpan time, Func<bool> callback);
 
+    /// <inheritdoc cref="AddTimeout(System.TimeSpan,System.Func{bool})"/>
+    object AddTimeout (Timeout timeout);
+
     /// <summary>Removes a previously scheduled timeout</summary>
     /// <remarks>The token parameter is the value returned by AddTimeout.</remarks>
     /// <returns>

Terminal.Gui/App/LogarithmicTimeout.cs

@@ -0,0 +1,43 @@
+namespace Terminal.Gui.App;
+
+/// <summary>Implements a logarithmic increasing timeout.</summary>
+public class LogarithmicTimeout : Timeout
+{
+    private int stage = 0;
+    private readonly TimeSpan baseDelay;
+
+    public LogarithmicTimeout (TimeSpan baseDelay, Func<bool> callback)
+    {
+        this.baseDelay = baseDelay;
+        this.Callback = callback;
+    }
+
+    /// <summary>Gets the current calculated Span based on the stage.</summary>
+    public override TimeSpan Span
+    {
+        get
+        {
+            // For stage 0, return base delay directly
+            if (stage == 0)
+            {
+                return baseDelay;
+            }
+
+            // Calculate logarithmic increase
+            double multiplier = Math.Log (stage + 1); // ln(stage + 1)
+            return TimeSpan.FromMilliseconds (baseDelay.TotalMilliseconds * multiplier);
+        }
+    }
+
+    /// <summary>Increments the stage to increase the timeout.</summary>
+    public void AdvanceStage ()
+    {
+        stage++;
+    }
+
+    /// <summary>Resets the stage back to zero.</summary>
+    public void Reset ()
+    {
+        stage = 0;
+    }
+}

Terminal.Gui/App/SmoothAcceleratingTimeout.cs

@@ -0,0 +1,58 @@
+namespace Terminal.Gui.App;
+
+/// <summary>
+/// Timeout which accelerates slowly at first then fast up to a maximum speed.
+/// Use <see cref="AdvanceStage"/> to increment the stage of the timer (e.g. in
+/// your timer callback code).
+/// </summary>
+public class SmoothAcceleratingTimeout : Timeout
+{
+    private int stage = 0;
+    private readonly TimeSpan initialDelay;
+    private readonly TimeSpan minDelay;
+    private readonly double decayFactor;
+
+    /// <summary>
+    /// Creates a new instance of the smooth acceleration timeout.
+    /// </summary>
+    /// <param name="initialDelay">Delay before first tick, the longest it will ever take</param>
+    /// <param name="minDelay">The fastest the timer can get no matter how long it runs</param>
+    /// <param name="decayFactor">Controls how fast the timer accelerates</param>
+    /// <param name="callback">Method to call when timer ticks</param>
+    public SmoothAcceleratingTimeout (TimeSpan initialDelay, TimeSpan minDelay, double decayFactor, Func<bool> callback)
+    {
+        this.initialDelay = initialDelay;
+        this.minDelay = minDelay;
+        this.decayFactor = decayFactor;
+        this.Callback = callback;
+    }
+
+    /// <inheritdoc/>
+    public override TimeSpan Span
+    {
+        get
+        {
+            double initialMs = initialDelay.TotalMilliseconds;
+            double minMs = minDelay.TotalMilliseconds;
+            double delayMs = minMs + (initialMs - minMs) * Math.Pow (decayFactor, stage);
+            return TimeSpan.FromMilliseconds (delayMs);
+        }
+    }
+
+    /// <summary>
+    /// Advances the timer stage, this should be called from your timer callback or whenever
+    /// you want to advance the speed.
+    /// </summary>
+    public void AdvanceStage ()
+    {
+        stage++;
+    }
+
+    /// <summary>
+    /// Resets the timer to original speed.
+    /// </summary>
+    public void Reset ()
+    {
+        stage = 0;
+    }
+}

Terminal.Gui/App/TimedEvents.cs

@@ -141,6 +141,13 @@ public object AddTimeout (TimeSpan time, Func<bool> callback)
         return timeout;
     }
 
+    /// <inheritdoc />
+    public object AddTimeout (Timeout timeout)
+    {
+        AddTimeout (timeout.Span, timeout);
+        return timeout;
+    }
+
     /// <inheritdoc/>
     public bool CheckTimers(out int waitTimeout)
     {

Terminal.Gui/App/Timeout.cs

@@ -7,12 +7,13 @@
 
 namespace Terminal.Gui.App;
 
+
 /// <summary>Provides data for timers running manipulation.</summary>
-public sealed class Timeout
+public class Timeout
 {
     /// <summary>The function that will be invoked.</summary>
     public Func<bool> Callback;
 
     /// <summary>Time to wait before invoke the callback.</summary>
-    public TimeSpan Span;
-}
+    public virtual TimeSpan Span { get; set; }
+}