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>
2025-12-26 15:57:56 +01:00 · 2025-07-10 18:59:27 +01:00
parent 23cacaee93
commit ec827e901e
68 changed files with 1788 additions and 1448 deletions
--- a/Tests/UnitTestsParallelizable/Application/LogarithmicTimeoutTests.cs
+++ b/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);
+    }
+}
--- a/Tests/UnitTestsParallelizable/Application/SmoothAcceleratingTimeoutTests.cs
+++ b/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);
+    }
+}