Fixes #3209 - Formalize Cancellable Work Pattern and add helpers (#4092)

Tests/IntegrationTests/UICatalog/ScenarioTests.cs

@@ -87,7 +87,7 @@ public class ScenarioTests : TestsAllViews
 
         void OnApplicationOnInitializedChanged (object? s, EventArgs<bool> a)
         {
-            if (a.CurrentValue)
+            if (a.Value)
             {
                 Application.Iteration += OnApplicationOnIteration;
                 initialized = true;
@@ -103,7 +103,7 @@ public class ScenarioTests : TestsAllViews
                 shutdownGracefully = true;
             }
 
-            _output.WriteLine ($"Initialized == {a.CurrentValue}; shutdownGracefully == {shutdownGracefully}.");
+            _output.WriteLine ($"Initialized == {a.Value}; shutdownGracefully == {shutdownGracefully}.");
         }
 
         // If the scenario doesn't close within abortTime ms, this will force it to quit

Tests/StressTests/ScenariosStressTests.cs

@@ -90,7 +90,7 @@ public class ScenariosStressTests : TestsAllViews
 
         void OnApplicationOnInitializedChanged (object? s, EventArgs<bool> a)
         {
-            if (a.CurrentValue)
+            if (a.Value)
             {
                 lock (_timeoutLock)
                 {
@@ -106,7 +106,7 @@ public class ScenariosStressTests : TestsAllViews
                                      {
                                          refreshedCount++;
 
-                                         if (args.CurrentValue)
+                                         if (args.Value)
                                          {
                                              updatedCount++;
                                          }
@@ -124,7 +124,7 @@ public class ScenariosStressTests : TestsAllViews
                 stopwatch!.Stop ();
             }
 
-            _output.WriteLine ($"Initialized == {a.CurrentValue}");
+            _output.WriteLine ($"Initialized == {a.Value}");
         }
 
         void OnApplicationOnIteration (object? s, IterationEventArgs a)

Tests/UnitTests/Application/ApplicationTests.cs

@@ -80,7 +80,7 @@ public class ApplicationTests
 
         void OnApplicationOnInitializedChanged (object s, EventArgs<bool> a)
         {
-            if (a.CurrentValue)
+            if (a.Value)
             {
                 Application.Iteration += OnApplicationOnIteration;
                 initialized = true;
@@ -447,7 +447,7 @@ public class ApplicationTests
 
         void OnApplicationOnInitializedChanged (object s, EventArgs<bool> a)
         {
-            if (a.CurrentValue)
+            if (a.Value)
             {
                 initialized = true;
             }

Tests/UnitTests/Application/KeyboardTests.cs

@@ -447,9 +447,9 @@ public class KeyboardTests
 
         void OnApplicationOnInitializedChanged (object s, EventArgs<bool> a)
         {
-            _output.WriteLine ("OnApplicationOnInitializedChanged: {0}", a.CurrentValue);
+            _output.WriteLine ("OnApplicationOnInitializedChanged: {0}", a.Value);
 
-            if (a.CurrentValue)
+            if (a.Value)
             {
                 Application.Iteration += OnApplicationOnIteration;
                 initialized = true;

Tests/UnitTests/Configuration/SettingsScopeTests.cs

@@ -51,7 +51,7 @@ public class SettingsScopeTests
 
         ThemeScope scope = dict [ThemeManager.DEFAULT_THEME_NAME];
         Assert.NotNull (scope);
-        Assert.Equal (HighlightStyle.Hover | HighlightStyle.Pressed, scope ["Button.DefaultHighlightStyle"].PropertyValue);
+        Assert.Equal (MouseState.In | MouseState.Pressed | MouseState.PressedOutside, scope ["Button.DefaultHighlightStates"].PropertyValue);
 
 
         RuntimeConfig = """
@@ -60,13 +60,13 @@ public class SettingsScopeTests
                                 {
                                   "Default": 
                                      {
-                                         "Button.DefaultHighlightStyle": "None"
+                                         "Button.DefaultHighlightStates": "None"
                                      }
                                 },
                                 {
                                   "NewTheme":
                                     {
-                                        "Button.DefaultHighlightStyle": "Hover"
+                                        "Button.DefaultHighlightStates": "In"
                                     }
                                 }                        
                             ]
@@ -77,8 +77,8 @@ public class SettingsScopeTests
 
         // assert
         Assert.Equal (2, ThemeManager.GetThemes ().Count);
-        Assert.Equal (HighlightStyle.None, (HighlightStyle)ThemeManager.GetCurrentTheme () ["Button.DefaultHighlightStyle"].PropertyValue!);
-        Assert.Equal (HighlightStyle.Hover, (HighlightStyle)ThemeManager.GetThemes () ["NewTheme"] ["Button.DefaultHighlightStyle"].PropertyValue!);
+        Assert.Equal (MouseState.None, (MouseState)ThemeManager.GetCurrentTheme () ["Button.DefaultHighlightStates"].PropertyValue!);
+        Assert.Equal (MouseState.In, (MouseState)ThemeManager.GetThemes () ["NewTheme"] ["Button.DefaultHighlightStates"].PropertyValue!);
 
         RuntimeConfig = """
                         {
@@ -86,7 +86,7 @@ public class SettingsScopeTests
                                 {
                                   "Default": 
                                      {
-                                         "Button.DefaultHighlightStyle": "Pressed"
+                                         "Button.DefaultHighlightStates": "Pressed"
                                      }
                                 }
                             ]
@@ -96,8 +96,8 @@ public class SettingsScopeTests
 
         // assert
         Assert.Equal (2, ThemeManager.GetThemes ().Count);
-        Assert.Equal (HighlightStyle.Pressed, (HighlightStyle)ThemeManager.Themes! [ThemeManager.DEFAULT_THEME_NAME] ["Button.DefaultHighlightStyle"].PropertyValue!);
-        Assert.Equal (HighlightStyle.Hover, (HighlightStyle)ThemeManager.Themes! ["NewTheme"] ["Button.DefaultHighlightStyle"].PropertyValue!);
+        Assert.Equal (MouseState.Pressed, (MouseState)ThemeManager.Themes! [ThemeManager.DEFAULT_THEME_NAME] ["Button.DefaultHighlightStates"].PropertyValue!);
+        Assert.Equal (MouseState.In, (MouseState)ThemeManager.Themes! ["NewTheme"] ["Button.DefaultHighlightStates"].PropertyValue!);
 
         // clean up
         Disable (resetToHardCodedDefaults: true);
@@ -272,11 +272,11 @@ public class SettingsScopeTests
         // Arrange: Create a ThemeScope and verify a property exists
         ThemeScope defaultThemeScope = new ThemeScope ();
         defaultThemeScope.LoadHardCodedDefaults ();
-        Assert.True (defaultThemeScope.ContainsKey ("Button.DefaultHighlightStyle"));
+        Assert.True (defaultThemeScope.ContainsKey ("Button.DefaultHighlightStates"));
 
         ThemeScope darkThemeScope = new ThemeScope ();
         darkThemeScope.LoadHardCodedDefaults ();
-        Assert.True (darkThemeScope.ContainsKey ("Button.DefaultHighlightStyle"));
+        Assert.True (darkThemeScope.ContainsKey ("Button.DefaultHighlightStates"));
 
         // Create a Themes list with two themes
         List<Dictionary<string, ThemeScope>> themesList =

Tests/UnitTests/Dialogs/WizardTests.cs

@@ -598,7 +598,7 @@ public class WizardTests ()
         Assert.Equal (string.Empty, r.Title);
 
         var expected = string.Empty;
-        r.TitleChanged += (s, args) => { Assert.Equal (r.Title, args.CurrentValue); };
+        r.TitleChanged += (s, args) => { Assert.Equal (r.Title, args.Value); };
 
         expected = "title";
         r.Title = expected;

Tests/UnitTests/View/Adornment/ShadowStyleTests.cs

@@ -144,7 +144,7 @@ public class ShadowStyleTests (ITestOutputHelper output)
             Width = Dim.Auto (),
             Height = Dim.Auto (),
             Text = "0123",
-            HighlightStyle = HighlightStyle.Pressed,
+            HighlightStates = MouseState.Pressed,
             ShadowStyle = style,
             CanFocus = true
         };

Tests/UnitTests/View/Mouse/MouseTests.cs

@@ -291,66 +291,54 @@ public class MouseTests : TestsAllViews
         Assert.Equal (2, clickedCount);
         me.Handled = false;
 
+        // Stay in Viewport
+        me.Flags = MouseFlags.Button1Pressed;
+        me.Position = me.Position with { X = 0 };
+        view.NewMouseEvent (me);
+        Assert.Equal (3, clickedCount);
+        me.Handled = false;
+
         view.Dispose ();
 
         // Button1Pressed, Button1Released cause Application.MouseGrabView to be set
         Application.ResetState (true);
     }
 
-    [Theory (Skip = "This test needs to be redone.")]
-    [InlineData (HighlightStyle.None, 0, 0)]
-    [InlineData (HighlightStyle.Pressed | HighlightStyle.PressedOutside, 1, 1)]
-    public void HighlightOnPress_Fires_Events_And_Highlights (HighlightStyle highlightOnPress, int expectedEnabling, int expectedDisabling)
-    {
-        var view = new View
-        {
-            CanFocus = true,
-            HighlightStyle = highlightOnPress,
-            Height = 1,
-            Width = 1
-        };
+    //[Theory]
+    //[InlineData (true, MouseState.None, 0, 0, 0, 0)]
+    //[InlineData (true, MouseState.In, 0, 0, 0, 0)]
+    //[InlineData (true, MouseState.Pressed, 0, 0, 1, 0)]
+    //[InlineData (true, MouseState.PressedOutside, 0, 0, 0, 1)]
+    //public void MouseState_Button1_Pressed_Then_Released_Outside (bool inViewport, MouseState highlightFlags, int noneCount, int expectedInCount, int expectedPressedCount, int expectedPressedOutsideCount)
+    //{
+    //    var testView = new MouseEventTestView
+    //    {
+    //        HighlightStates = highlightFlags
+    //    };
 
-        var enablingHighlight = 0;
-        var disablingHighlight = 0;
-        view.Highlight += ViewHighlight;
-        view.SetScheme (new (new Attribute (ColorName16.Red, ColorName16.Blue)));
-        Scheme originalScheme = view.GetScheme ();
+    //    Assert.Equal (0, testView.MouseStateInCount);
+    //    Assert.Equal (0, testView.MouseStatePressedCount);
+    //    Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+    //    Assert.Equal (0, testView.MouseStateNoneCount);
 
-        view.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed });
+    //    testView.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed, Position = new (inViewport ? 0 : 1, 0) });
+    //    Assert.Equal (expectedInCount, testView.MouseStateInCount);
+    //    Assert.Equal (expectedPressedCount, testView.MouseStatePressedCount);
+    //    Assert.Equal (expectedPressedOutsideCount, testView.MouseStatePressedOutsideCount);
+    //    Assert.Equal (noneCount, testView.MouseStateNoneCount);
 
-        if (highlightOnPress != HighlightStyle.None)
-        {
-            Assert.NotEqual (originalScheme, view.GetScheme ());
-        }
-        else
-        {
-            Assert.Equal (originalScheme, view.GetScheme ());
-        }
+    //    testView.NewMouseEvent (new () { Flags = MouseFlags.Button1Released, Position = new (inViewport ? 0 : 1, 0) });
+    //    Assert.Equal (expectedInCount, testView.MouseStateInCount);
+    //    Assert.Equal (expectedPressedCount, testView.MouseStatePressedCount);
+    //    Assert.Equal (expectedPressedOutsideCount, testView.MouseStatePressedOutsideCount);
+    //    Assert.Equal (noneCount, testView.MouseStateNoneCount);
 
-        view.NewMouseEvent (new () { Flags = MouseFlags.Button1Released });
-        Assert.Equal (originalScheme, view.GetScheme ());
-        Assert.Equal (expectedEnabling, enablingHighlight);
-        Assert.Equal (expectedDisabling, disablingHighlight);
+    //    testView.Dispose ();
 
-        view.Dispose ();
+    //    // Button1Pressed, Button1Released cause Application.MouseGrabView to be set
+    //    Application.ResetState (true);
 
-        // Button1Pressed, Button1Released cause Application.MouseGrabView to be set
-        Application.ResetState (true);
-
-        return;
-
-        void ViewHighlight (object sender, CancelEventArgs<HighlightStyle> e)
-        {
-            if (e.NewValue == HighlightStyle.None)
-            {
-                disablingHighlight++;
-            }
-            else
-            {
-                enablingHighlight++;
-            }
-        }
-    }
+    //}
 
     // TODO: Add tests for each combination of HighlightFlags
 
@@ -358,70 +346,298 @@ public class MouseTests : TestsAllViews
     [InlineData (0)]
     [InlineData (1)]
     [InlineData (10)]
-    public void HighlightOnPress_Move_Keeps_Highlight (int x)
+    public void MouseState_None_Button1_Pressed_Move_No_Changes (int x)
     {
-        var view = new View
+        var testView = new MouseEventTestView
         {
-            CanFocus = true,
-            HighlightStyle = HighlightStyle.Pressed | HighlightStyle.PressedOutside,
-            Height = 1,
-            Width = 1
+            HighlightStates = MouseState.None
         };
-        var enablingHighlight = 0;
-        var disablingHighlight = 0;
-        view.Highlight += ViewHighlight;
-        bool inViewport = view.Viewport.Contains (x, 0);
+
+        bool inViewport = testView.Viewport.Contains (x, 0);
 
         // Start at 0,0 ; in viewport
-        view.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed });
-        Assert.Equal (1, enablingHighlight);
-        Assert.Equal (0, disablingHighlight);
+        testView.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed });
+        Assert.Equal (0, testView.MouseStateInCount);
+        Assert.Equal (0, testView.MouseStatePressedCount);
+        Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+        Assert.Equal (0, testView.MouseStateNoneCount);
 
         // Move to x,0 
-        view.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed });
+        testView.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed, Position = new (x, 0) });
 
         if (inViewport)
         {
-            Assert.Equal (2, enablingHighlight);
-            Assert.Equal (0, disablingHighlight);
+            Assert.Equal (0, testView.MouseStateInCount);
+            Assert.Equal (0, testView.MouseStatePressedCount);
+            Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+            Assert.Equal (0, testView.MouseStateNoneCount);
         }
         else
         {
-            Assert.Equal (2, enablingHighlight);
-            Assert.Equal (0, disablingHighlight);
+            Assert.Equal (0, testView.MouseStateInCount);
+            Assert.Equal (0, testView.MouseStatePressedCount);
+            Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+            Assert.Equal (0, testView.MouseStateNoneCount);
         }
 
         // Move backto 0,0 ; in viewport
-        view.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed });
+        testView.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed });
 
         if (inViewport)
         {
-            Assert.Equal (3, enablingHighlight);
-            Assert.Equal (0, disablingHighlight);
+            Assert.Equal (0, testView.MouseStateInCount);
+            Assert.Equal (0, testView.MouseStatePressedCount);
+            Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+            Assert.Equal (0, testView.MouseStateNoneCount);
         }
         else
         {
-            Assert.Equal (3, enablingHighlight);
-            Assert.Equal (0, disablingHighlight);
+            Assert.Equal (0, testView.MouseStateInCount);
+            Assert.Equal (0, testView.MouseStatePressedCount);
+            Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+            Assert.Equal (0, testView.MouseStateNoneCount);
         }
 
-        view.Dispose ();
+        testView.Dispose ();
 
         // Button1Pressed, Button1Released cause Application.MouseGrabView to be set
         Application.ResetState (true);
+    }
 
-        return;
-
-        void ViewHighlight (object sender, CancelEventArgs<HighlightStyle> e)
+    [Theory]
+    [InlineData (0)]
+    [InlineData (1)]
+    [InlineData (10)]
+    public void MouseState_Pressed_Button1_Pressed_Move_Keeps_Pressed (int x)
+    {
+        var testView = new MouseEventTestView
         {
-            if (e.NewValue == HighlightStyle.None)
+            HighlightStates = MouseState.Pressed
+        };
+
+        bool inViewport = testView.Viewport.Contains (x, 0);
+
+        // Start at 0,0 ; in viewport
+        testView.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed });
+        Assert.Equal (0, testView.MouseStateInCount);
+        Assert.Equal (1, testView.MouseStatePressedCount);
+        Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+        Assert.Equal (0, testView.MouseStateNoneCount);
+
+        // Move to x,0 
+        testView.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed, Position = new (x, 0) });
+
+        if (inViewport)
+        {
+            Assert.Equal (0, testView.MouseStateInCount);
+            Assert.Equal (1, testView.MouseStatePressedCount);
+            Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+            Assert.Equal (0, testView.MouseStateNoneCount);
+        }
+        else
+        {
+            Assert.Equal (0, testView.MouseStateInCount);
+            Assert.Equal (1, testView.MouseStatePressedCount);
+            Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+            Assert.Equal (0, testView.MouseStateNoneCount);
+        }
+
+        // Move backto 0,0 ; in viewport
+        testView.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed });
+
+        if (inViewport)
+        {
+            Assert.Equal (0, testView.MouseStateInCount);
+            Assert.Equal (1, testView.MouseStatePressedCount);
+            Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+            Assert.Equal (0, testView.MouseStateNoneCount);
+        }
+        else
+        {
+            Assert.Equal (0, testView.MouseStateInCount);
+            Assert.Equal (1, testView.MouseStatePressedCount);
+            Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+            Assert.Equal (0, testView.MouseStateNoneCount);
+        }
+
+        testView.Dispose ();
+
+        // Button1Pressed, Button1Released cause Application.MouseGrabView to be set
+        Application.ResetState (true);
+    }
+
+    [Theory]
+    [InlineData (0)]
+    [InlineData (1)]
+    [InlineData (10)]
+    public void MouseState_PressedOutside_Button1_Pressed_Move_Raises_PressedOutside (int x)
+    {
+        var testView = new MouseEventTestView
+        {
+            HighlightStates = MouseState.PressedOutside,
+            WantContinuousButtonPressed = false
+        };
+
+        bool inViewport = testView.Viewport.Contains (x, 0);
+
+        // Start at 0,0 ; in viewport
+        testView.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed });
+        Assert.Equal (0, testView.MouseStateInCount);
+        Assert.Equal (0, testView.MouseStatePressedCount);
+        Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+        Assert.Equal (0, testView.MouseStateNoneCount);
+
+        // Move to x,0 
+        testView.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed, Position = new (x, 0) });
+
+        if (inViewport)
+        {
+            Assert.Equal (0, testView.MouseStateInCount);
+            Assert.Equal (0, testView.MouseStatePressedCount);
+            Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+            Assert.Equal (0, testView.MouseStateNoneCount);
+        }
+        else
+        {
+            Assert.Equal (0, testView.MouseStateInCount);
+            Assert.Equal (0, testView.MouseStatePressedCount);
+            Assert.Equal (1, testView.MouseStatePressedOutsideCount);
+            Assert.Equal (0, testView.MouseStateNoneCount);
+        }
+
+        // Move backto 0,0 ; in viewport
+        testView.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed });
+
+        if (inViewport)
+        {
+            Assert.Equal (0, testView.MouseStateInCount);
+            Assert.Equal (0, testView.MouseStatePressedCount);
+            Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+            Assert.Equal (0, testView.MouseStateNoneCount);
+        }
+        else
+        {
+            Assert.Equal (0, testView.MouseStateInCount);
+            Assert.Equal (0, testView.MouseStatePressedCount);
+            Assert.Equal (1, testView.MouseStatePressedOutsideCount);
+            Assert.Equal (1, testView.MouseStateNoneCount);
+        }
+
+        testView.Dispose ();
+
+        // Button1Pressed, Button1Released cause Application.MouseGrabView to be set
+        Application.ResetState (true);
+    }
+
+
+    [Theory]
+    [InlineData (0)]
+    [InlineData (1)]
+    [InlineData (10)]
+    public void MouseState_PressedOutside_Button1_Pressed_Move_Raises_PressedOutside_WantContinuousButtonPressed (int x)
+    {
+        var testView = new MouseEventTestView
+        {
+            HighlightStates = MouseState.PressedOutside,
+            WantContinuousButtonPressed = true
+        };
+
+        bool inViewport = testView.Viewport.Contains (x, 0);
+
+        // Start at 0,0 ; in viewport
+        testView.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed });
+        Assert.Equal (0, testView.MouseStateInCount);
+        Assert.Equal (0, testView.MouseStatePressedCount);
+        Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+        Assert.Equal (0, testView.MouseStateNoneCount);
+
+        // Move to x,0 
+        testView.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed, Position = new (x, 0) });
+
+        if (inViewport)
+        {
+            Assert.Equal (0, testView.MouseStateInCount);
+            Assert.Equal (0, testView.MouseStatePressedCount);
+            Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+            Assert.Equal (0, testView.MouseStateNoneCount);
+        }
+        else
+        {
+            Assert.Equal (0, testView.MouseStateInCount);
+            Assert.Equal (0, testView.MouseStatePressedCount);
+            Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+            Assert.Equal (0, testView.MouseStateNoneCount);
+        }
+
+        // Move backto 0,0 ; in viewport
+        testView.NewMouseEvent (new () { Flags = MouseFlags.Button1Pressed });
+
+        if (inViewport)
+        {
+            Assert.Equal (0, testView.MouseStateInCount);
+            Assert.Equal (0, testView.MouseStatePressedCount);
+            Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+            Assert.Equal (0, testView.MouseStateNoneCount);
+        }
+        else
+        {
+            Assert.Equal (0, testView.MouseStateInCount);
+            Assert.Equal (0, testView.MouseStatePressedCount);
+            Assert.Equal (0, testView.MouseStatePressedOutsideCount);
+            Assert.Equal (0, testView.MouseStateNoneCount);
+        }
+
+        testView.Dispose ();
+
+        // Button1Pressed, Button1Released cause Application.MouseGrabView to be set
+        Application.ResetState (true);
+    }
+    private class MouseEventTestView : View
+    {
+        public int MouseEnterCount { get; private set; }
+        public int MouseLeaveCount { get; private set; }
+        public int MouseStatePressedOutsideCount { get; private set; }
+        public int MouseStateInCount { get; private set; }
+        public int MouseStatePressedCount { get; private set; }
+        public int MouseStateNoneCount { get; private set; }
+
+        public MouseEventTestView ()
+        {
+            Height = 1;
+            Width = 1;
+            CanFocus = true;
+            Id = "mouseEventTestView";
+
+            MouseLeave += (s, e) => { MouseEnterCount++; };
+            MouseEnter += (s, e) => { MouseLeaveCount++; };
+        }
+
+        /// <inheritdoc/>
+        protected override void OnMouseStateChanged (EventArgs<MouseState> args)
+        {
+            switch (args.Value)
             {
-                disablingHighlight++;
-            }
-            else
-            {
-                enablingHighlight++;
+                case MouseState.None:
+                    MouseStateNoneCount++;
+
+                    break;
+                case MouseState.In:
+                    MouseStateInCount++;
+
+                    break;
+
+                case MouseState.Pressed:
+                    MouseStatePressedCount++;
+
+                    break;
+
+                case MouseState.PressedOutside:
+                    MouseStatePressedOutsideCount++;
+
+                    break;
             }
+
+            base.OnMouseStateChanged (args);
         }
     }
 }

Tests/UnitTests/Views/CheckBoxTests.cs

@@ -623,10 +623,10 @@ public class CheckBoxTests (ITestOutputHelper output)
 
         return;
 
-        void OnCheckedStateChanging (object sender, CancelEventArgs e)
+        void OnCheckedStateChanging (object sender, ResultEventArgs<CheckState> e)
         {
             checkedInvoked = true;
-            e.Cancel = true;
+            e.Handled = true;
         }
     }
 }

Tests/UnitTests/Views/ColorPickerTests.cs

@@ -16,9 +16,9 @@ public class ColorPickerTests
         cp.ColorChanged += (s, e) =>
                            {
                                count++;
-                               newColor = e.CurrentValue;
+                               newColor = e.Result;
 
-                               Assert.Equal (cp.SelectedColor, e.CurrentValue);
+                               Assert.Equal (cp.SelectedColor, e.Result);
                            };
 
         cp.SelectedColor = new (1, 2, 3);

Tests/UnitTests/Views/TextFieldTests.cs

@@ -348,11 +348,11 @@ public class TextFieldTests (ITestOutputHelper output)
 
         _textField.TextChanging += TextFieldTextChanging;
 
-        void TextFieldTextChanging (object sender, CancelEventArgs<string> e)
+        void TextFieldTextChanging (object sender, ResultEventArgs<string> e)
         {
-            if (e.NewValue.GetRuneCount () > 11)
+            if (e.Result.GetRuneCount () > 11)
             {
-                e.NewValue = e.NewValue [..11];
+                e.Result = e.Result [..11];
             }
         }
 
@@ -416,8 +416,8 @@ public class TextFieldTests (ITestOutputHelper output)
 
         tf.TextChanging += (s, e) =>
                            {
-                               newText = e.NewValue;
-                               oldText = e.CurrentValue;
+                               newText = e.Result;
+                               oldText = tf.Text;
                            };
 
         var top = new Toplevel ();
@@ -957,11 +957,11 @@ public class TextFieldTests (ITestOutputHelper output)
 
         _textField.TextChanging += (s, e) =>
                                    {
-                                       Assert.Equal ("changing", e.NewValue);
+                                       Assert.Equal ("changing", e.Result);
 
                                        if (cancel)
                                        {
-                                           e.Cancel = true;
+                                           e.Handled = true;
                                        }
                                    };
 

Tests/UnitTestsParallelizable/Application/CWP/ResultEventArgsTests.cs

@@ -0,0 +1,342 @@
+#nullable enable
+using System;
+using Terminal.Gui.App;
+using Xunit;
+
+public class ResultEventArgsTests
+{
+    [Fact]
+    public void DefaultConstructor_InitializesProperties ()
+    {
+        var args = new ResultEventArgs<string> ();
+
+        Assert.Null (args.Result);
+        Assert.False (args.Handled);
+    }
+
+    [Fact]
+    public void Constructor_WithResult_SetsResult ()
+    {
+        var args = new ResultEventArgs<int> (42);
+
+        Assert.Equal (42, args.Result);
+        Assert.False (args.Handled);
+    }
+
+    [Fact]
+    public void Constructor_WithNullResult_AllowsNull ()
+    {
+        var args = new ResultEventArgs<string?> (null);
+
+        Assert.Null (args.Result);
+        Assert.False (args.Handled);
+    }
+
+    [Fact]
+    public void Result_CanBeSetAndRetrieved ()
+    {
+        var args = new ResultEventArgs<string> ();
+        args.Result = "foo";
+
+        Assert.Equal ("foo", args.Result);
+
+        args.Result = null;
+        Assert.Null (args.Result);
+    }
+
+    [Fact]
+    public void Handled_CanBeSetAndRetrieved ()
+    {
+        var args = new ResultEventArgs<object> ();
+        Assert.False (args.Handled);
+
+        args.Handled = true;
+        Assert.True (args.Handled);
+
+        args.Handled = false;
+        Assert.False (args.Handled);
+    }
+
+    [Fact]
+    public void WorksWithValueTypes ()
+    {
+        var args = new ResultEventArgs<int> ();
+        Assert.Equal (0, args.Result); // default(int) is 0
+
+        args.Result = 123;
+        Assert.Equal (123, args.Result);
+    }
+
+    [Fact]
+    public void WorksWithReferenceTypes ()
+    {
+        var obj = new object ();
+        var args = new ResultEventArgs<object> (obj);
+
+        Assert.Same (obj, args.Result);
+
+        args.Result = null;
+        Assert.Null (args.Result);
+    }
+
+    // Simulate an event pattern
+    public event EventHandler<ResultEventArgs<string>>? StringResultEvent;
+
+    [Fact]
+    public void EventHandler_CanChangeResult_AndCallerSeesChange ()
+    {
+        // Arrange
+        var args = new ResultEventArgs<string> ("initial");
+        StringResultEvent += (sender, e) =>
+                             {
+                                 // Handler changes the result
+                                 e.Result = "changed by handler";
+                             };
+
+        // Act
+        StringResultEvent?.Invoke (this, args);
+
+        // Assert
+        Assert.Equal ("changed by handler", args.Result);
+    }
+
+
+
+    [Fact]
+    public void EventHandler_CanSetResultToNull ()
+    {
+        // Arrange
+        var args = new ResultEventArgs<string> ("not null");
+        StringResultEvent += (sender, e) =>
+                             {
+                                 e.Result = null;
+                             };
+
+        // Act
+        StringResultEvent?.Invoke (this, args);
+
+        // Assert
+        Assert.Null (args.Result);
+    }
+
+    [Fact]
+    public void MultipleHandlers_LastHandlerWins ()
+    {
+        // Arrange
+        var args = new ResultEventArgs<int> (1);
+        EventHandler<ResultEventArgs<int>>? intEvent = null;
+        intEvent += (s, e) => e.Result = 2;
+        intEvent += (s, e) => e.Result = 3;
+
+        // Act
+        intEvent?.Invoke (this, args);
+
+        // Assert
+        Assert.Equal (3, args.Result);
+    }
+
+    // Value type: int
+    [Fact]
+    public void EventHandler_CanChangeResult_Int ()
+    {
+        EventHandler<ResultEventArgs<int>> handler = (s, e) => e.Result = 99;
+        var args = new ResultEventArgs<int> (1);
+        handler.Invoke (this, args);
+        Assert.Equal (99, args.Result);
+    }
+
+    // Value type: double
+    [Fact]
+    public void EventHandler_CanChangeResult_Double ()
+    {
+        EventHandler<ResultEventArgs<double>> handler = (s, e) => e.Result = 2.718;
+        var args = new ResultEventArgs<double> (3.14);
+        handler.Invoke (this, args);
+        Assert.Equal (2.718, args.Result);
+    }
+
+    // Value type: bool
+    [Fact]
+    public void EventHandler_CanChangeResult_Bool ()
+    {
+        EventHandler<ResultEventArgs<bool>> handler = (s, e) => e.Result = false;
+        var args = new ResultEventArgs<bool> (true);
+        handler.Invoke (this, args);
+        Assert.False (args.Result);
+    }
+
+    // Enum
+    enum MyEnum { A, B, C }
+    [Fact]
+    public void EventHandler_CanChangeResult_Enum ()
+    {
+        EventHandler<ResultEventArgs<MyEnum>> handler = (s, e) => e.Result = MyEnum.C;
+        var args = new ResultEventArgs<MyEnum> (MyEnum.A);
+        handler.Invoke (this, args);
+        Assert.Equal (MyEnum.C, args.Result);
+    }
+
+    // Struct
+    struct MyStruct { public int X; }
+    [Fact]
+    public void EventHandler_CanChangeResult_Struct ()
+    {
+        EventHandler<ResultEventArgs<MyStruct>> handler = (s, e) => e.Result = new MyStruct { X = 42 };
+        var args = new ResultEventArgs<MyStruct> (new MyStruct { X = 1 });
+        handler.Invoke (this, args);
+        Assert.Equal (42, args.Result.X);
+    }
+
+    // Reference type: string
+    [Fact]
+    public void EventHandler_CanChangeResult_String ()
+    {
+        EventHandler<ResultEventArgs<string>> handler = (s, e) => e.Result = "changed";
+        var args = new ResultEventArgs<string> ("original");
+        handler.Invoke (this, args);
+        Assert.Equal ("changed", args.Result);
+    }
+
+    // Reference type: object
+    [Fact]
+    public void EventHandler_CanChangeResult_Object ()
+    {
+        var newObj = new object ();
+        EventHandler<ResultEventArgs<object>> handler = (s, e) => e.Result = newObj;
+        var args = new ResultEventArgs<object> (new object ());
+        handler.Invoke (this, args);
+        Assert.Same (newObj, args.Result);
+    }
+
+    // Nullable value type
+    [Fact]
+    public void EventHandler_CanChangeResult_NullableInt ()
+    {
+        EventHandler<ResultEventArgs<int?>> handler = (s, e) => e.Result = null;
+        var args = new ResultEventArgs<int?> (42);
+        handler.Invoke (this, args);
+        Assert.Null (args.Result);
+    }
+
+    // Array
+    [Fact]
+    public void EventHandler_CanChangeResult_Array ()
+    {
+        var newArr = new [] { "x", "y" };
+        EventHandler<ResultEventArgs<string []>> handler = (s, e) => e.Result = newArr;
+        var args = new ResultEventArgs<string []> (new [] { "a", "b" });
+        handler.Invoke (this, args);
+        Assert.Equal (newArr, args.Result);
+    }
+
+    // List<T>
+    [Fact]
+    public void EventHandler_CanChangeResult_List ()
+    {
+        var newList = new List<int> { 1, 2, 3 };
+        EventHandler<ResultEventArgs<List<int>>> handler = (s, e) => e.Result = newList;
+        var args = new ResultEventArgs<List<int>> (new List<int> { 9 });
+        handler.Invoke (this, args);
+        Assert.Equal (newList, args.Result);
+    }
+
+    // Dictionary<K,V>
+    [Fact]
+    public void EventHandler_CanChangeResult_Dictionary ()
+    {
+        var newDict = new Dictionary<string, int> { ["a"] = 1 };
+        EventHandler<ResultEventArgs<Dictionary<string, int>>> handler = (s, e) => e.Result = newDict;
+        var args = new ResultEventArgs<Dictionary<string, int>> (new Dictionary<string, int> ());
+        handler.Invoke (this, args);
+        Assert.Equal (newDict, args.Result);
+    }
+
+    // Record
+    public record MyRecord (int Id, string Name);
+    [Fact]
+    public void EventHandler_CanChangeResult_Record ()
+    {
+        var rec = new MyRecord (1, "foo");
+        EventHandler<ResultEventArgs<MyRecord>> handler = (s, e) => e.Result = rec;
+        var args = new ResultEventArgs<MyRecord> (null);
+        handler.Invoke (this, args);
+        Assert.Equal (rec, args.Result);
+    }
+
+    // Nullable int
+    [Fact]
+    public void EventHandler_CanChangeResult_NullableInt_ToValue_AndNull ()
+    {
+        EventHandler<ResultEventArgs<int?>> handler = (s, e) => e.Result = 123;
+        var args = new ResultEventArgs<int?> (null);
+        handler.Invoke (this, args);
+        Assert.Equal (123, args.Result);
+
+        handler = (s, e) => e.Result = null;
+        args = new ResultEventArgs<int?> (456);
+        handler.Invoke (this, args);
+        Assert.Null (args.Result);
+    }
+
+    // Nullable double
+    [Fact]
+    public void EventHandler_CanChangeResult_NullableDouble_ToValue_AndNull ()
+    {
+        EventHandler<ResultEventArgs<double?>> handler = (s, e) => e.Result = 3.14;
+        var args = new ResultEventArgs<double?> (null);
+        handler.Invoke (this, args);
+        Assert.Equal (3.14, args.Result);
+
+        handler = (s, e) => e.Result = null;
+        args = new ResultEventArgs<double?> (2.71);
+        handler.Invoke (this, args);
+        Assert.Null (args.Result);
+    }
+
+    // Nullable custom struct
+    [Fact]
+    public void EventHandler_CanChangeResult_NullableStruct_ToValue_AndNull ()
+    {
+        EventHandler<ResultEventArgs<MyStruct?>> handler = (s, e) => e.Result = new MyStruct { X = 7 };
+        var args = new ResultEventArgs<MyStruct?> (null);
+        handler.Invoke (this, args);
+        Assert.Equal (7, args.Result?.X);
+
+        handler = (s, e) => e.Result = null;
+        args = new ResultEventArgs<MyStruct?> (new MyStruct { X = 8 });
+        handler.Invoke (this, args);
+        Assert.Null (args.Result);
+    }
+
+    // Nullable string (reference type)
+    [Fact]
+    public void EventHandler_CanChangeResult_NullableString_ToValue_AndNull ()
+    {
+        EventHandler<ResultEventArgs<string?>> handler = (s, e) => e.Result = "hello";
+        var args = new ResultEventArgs<string?> (null);
+        handler.Invoke (this, args);
+        Assert.Equal ("hello", args.Result);
+
+        handler = (s, e) => e.Result = null;
+        args = new ResultEventArgs<string?> ("world");
+        handler.Invoke (this, args);
+        Assert.Null (args.Result);
+    }
+
+    // Nullable custom class
+    class MyClass { public int Y { get; set; } }
+    [Fact]
+    public void EventHandler_CanChangeResult_NullableClass_ToValue_AndNull ()
+    {
+        EventHandler<ResultEventArgs<MyClass?>> handler = (s, e) => e.Result = new MyClass { Y = 42 };
+        var args = new ResultEventArgs<MyClass?> (null);
+        handler.Invoke (this, args);
+        Assert.NotNull (args.Result);
+        Assert.Equal (42, args.Result?.Y);
+
+        handler = (s, e) => e.Result = null;
+        args = new ResultEventArgs<MyClass?> (new MyClass { Y = 99 });
+        handler.Invoke (this, args);
+        Assert.Null (args.Result);
+    }
+}

Tests/UnitTestsParallelizable/View/Adornment/AdornmentTests.cs

@@ -1,8 +1,63 @@
-namespace Terminal.Gui.ViewTests;
+#nullable enable
+namespace Terminal.Gui.ViewTests;
 
 [Collection ("Global Test Setup")]
 public class AdornmentTests
 {
+    //private class TestView : View
+    //{
+    //    public bool BorderDrawn { get; set; }
+    //    public bool PaddingDrawn { get; set; }
+
+    //    /// <inheritdoc />
+    //    protected override bool OnDrawingContent () 
+    //    {
+    //        if (Border is { } && Border.Thickness != Thickness.Empty)
+    //        {
+    //            BorderDrawn = true;
+    //            Border.Draw ();
+    //        }
+    //        if (Padding is { } && Padding.Thickness != Thickness.Empty)
+    //        {
+    //            PaddingDrawn = true;
+    //            Padding.Draw ();
+    //        }
+
+    //        return base.OnDrawingContent ();
+    //    }
+    //}
+
+    //[Fact]
+    //public void DrawAdornments_UsesCWPEventHelper ()
+    //{
+    //    var view = new TestView
+    //    {
+    //        Id = "view"
+    //    };
+    //    view.Border!.Thickness = new Thickness (1);
+    //    view.Padding!.Thickness = new Thickness (1);
+
+    //    // Test cancellation
+    //    view.DrawingAdornments += OnDrawingAdornmentsHandled;
+    //    view.DoDrawAdornments (originalClip: null);
+    //    Assert.False (view.BorderDrawn);
+    //    Assert.False (view.PaddingDrawn);
+    //    view.DrawingAdornments -= OnDrawingAdornmentsHandled;
+
+    //    // Test successful drawing
+    //    view.DrawingAdornments += OnDrawingAdornmentsAssert;
+    //    view.BorderDrawn = false;
+    //    view.PaddingDrawn = false;
+    //    view.DoDrawAdornments (originalClip: null);
+    //    Assert.True (view.BorderDrawn);
+    //    Assert.True (view.PaddingDrawn);
+
+    //    view.Dispose ();
+
+    //    void OnDrawingAdornmentsHandled (object? sender, DrawAdornmentsEventArgs args) => args.Handled = true;
+    //    void OnDrawingAdornmentsAssert (object? sender, DrawAdornmentsEventArgs args) => Assert.Null (args.Context);
+    //}
+
     [Fact]
     public void Viewport_Location_Always_Empty_Size_Correct ()
     {

Tests/UnitTestsParallelizable/View/Adornment/ShadowStyletests.cs

@@ -44,7 +44,7 @@ public class ShadowStyleTests
             Width = Dim.Auto (),
             Height = Dim.Auto (),
             Text = "0123",
-            HighlightStyle = HighlightStyle.Pressed,
+            HighlightStates = MouseState.Pressed,
             ShadowStyle = style,
             CanFocus = true
         };

Tests/UnitTestsParallelizable/View/SchemeTests.cs

@@ -139,15 +139,17 @@ public class SchemeTests
     public void GettingScheme_Event_CanOverrideScheme ()
     {
         var view = new View ();
-        var customScheme = SchemeManager.GetHardCodedSchemes ()? ["Error"];
+        var customScheme = SchemeManager.GetHardCodedSchemes ()? ["Error"]! with { Normal = Attribute.Default };
 
+        Assert.NotEqual (Attribute.Default, view.GetScheme ().Normal);
         view.GettingScheme += (sender, args) =>
-        {
-            args.NewScheme = customScheme;
-            args.Cancel = true;
-        };
+                              {
+                                  args.Result = customScheme;
+                                  args.Handled = true;
+                              };
 
         Assert.Equal (customScheme, view.GetScheme ());
+        Assert.Equal (Attribute.Default, view.GetScheme ().Normal);
         view.Dispose ();
     }
 
@@ -157,7 +159,7 @@ public class SchemeTests
         var view = new View ();
         var dialogScheme = SchemeManager.GetHardCodedSchemes ()? ["Dialog"];
 
-        view.SettingScheme += (sender, args) => args.Cancel = true;
+        view.SchemeChanging += (sender, args) => args.Handled = true;
 
         view.SetScheme (dialogScheme);
 
@@ -175,8 +177,8 @@ public class SchemeTests
         {
             if (args.Role == VisualRole.Focus)
             {
-                args.NewValue = customAttribute;
-                args.Cancel = true;
+                args.Result = customAttribute;
+                args.Handled = true;
             }
         };
 
@@ -208,7 +210,7 @@ public class SchemeTests
         subView.SchemeName = "Error";
 
         var errorScheme = SchemeManager.GetHardCodedSchemes ()? ["Error"];
-        Assert.Equal (errorScheme, subView.GetScheme());
+        Assert.Equal (errorScheme, subView.GetScheme ());
 
         subView.Dispose ();
         superView.Dispose ();
@@ -220,7 +222,7 @@ public class SchemeTests
         var view = new View ();
         var baseScheme = SchemeManager.GetHardCodedSchemes ()? ["Base"];
 
-        Assert.Equal (baseScheme, view.GetScheme());
+        Assert.Equal (baseScheme, view.GetScheme ());
         view.Dispose ();
     }
 
@@ -231,7 +233,7 @@ public class SchemeTests
         view.SchemeName = "Dialog";
 
         var dialogScheme = SchemeManager.GetHardCodedSchemes ()? ["Dialog"];
-        Assert.Equal (dialogScheme, view.GetScheme());
+        Assert.Equal (dialogScheme, view.GetScheme ());
 
         view.Dispose ();
     }
@@ -244,7 +246,7 @@ public class SchemeTests
             return true;
         }
 
-        protected override bool OnSettingScheme (in Scheme? scheme)
+        protected override bool OnSettingScheme (ValueChangingEventArgs<Scheme?> args)
         {
             return true; // Prevent setting the scheme
         }

Tests/UnitTestsParallelizable/View/TitleTests.cs

@@ -18,7 +18,7 @@ public class TitleTests
 
         r.TitleChanged += (s, args) =>
                           {
-                              Assert.Equal (r.Title, args.CurrentValue);
+                              Assert.Equal (r.Title, args.Value);
                           };
 
         expected = "title";

Tests/UnitTestsParallelizable/Views/TextFieldTests.cs

@@ -13,7 +13,7 @@ public class TextFieldTests
         Assert.Equal ("A", tf.Text);
 
         // cancel the next keystroke
-        tf.TextChanging += (s, e) => e.Cancel = e.NewValue == "AB";
+        tf.TextChanging += (s, e) => e.Handled = e.Result == "AB";
         tf.NewKeyDownEvent (Key.B.WithShift);
 
         // B was canceled so should just be A