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>

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 class Threading : Scenario
 
         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 class Threading : Scenario
                  _btnActionCancel,
                  _logJob,
                  text,
+                 _btnLogarithmic,
+                 _numberLog,
+                 _btnSmooth,
+                 _numberSmooth,
                  btnAction,
                  btnLambda,
                  btnHandler,
@@ -129,6 +172,51 @@ public class Threading : Scenario
         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.Remove (_timeoutObj);
+            _timeoutObj = null;
+        }
+        else
+        {
+            _btnLogarithmic.Text = "Stop Log Counter";
+            _logarithmicTimeout = new LogarithmicTimeout (TimeSpan.FromMilliseconds (500), LogTimeout);
+            _timeoutObj = Application.TimedEvents.Add (_logarithmicTimeout);
+        }
+    }
+
+    private void StartStopSmoothTimeout (object sender, CommandEventArgs e)
+    {
+        if (_timeoutObjSmooth != null)
+        {
+            _btnSmooth.Text = "Start Smooth Counter";
+            Application.TimedEvents.Remove (_timeoutObjSmooth);
+            _timeoutObjSmooth = null;
+        }
+        else
+        {
+            _btnSmooth.Text = "Stop Smooth Counter";
+            _smoothTimeout = new SmoothAcceleratingTimeout (TimeSpan.FromMilliseconds (500), TimeSpan.FromMilliseconds (50), 0.5, SmoothTimeout);
+            _timeoutObjSmooth = Application.TimedEvents.Add (_smoothTimeout);
+        }
+    }
+
     private async void CallLoadItemsAsync ()
     {
         _cancellationTokenSource = new CancellationTokenSource ();