Fixes #4172 Timeout revamp and remove continuous mouse (#4173)

* Remove continous press code from Application

* WIP prototype code to handle continuous press as subcomponent of View

* Prototype with Button

* Implement CWP

* Move to seperate classes and prevent double entry to Start

* Fix repeat clicking when moving mouse by removing phantom click code (old implementation of WantContinuousButtonPressed)

* Remove initial tick because it results in double activation e.g. button firing twice immediately as mouse is pressed down.

* Refactor DatePicker lamdas

* WIP investigate subcomponents instead of statics

* Add IMouseGrabHandler to IApplication

* Make mouse grabbing non static activity

* Make MouseHeldDown suppress when null fields e.g. app not initialized in tests

* Update test and remove dependency on Application

* Fix other mouse click and hold tests

* Code cleanup

* Update class diagram

* Fix bad xml doc references

* Fix timed events not getting passed through in v2 applications

* Make timed events nullable for tests that dont create an Application

* Remove strange blocking test

* WIP remove all idles and replace with zero timeouts

* Fix build of tests

* Fix unit tests

* Add wakeup call back in

* Comment out incredibly complicated test and fix others

* Fix test

* test fix

* Make Post execute immediately if already on UI thread

* Re enable test and simplify Invoke to just execute if in UI thread (up front)

* Remove xml doc references to idles

* Remove more references to idles

* Make Screen initialization threadsafe

* Add more exciting timeouts

* WIP add tests

* fix log

* fix test

* make continuous key press use smoth acceleration

* Rename _lock to _lockScreen

* Remove section on idles, they are not a thing anymore - and they kinda never were.

* Add nullable enable

* Add xml comment

* Fix namings and cleanup code

* xmldoc fix

* Rename LockAndRunTimers to just RunTimers

* Rename AddTimeout and RemoveTimeout (and event) to just Add/Remove

* Update description of MainLoop

* Commented out Run_T_Call_Init_ForceDriver_Should_Pick_Correct_Driver

* Again? Commented out Run_T_Call_Init_ForceDriver_Should_Pick_Correct_Driver

* Revert Commented out Run_T_Call_Init_ForceDriver_Should_Pick_Correct_Driver

* When mouse is released from MouseHeldDown reset host MouseState

* Fix namespaces in class diagram

* Apply @BDisp suggested fix

* Fix class diagrams

* Add lock

* Make TimeSpan.Zero definetly run

* Fix duplicate entry in package props

---------

Co-authored-by: Tig <tig@users.noreply.github.com>

Tests/UnitTestsParallelizable/Application/LogarithmicTimeoutTests.cs

@@ -0,0 +1,81 @@
+namespace Terminal.Gui.ApplicationTests;
+
+public class LogarithmicTimeoutTests
+{
+    [Fact]
+    public void Span_Should_Return_BaseDelay_When_Stage_Is_Zero ()
+    {
+        var baseDelay = TimeSpan.FromMilliseconds (1000);
+        var timeout = new LogarithmicTimeout (baseDelay, () => true);
+
+        Assert.Equal (TimeSpan.Zero, timeout.Span);
+    }
+
+    [Fact]
+    public void Span_Should_Increase_Logarithmically ()
+    {
+        var baseDelay = TimeSpan.FromMilliseconds (1000);
+        var timeout = new LogarithmicTimeout (baseDelay, () => true);
+
+        var stage0 = timeout.Span;
+
+        timeout.AdvanceStage (); // stage = 1
+        var stage1 = timeout.Span;
+
+        timeout.AdvanceStage (); // stage = 2
+        var stage2 = timeout.Span;
+
+        timeout.AdvanceStage (); // stage = 3
+        var stage3 = timeout.Span;
+
+        Assert.True (stage1 > stage0, "Stage 1 should be greater than stage 0");
+        Assert.True (stage2 > stage1, "Stage 2 should be greater than stage 1");
+        Assert.True (stage3 > stage2, "Stage 3 should be greater than stage 2");
+    }
+
+    [Theory]
+    [MemberData (nameof (GetLogarithmicTestData))]
+    public void Span_Should_Match_Expected_Logarithmic_Value (
+        double baseDelayMs, int stage, double expectedMs)
+    {
+        var baseDelay = TimeSpan.FromMilliseconds (baseDelayMs);
+        var timeout = new LogarithmicTimeout (baseDelay, () => true);
+
+        for (int i = 0; i < stage; i++)
+        {
+            timeout.AdvanceStage ();
+        }
+
+        double actualMs = timeout.Span.TotalMilliseconds;
+        double tolerance = 0.001; // Allow minor rounding error
+
+        Assert.InRange (actualMs, expectedMs - tolerance, expectedMs + tolerance);
+    }
+
+    public static IEnumerable<object []> GetLogarithmicTestData ()
+    {
+        // baseDelayMs, stage, expectedSpanMs
+        double baseMs = 1000;
+
+        yield return new object [] { baseMs, 0, 0 };
+        yield return new object [] { baseMs, 1, baseMs * Math.Log (2) };
+        yield return new object [] { baseMs, 2, baseMs * Math.Log (3) };
+        yield return new object [] { baseMs, 5, baseMs * Math.Log (6) };
+        yield return new object [] { baseMs, 10, baseMs * Math.Log (11) };
+    }
+
+
+    [Fact]
+    public void Reset_Should_Set_Stage_Back_To_Zero ()
+    {
+        var baseDelay = TimeSpan.FromMilliseconds (1000);
+        var timeout = new LogarithmicTimeout (baseDelay, () => true);
+
+        timeout.AdvanceStage ();
+        timeout.AdvanceStage ();
+        Assert.NotEqual (baseDelay, timeout.Span);
+
+        timeout.Reset ();
+        Assert.Equal (TimeSpan.Zero, timeout.Span);
+    }
+}

Tests/UnitTestsParallelizable/Application/SmoothAcceleratingTimeoutTests.cs

@@ -0,0 +1,70 @@
+namespace Terminal.Gui.ApplicationTests;
+
+
+public class SmoothAcceleratingTimeoutTests
+{
+    [Fact]
+    public void Span_Should_Return_InitialDelay_On_StageZero ()
+    {
+        var initialDelay = TimeSpan.FromMilliseconds (500);
+        var minDelay = TimeSpan.FromMilliseconds (50);
+        double decayFactor = 0.7;
+
+        var timeout = new SmoothAcceleratingTimeout (initialDelay, minDelay, decayFactor, () => true);
+
+        Assert.Equal (initialDelay, timeout.Span);
+    }
+
+    [Fact]
+    public void Span_Should_Decrease_As_Stage_Increases ()
+    {
+        var initialDelay = TimeSpan.FromMilliseconds (500);
+        var minDelay = TimeSpan.FromMilliseconds (50);
+        double decayFactor = 0.7;
+
+        var timeout = new SmoothAcceleratingTimeout (initialDelay, minDelay, decayFactor, () => true);
+
+        var previousSpan = timeout.Span;
+        for (int i = 0; i < 10; i++)
+        {
+            timeout.AdvanceStage ();
+            var currentSpan = timeout.Span;
+            Assert.True (currentSpan <= previousSpan, $"Stage {i + 1}: {currentSpan} should be <= {previousSpan}");
+            previousSpan = currentSpan;
+        }
+    }
+
+    [Fact]
+    public void Span_Should_Not_Go_Below_MinDelay ()
+    {
+        var initialDelay = TimeSpan.FromMilliseconds (500);
+        var minDelay = TimeSpan.FromMilliseconds (50);
+        double decayFactor = 0.5;
+
+        var timeout = new SmoothAcceleratingTimeout (initialDelay, minDelay, decayFactor, () => true);
+
+        for (int i = 0; i < 100; i++)
+        {
+            timeout.AdvanceStage ();
+        }
+
+        Assert.Equal (minDelay, timeout.Span);
+    }
+
+    [Fact]
+    public void Reset_Should_Set_Stage_Back_To_Zero ()
+    {
+        var initialDelay = TimeSpan.FromMilliseconds (500);
+        var minDelay = TimeSpan.FromMilliseconds (50);
+        double decayFactor = 0.7;
+
+        var timeout = new SmoothAcceleratingTimeout (initialDelay, minDelay, decayFactor, () => true);
+
+        timeout.AdvanceStage ();
+        timeout.AdvanceStage ();
+        Assert.NotEqual (initialDelay, timeout.Span);
+
+        timeout.Reset ();
+        Assert.Equal (initialDelay, timeout.Span);
+    }
+}

Tests/UnitTestsParallelizable/TestSetup.cs

@@ -40,8 +40,7 @@ public class GlobalTestSetup : IDisposable
 
         // Public Properties
         Assert.Null (Application.Top);
-        Assert.Null (Application.MouseGrabView);
-        Assert.Null (Application.WantContinuousButtonPressedView);
+        Assert.Null (Application.MouseGrabHandler.MouseGrabView);
 
         // Don't check Application.ForceDriver
         // Assert.Empty (Application.ForceDriver);