Fixes #3691 - Adds ViewArrangement.Popover (#3852)

* Added Applicaton.Popover.
Refactored FindDeepestView

* Popover prototype

* Testing highlight

* Fixed click outside issue

* Fixed DialogTests

* Fixed click outside issue (agbain)

* Enabled mouse wheel in Bar

* Enabled mouse wheel in Bar

* Progress. Broke arrangement

* Added popover tests.
Fixed a bunch more CM issues related ot unreliable unit tests.
Updated config.json to include Glyphs.

* Can't set ForceDriver to empty in Resources/config.json.

* added BUGBUG

* Made Position/ScreenPosition clear

* Added View.IsInHierarchy tests

* Added Contextmenuv2 scenario.

* Implemented CM2 in TextView

* Removed unneeded CM stuff from testhelpers

* Shortcut API docs

* Fixed keybinding unit tests

* Fixed mouse handling

* Fighting with CM related unit test failures

* Unit tests pass. I think.

* Shortcut code cleanup

* TextView uses new CM2

* Starting on OnSelect etc...

* Starting on OnSelect etc...

* Fixed ContextMenuv2

* ContextMenu is working again.

* Ugh. ANd fixed button api docs

* Fixed DrawHorizontalShadowTransparent (vertical was already fixed).

* Made Scenarios compatible with #nullable enable

* Undid some keybinding stuff

* Fixed stuff

* Sped up unit tests

* Sped up unit tests 2

* Sped up unit tests 3

* Messing with menus

* merged latest v2_develop

* Added more Popover unit tests

* Added more Popover unit tests2

* Fixed positioning bug

* Fixed mouse bug

* Fixed Bar draw issue

* WIP

* merge v2_develop

* CM2 sorta works

* Enabled Bar subclasses to have IDesignable

* Added ViewportSettings.Transparent

* Region -> nullable enable

* Added ViewportSettigs Editor

* merged v2_develop part 2

* merged v2_develop part 3

* WIP: GetViewsUnderMouse

* WIP: More GetViewsUnderMouse work

* Bars works again

* Added unit tests

* CM now works

* MenuItemv2 POC

* SubMenu POC

* CommandNotBound

* More POC

* Optimize Margin to not defer draw if there's no shadow

* Logger cleanup

* Reverted Generic

* Cascading mostly working

* fixed layout bug

* API docs

* API docs

* Fixed cascade

* Events basically work

* code cleanup

* Fixed IsDefault bug;

* Enabled hotkey support

* Made context-menu-like

* Improved usability

* Refactored ApplicationPopover again

* Cleanup

* Menuv2 POC basically complete

* Code Cleanup

* Made menu API simpler

* Fixed Strings bugs

* Got old ContextMenu scenario mostly working

* ContextMenu scenario now works

* ContextMenu fixes

* ContextMenu fixes

* Tons of menu cleanup

* ContextMenu works in TextView

* Fixed unit tes

* Added unit tests

* Fixed tests

* code cleanup

* More code cleanup

* Deep dive

* scenario

* typos

* Demo colorpicker in a Menu

* Added Region tests proving Region is broken in some Union cases

* fixed v2win/net

Tests/UnitTestsParallelizable/Application/ApplicationPopoverTests.cs

@@ -0,0 +1,163 @@
+using Moq;
+
+namespace Terminal.Gui.ApplicationTests;
+
+public class ApplicationPopoverTests
+{
+    [Fact]
+    public void Register_AddsPopover ()
+    {
+        // Arrange
+        var popover = new Mock<IPopover> ().Object;
+        var popoverManager = new ApplicationPopover ();
+
+        // Act
+        popoverManager.Register (popover);
+
+        // Assert
+        Assert.Contains (popover, popoverManager.Popovers);
+    }
+
+    [Fact]
+    public void DeRegister_RemovesPopover ()
+    {
+        // Arrange
+        var popover = new Mock<IPopover> ().Object;
+        var popoverManager = new ApplicationPopover ();
+        popoverManager.Register (popover);
+
+        // Act
+        var result = popoverManager.DeRegister (popover);
+
+        // Assert
+        Assert.True (result);
+        Assert.DoesNotContain (popover, popoverManager.Popovers);
+    }
+
+    [Fact]
+    public void ShowPopover_SetsActivePopover ()
+    {
+        // Arrange
+        var popover = new Mock<IPopoverTestClass> ().Object;
+        var popoverManager = new ApplicationPopover ();
+
+        // Act
+        popoverManager.ShowPopover (popover);
+
+        // Assert
+        Assert.Equal (popover, popoverManager.GetActivePopover ());
+    }
+
+    [Fact]
+    public void HidePopover_ClearsActivePopover ()
+    {
+        // Arrange
+        var popover = new Mock<IPopover> ().Object;
+        var popoverManager = new ApplicationPopover ();
+        popoverManager.ShowPopover (popover);
+
+        // Act
+        popoverManager.HidePopover (popover);
+
+        // Assert
+        Assert.Null (popoverManager.GetActivePopover ());
+    }
+
+
+    [Fact]
+    public void DispatchKeyDown_ActivePopoverGetsKey ()
+    {
+        // Arrange
+        var popover = new IPopoverTestClass ();
+        var popoverManager = new ApplicationPopover ();
+        popoverManager.ShowPopover (popover);
+
+        // Act
+        popoverManager.DispatchKeyDown (Key.A);
+
+        // Assert
+        Assert.Contains (KeyCode.A, popover.HandledKeys);
+    }
+
+
+    [Fact]
+    public void DispatchKeyDown_ActivePopoverGetsHotKey ()
+    {
+        // Arrange
+        var popover = new IPopoverTestClass ();
+        var popoverManager = new ApplicationPopover ();
+        popoverManager.ShowPopover (popover);
+
+        // Act
+        popoverManager.DispatchKeyDown (Key.N.WithCtrl);
+
+        // Assert
+        Assert.Equal(1, popover.NewCommandInvokeCount);
+        Assert.Contains (Key.N.WithCtrl, popover.HandledKeys);
+    }
+
+
+    [Fact]
+    public void DispatchKeyDown_InactivePopoverGetsHotKey ()
+    {
+        // Arrange
+        var activePopover = new IPopoverTestClass () { Id = "activePopover" };
+        var inactivePopover = new IPopoverTestClass () { Id = "inactivePopover" }; ;
+        var popoverManager = new ApplicationPopover ();
+        popoverManager.ShowPopover (activePopover);
+        popoverManager.Register (inactivePopover);
+
+        // Act
+        popoverManager.DispatchKeyDown (Key.N.WithCtrl);
+
+        // Assert
+        Assert.Equal (1, activePopover.NewCommandInvokeCount);
+        Assert.Equal (1, inactivePopover.NewCommandInvokeCount);
+        Assert.Contains (Key.N.WithCtrl, activePopover.HandledKeys);
+        Assert.NotEmpty (inactivePopover.HandledKeys);
+    }
+
+    [Fact]
+    public void DispatchKeyDown_InactivePopoverDoesGetKey ()
+    {
+        // Arrange
+        var activePopover = new IPopoverTestClass ();
+        var inactivePopover = new IPopoverTestClass ();
+        var popoverManager = new ApplicationPopover ();
+        popoverManager.ShowPopover (activePopover);
+        popoverManager.Register (inactivePopover);
+
+        // Act
+        popoverManager.DispatchKeyDown (Key.A);
+
+        // Assert
+        Assert.Contains (Key.A, activePopover.HandledKeys);
+        Assert.NotEmpty (inactivePopover.HandledKeys);
+    }
+    
+    public class IPopoverTestClass : View, IPopover
+    {
+        public List<Key> HandledKeys { get; } = new List<Key> ();
+        public int NewCommandInvokeCount { get; private set; }
+
+        public IPopoverTestClass ()
+        {
+            CanFocus = true;
+            AddCommand(Command.New, NewCommandHandler );
+            HotKeyBindings.Add (Key.N.WithCtrl, Command.New);
+
+            bool? NewCommandHandler (ICommandContext ctx)
+            {
+                NewCommandInvokeCount++;
+
+                return false;
+            }
+        }
+
+        protected override bool OnKeyDown (Key key)
+        {
+            HandledKeys.Add (key);
+            return false;
+        }
+    }
+}

Tests/UnitTestsParallelizable/Drawing/DrawContextTests.cs

@@ -0,0 +1,20 @@
+namespace Terminal.Gui.DrawingTests;
+
+public class DrawContextTests
+{
+    [Fact (Skip = "Region Union is broken")]
+    public void AddDrawnRectangle_Unions ()
+    {
+        DrawContext drawContext = new DrawContext ();
+
+        drawContext.AddDrawnRectangle (new (0, 0, 1, 1));
+        drawContext.AddDrawnRectangle (new (1, 0, 1, 1));
+
+        Assert.Equal (new Rectangle (0, 0, 2, 1), drawContext.GetDrawnRegion ().GetBounds ());
+        Assert.Equal (2, drawContext.GetDrawnRegion ().GetRectangles ().Length);
+
+        drawContext.AddDrawnRectangle (new (0, 0, 4, 1));
+        Assert.Equal (new Rectangle (0, 1, 4, 1), drawContext.GetDrawnRegion ().GetBounds ());
+        Assert.Single (drawContext.GetDrawnRegion ().GetRectangles ());
+    }
+}

Tests/UnitTestsParallelizable/Drawing/Region/RegionTests.cs

@@ -783,6 +783,46 @@ public class RegionTests
         Assert.True (region1.Contains (40, 40));
     }
 
+    [Fact (Skip = "Union is broken")]
+    public void Union_Third_Rect_Covering_Two_Disjoint_Merges ()
+    {
+        var origRegion = new Region ();
+
+        var region1 = new Region (new (0, 0, 1, 1));
+        var region2 = new Region (new (1, 0, 1, 1));
+
+        origRegion.Union(region1);
+        origRegion.Union(region2);
+
+        Assert.Equal (new Rectangle (0, 0, 2, 1), origRegion.GetBounds ());
+        Assert.Equal (2, origRegion.GetRectangles ().Length);
+
+        origRegion.Union(new Region(new (0, 0, 4, 1)));
+
+        Assert.Equal (new Rectangle (0, 1, 4, 1), origRegion.GetBounds ());
+        Assert.Single (origRegion.GetRectangles ());
+    }
+
+    [Fact (Skip = "MinimalUnion is broken")]
+    public void MinimalUnion_Third_Rect_Covering_Two_Disjoint_Merges ()
+    {
+        var origRegion = new Region ();
+
+        var region1 = new Region (new (0, 0, 1, 1));
+        var region2 = new Region (new (1, 0, 1, 1));
+
+        origRegion.Union (region1);
+        origRegion.Union (region2);
+
+        Assert.Equal (new Rectangle (0, 0, 2, 1), origRegion.GetBounds ());
+        Assert.Equal (2, origRegion.GetRectangles ().Length);
+
+        origRegion.MinimalUnion (new Region (new (0, 0, 4, 1)));
+
+        Assert.Equal (new Rectangle (0, 1, 4, 1), origRegion.GetBounds ());
+        Assert.Single (origRegion.GetRectangles ());
+    }
+
     /// <summary>
     ///     Proves MergeRegion does not overly combine regions.
     /// </summary>

Tests/UnitTestsParallelizable/View/ViewCommandTests.cs

@@ -226,10 +226,52 @@ public class ViewCommandTests
 
     #endregion OnHotKey/HotKey tests
 
+    #region InvokeCommand Tests
+
+
+    [Fact]
+    public void InvokeCommand_NotBound_Invokes_CommandNotBound ()
+    {
+        ViewEventTester view = new ();
+
+        view.InvokeCommand (Command.NotBound);
+
+        Assert.False (view.HasFocus);
+        Assert.Equal (1, view.OnCommandNotBoundCount);
+        Assert.Equal (1, view.CommandNotBoundCount);
+    }
+
+    [Fact]
+    public void InvokeCommand_Command_Not_Bound_Invokes_CommandNotBound ()
+    {
+        ViewEventTester view = new ();
+
+        view.InvokeCommand (Command.New);
+
+        Assert.False (view.HasFocus);
+        Assert.Equal (1, view.OnCommandNotBoundCount);
+        Assert.Equal (1, view.CommandNotBoundCount);
+    }
+
+    [Fact]
+    public void InvokeCommand_Command_Bound_Does_Not_Invoke_CommandNotBound ()
+    {
+        ViewEventTester view = new ();
+
+        view.InvokeCommand (Command.Accept);
+
+        Assert.False (view.HasFocus);
+        Assert.Equal (0, view.OnCommandNotBoundCount);
+        Assert.Equal (0, view.CommandNotBoundCount);
+    }
+
+    #endregion
+
     public class ViewEventTester : View
     {
         public ViewEventTester ()
         {
+            Id = "viewEventTester";
             CanFocus = true;
 
             Accepting += (s, a) =>
@@ -249,6 +291,12 @@ public class ViewCommandTests
                              a.Cancel = HandleSelecting;
                              SelectingCount++;
                          };
+
+            CommandNotBound += (s, a) =>
+                               {
+                                   a.Cancel = HandleCommandNotBound;
+                                   CommandNotBoundCount++;
+                               };
         }
 
         public int OnAcceptedCount { get; set; }
@@ -282,6 +330,8 @@ public class ViewCommandTests
         public int OnSelectingCount { get; set; }
         public int SelectingCount { get; set; }
         public bool HandleOnSelecting { get; set; }
+        public bool HandleSelecting { get; set; }
+
 
         /// <inheritdoc/>
         protected override bool OnSelecting (CommandEventArgs args)
@@ -291,6 +341,17 @@ public class ViewCommandTests
             return HandleOnSelecting;
         }
 
-        public bool HandleSelecting { get; set; }
+        public int OnCommandNotBoundCount { get; set; }
+        public int CommandNotBoundCount { get; set; }
+
+        public bool HandleOnCommandNotBound { get; set; }
+
+        public bool HandleCommandNotBound { get; set; }
+
+        protected override bool OnCommandNotBound (CommandEventArgs args)
+        {
+            OnCommandNotBoundCount++;
+            return HandleOnCommandNotBound;
+        }
     }
 }