Partial on #2975 - Replaces Menu v1 in many places with v2 (#4040)

* touching publish.yml

* Fixed UICatalog bugs. Added fluent tests.

* marked v1 menu stuff as obsolte

* Tweaks.
Added View.GetSubMenus<type>().

* fixed unit tests

* general messing around

* general messing around

* Playing with Fluent

* ColorScheme tweaks

* WIP: ColorScheme tweaks

* Playing with Fluent

* Merged from laptop2

* Hacky-ish fixes to:
- #4016
- #4014

* Fixed Region bug preventing menus without borders from working

* Tweaks

* Fixed a bunch of CM issues

* Fixed OoptionSelector

* ip

* FixedCM issues

* Fixed CM issues2

* Revert "FixedCM issues"

This reverts commit dd6c6a70a3d16a6a13b572b80f9a41c8a721ed1c.

* Reverted stuff

* Found and fixed bug in AllViews_Center_Properly

* Fixed CM issues2

* removed menuv2 onapplied.
Changed how UICatalog Applys CM

* changed test time out to see if it helkps with ubuntu fails

* reset app on fail?

* back to 1500ms

* Made StatusBar nullable.

* Code Cleanup.

* HexEditor Code Cleanup.

* HexEditor Code Cleanup.

* Back to 3000ms. Sigh.

* Trying different logic

* Trying different logic2

* Fixed potential crash in runlop

* Fixed potential crash in runlop2

* Tweaked Spinner stuff

* Removed TabView from TextEffects scenario. Not needed and possible culprit.

* back to 2000ms

* WIP: Revamping menu scenarios

* Menu Scenario refinements.
Fixed a few bugs.
Code cleanup.

* fixed unit test

* Fixed warnings

* Fixed warnings2

* Fixed File.Exit

* WIP: Dealing with QuitKey struggles

* WIP: Dealing with QuitKey struggles 2

* WIP: Dealing with QuitKey struggles 3

* Fixed ListView collection nav bug

* Fixed a bunch of menu stuff.
Fixed Appv2 stuff.

* Lots of refactoring and fixing

* Lots of unit test issues

* Fixed DebugIDisposable issues

* Fixed release build issue

* Fixed release build issue 2

* DebugIDisposable -> EnableDebugIDisposableAsserts and more

* DebugIDisposable -> EnableDebugIDisposableAsserts and more 2

* Fixed Menus scenario - context menu

* Added @bdisp suggested assert. Commented it out as it breaks tests.

* Code cleanup

* Fixed disposed but

* Fixed UICatalog exit

* Fixed Unit test I broke.
Added 'Minimal' Theme that turns off all borders etc...

Terminal.Gui/Application/Application.Keyboard.cs

@@ -13,6 +13,17 @@ public static partial class Application // Keyboard handling
     /// <returns><see langword="true"/> if the key was handled.</returns>
     public static bool RaiseKeyDownEvent (Key key)
     {
+        Logging.Debug ($"{key}");
+
+        // TODO: Add a way to ignore certain keys, esp for debugging.
+        //#if DEBUG
+        //        if (key == Key.Empty.WithAlt || key == Key.Empty.WithCtrl)
+        //        {
+        //            Logging.Debug ($"Ignoring {key}");
+        //            return false;
+        //        }
+        //#endif
+
         // TODO: This should match standard event patterns
         KeyDown?.Invoke (null, key);
 

Terminal.Gui/Application/Application.Mouse.cs

@@ -63,7 +63,7 @@ public static partial class Application // Mouse handling
         }
 
 #if DEBUG_IDISPOSABLE
-        if (View.DebugIDisposable)
+        if (View.EnableDebugIDisposableAsserts)
         {
             ObjectDisposedException.ThrowIf (MouseGrabView.WasDisposed, MouseGrabView);
         }
@@ -154,7 +154,7 @@ public static partial class Application // Mouse handling
         if (deepestViewUnderMouse is { })
         {
 #if DEBUG_IDISPOSABLE
-            if (View.DebugIDisposable && deepestViewUnderMouse.WasDisposed)
+            if (View.EnableDebugIDisposableAsserts && deepestViewUnderMouse.WasDisposed)
             {
                 throw new ObjectDisposedException (deepestViewUnderMouse.GetType ().FullName);
             }
@@ -174,8 +174,11 @@ public static partial class Application // Mouse handling
             && Popover?.GetActivePopover () as View is { Visible: true } visiblePopover
             && View.IsInHierarchy (visiblePopover, deepestViewUnderMouse, includeAdornments: true) is false)
         {
-
-            visiblePopover.Visible = false;
+            // TODO: Build a use/test case for the popover not handling Quit
+            if (visiblePopover.InvokeCommand (Command.Quit) is true && visiblePopover.Visible)
+            {
+                visiblePopover.Visible = false;
+            }
 
             // Recurse once so the event can be handled below the popover
             RaiseMouseEvent (mouseEvent);
@@ -297,7 +300,7 @@ public static partial class Application // Mouse handling
         if (MouseGrabView is { })
         {
 #if DEBUG_IDISPOSABLE
-            if (View.DebugIDisposable && MouseGrabView.WasDisposed)
+            if (View.EnableDebugIDisposableAsserts && MouseGrabView.WasDisposed)
             {
                 throw new ObjectDisposedException (MouseGrabView.GetType ().FullName);
             }

Terminal.Gui/Application/Application.Run.cs

@@ -98,7 +98,7 @@ public static partial class Application // Run (Begin, Run, End, Stop)
         var rs = new RunState (toplevel);
 
 #if DEBUG_IDISPOSABLE
-        if (View.DebugIDisposable && Top is { } && toplevel != Top && !TopLevels.Contains (Top))
+        if (View.EnableDebugIDisposableAsserts && Top is { } && toplevel != Top && !TopLevels.Contains (Top))
         {
             // This assertion confirm if the Top was already disposed
             Debug.Assert (Top.WasDisposed);
@@ -193,6 +193,11 @@ public static partial class Application // Run (Begin, Run, End, Stop)
             toplevel.EndInit (); // Calls Layout
         }
 
+        // Call ConfigurationManager Apply here to ensure all subscribers to ConfigurationManager.Applied
+        // can update their state appropriately.
+        // BUGBUG: DO NOT DO THIS. Leave this commented out until we can figure out how to do this right
+        //Apply ();
+
         // Try to set initial focus to any TabStop
         if (!toplevel.HasFocus)
         {
@@ -426,7 +431,7 @@ public static partial class Application // Run (Begin, Run, End, Stop)
 
     internal static void LayoutAndDrawImpl (bool forceDraw = false)
     {
-        List<View> tops = [..TopLevels];
+        List<View> tops = [.. TopLevels];
 
         if (Popover?.GetActivePopover () as View is { Visible: true } visiblePopover)
         {
@@ -479,7 +484,10 @@ public static partial class Application // Run (Begin, Run, End, Stop)
 
         for (state.Toplevel.Running = true; state.Toplevel?.Running == true;)
         {
-            MainLoop!.Running = true;
+            if (MainLoop is { })
+            {
+                MainLoop.Running = true;
+            }
 
             if (EndAfterFirstIteration && !firstIteration)
             {
@@ -489,7 +497,10 @@ public static partial class Application // Run (Begin, Run, End, Stop)
             firstIteration = RunIteration (ref state, firstIteration);
         }
 
-        MainLoop!.Running = false;
+        if (MainLoop is { })
+        {
+            MainLoop.Running = false;
+        }
 
         // Run one last iteration to consume any outstanding input events from Driver
         // This is important for remaining OnKeyUp events.
@@ -505,7 +516,7 @@ public static partial class Application // Run (Begin, Run, End, Stop)
     public static bool RunIteration (ref RunState state, bool firstIteration = false)
     {
         // If the driver has events pending do an iteration of the driver MainLoop
-        if (MainLoop!.Running && MainLoop.EventsPending ())
+        if (MainLoop is { Running: true } && MainLoop.EventsPending ())
         {
             // Notify Toplevel it's ready
             if (firstIteration)
@@ -529,7 +540,7 @@ public static partial class Application // Run (Begin, Run, End, Stop)
 
         if (PositionCursor ())
         {
-            Driver!.UpdateCursor ();
+            Driver?.UpdateCursor ();
         }
 
         return firstIteration;
@@ -564,7 +575,14 @@ public static partial class Application // Run (Begin, Run, End, Stop)
     {
         ArgumentNullException.ThrowIfNull (runState);
 
-        Popover?.Hide (Popover?.GetActivePopover ());
+        if (Popover?.GetActivePopover () as View is { Visible: true } visiblePopover)
+        {
+            // TODO: Build a use/test case for the popover not handling Quit
+            if (visiblePopover.InvokeCommand (Command.Quit) is true && visiblePopover.Visible)
+            {
+                visiblePopover.Visible = false;
+            }
+        }
 
         runState.Toplevel.OnUnloaded ();
 

Terminal.Gui/Application/Application.cs

@@ -53,6 +53,7 @@ public static partial class Application
         {
             return string.Empty;
         }
+
         var sb = new StringBuilder ();
 
         Cell [,] contents = driver?.Contents!;
@@ -139,7 +140,7 @@ public static partial class Application
     // starts running and after Shutdown returns.
     internal static void ResetState (bool ignoreDisposed = false)
     {
-        Application.Navigation = new ApplicationNavigation ();
+        Navigation = new ();
 
         // Shutdown is the bookend for Init. As such it needs to clean up all resources
         // Init created. Apps that do any threading will need to code defensively for this.
@@ -151,8 +152,11 @@ public static partial class Application
 
         if (Popover?.GetActivePopover () is View popover)
         {
+            // This forcefully closes the popover; invoking Command.Quit would be more graceful
+            // but since this is shutdown, doing this is ok.
             popover.Visible = false;
         }
+
         Popover?.Dispose ();
         Popover = null;
 
@@ -160,9 +164,9 @@ public static partial class Application
 #if DEBUG_IDISPOSABLE
 
         // Don't dispose the Top. It's up to caller dispose it
-        if (View.DebugIDisposable && !ignoreDisposed && Top is { })
+        if (View.EnableDebugIDisposableAsserts && !ignoreDisposed && Top is { })
         {
-            Debug.Assert (Top.WasDisposed);
+            Debug.Assert (Top.WasDisposed, $"Title = {Top.Title}, Id = {Top.Id}");
 
             // If End wasn't called _cachedRunStateToplevel may be null
             if (_cachedRunStateToplevel is { })
@@ -223,7 +227,6 @@ public static partial class Application
 
         Navigation = null;
 
-
         KeyBindings.Clear ();
         AddKeyBindings ();
 
@@ -234,10 +237,9 @@ public static partial class Application
         SynchronizationContext.SetSynchronizationContext (null);
     }
 
-
     /// <summary>
     ///     Adds specified idle handler function to main iteration processing. The handler function will be called
     ///     once per iteration of the main loop after other events have been handled.
     /// </summary>
-    public static void AddIdle (Func<bool> func) => ApplicationImpl.Instance.AddIdle (func);
+    public static void AddIdle (Func<bool> func) { ApplicationImpl.Instance.AddIdle (func); }
 }

Terminal.Gui/Application/ApplicationImpl.cs

@@ -34,7 +34,7 @@ public class ApplicationImpl : IApplication
     [RequiresDynamicCode ("AOT")]
     public virtual void Init (IConsoleDriver? driver = null, string? driverName = null)
     {
-            Application.InternalInit (driver, driverName);
+        Application.InternalInit (driver, driverName);
     }
 
     /// <summary>
@@ -166,34 +166,35 @@ public class ApplicationImpl : IApplication
             try
             {
 #endif
-            resume = false;
-            RunState runState = Application.Begin (view);
+                resume = false;
+                RunState runState = Application.Begin (view);
 
-            // If EndAfterFirstIteration is true then the user must dispose of the runToken
-            // by using NotifyStopRunState event.
-            Application.RunLoop (runState);
+                // If EndAfterFirstIteration is true then the user must dispose of the runToken
+                // by using NotifyStopRunState event.
+                Application.RunLoop (runState);
 
-            if (runState.Toplevel is null)
-            {
+                if (runState.Toplevel is null)
+                {
 #if DEBUG_IDISPOSABLE
-                if (View.DebugIDisposable)
+                if (View.EnableDebugIDisposableAsserts)
                 {
                     Debug.Assert (Application.TopLevels.Count == 0);
                 }
 #endif
-                runState.Dispose ();
+                    runState.Dispose ();
 
-                return;
-            }
+                    return;
+                }
 
-            if (!Application.EndAfterFirstIteration)
-            {
-                Application.End (runState);
-            }
+                if (!Application.EndAfterFirstIteration)
+                {
+                    Application.End (runState);
+                }
 #if !DEBUG
             }
             catch (Exception error)
             {
+                Logging.Warning ($"Release Build Exception: {error}");
                 if (errorHandler is null)
                 {
                     throw;
@@ -225,7 +226,7 @@ public class ApplicationImpl : IApplication
         {
             bool init = Application.Initialized;
 
-            Application.OnInitializedChanged(this, new (in init));
+            Application.OnInitializedChanged (this, new (in init));
         }
     }
 
@@ -270,7 +271,7 @@ public class ApplicationImpl : IApplication
     /// <inheritdoc />
     public virtual void AddIdle (Func<bool> func)
     {
-        if(Application.MainLoop is null)
+        if (Application.MainLoop is null)
         {
             throw new NotInitializedException ("Cannot add idle before main loop is initialized");
         }
@@ -294,7 +295,7 @@ public class ApplicationImpl : IApplication
 
     /// <inheritdoc />
     public virtual bool RemoveTimeout (object token)
-    { 
+    {
         return Application.MainLoop?.TimedEvents.RemoveTimeout (token) ?? false;
     }
 

Terminal.Gui/Application/ApplicationPopover.cs

@@ -103,6 +103,7 @@ public sealed class ApplicationPopover : IDisposable
 
         if (popover is View newPopover)
         {
+            Register (popover);
             if (!newPopover.IsInitialized)
             {
                 newPopover.BeginInit ();
@@ -145,6 +146,7 @@ public sealed class ApplicationPopover : IDisposable
 
         if (activePopover is { Visible: true })
         {
+            Logging.Debug ($"Active - Calling NewKeyDownEvent ({key}) on {activePopover.Title}");
             if (activePopover.NewKeyDownEvent (key))
             {
                 return true;
@@ -163,6 +165,7 @@ public sealed class ApplicationPopover : IDisposable
             }
 
             // hotKeyHandled = popoverView.InvokeCommandsBoundToHotKey (key);
+            Logging.Debug ($"Inactive - Calling NewKeyDownEvent ({key}) on {popoverView.Title}");
             hotKeyHandled = popoverView.NewKeyDownEvent (key);
 
             if (hotKeyHandled is true)

Terminal.Gui/Application/PopoverBaseImpl.cs

@@ -41,7 +41,7 @@ public abstract class PopoverBaseImpl : View, IPopover
         {
             if (!Visible)
             {
-                return null;
+                return false;
             }
 
             Visible = false;
@@ -54,11 +54,22 @@ public abstract class PopoverBaseImpl : View, IPopover
     protected override bool OnVisibleChanging ()
     {
         bool ret = base.OnVisibleChanging ();
-        if (!ret && !Visible)
+        if (ret is not true)
         {
-            // Whenever visible is changing to true, we need to resize;
-            // it's our only chance because we don't get laid out until we're visible
-            Layout (Application.Screen.Size);
+            if (!Visible)
+            {
+                // Whenever visible is changing to true, we need to resize;
+                // it's our only chance because we don't get laid out until we're visible
+                Layout (Application.Screen.Size);
+            }
+            else
+            {
+                // Whenever visible is changing to false, we need to reset the focus
+                if (ApplicationNavigation.IsInHierarchy(this, Application.Navigation?.GetFocused ()))
+                {
+                   Application.Navigation?.SetFocused (Application.Top?.MostFocused);
+                }
+            }
         }
 
         return ret;

Terminal.Gui/Application/RunState.cs

@@ -1,4 +1,6 @@
-namespace Terminal.Gui;
+using System.Collections.Concurrent;
+
+namespace Terminal.Gui;
 
 /// <summary>The execution state for a <see cref="Toplevel"/> view.</summary>
 public class RunState : IDisposable
@@ -22,10 +24,7 @@ public class RunState : IDisposable
         Dispose (true);
         GC.SuppressFinalize (this);
 #if DEBUG_IDISPOSABLE
-        if (View.DebugIDisposable)
-        {
-            WasDisposed = true;
-        }
+        WasDisposed = true;
 #endif
     }
 
@@ -45,22 +44,32 @@ public class RunState : IDisposable
     }
 
 #if DEBUG_IDISPOSABLE
-    /// <summary>For debug (see DEBUG_IDISPOSABLE define) purposes to verify objects are being disposed properly</summary>
-    public bool WasDisposed;
+    /// <summary>
+    ///     Gets whether <see cref="Dispose"/> was called on this RunState or not.
+    ///     For debug purposes to verify objects are being disposed properly.
+    ///     Only valid when DEBUG_IDISPOSABLE is defined.
+    /// </summary>
+    public bool WasDisposed { get; private set; }
 
-    /// <summary>For debug (see DEBUG_IDISPOSABLE define) purposes to verify objects are being disposed properly</summary>
-    public int DisposedCount = 0;
+    /// <summary>
+    ///     Gets the number of times <see cref="Dispose"/> was called on this object.
+    ///     For debug purposes to verify objects are being disposed properly.
+    ///     Only valid when DEBUG_IDISPOSABLE is defined.
+    /// </summary>
+    public int DisposedCount { get; private set; } = 0;
 
-    /// <summary>For debug (see DEBUG_IDISPOSABLE define) purposes; the runstate instances that have been created</summary>
-    public static List<RunState> Instances = new ();
+    /// <summary>
+    ///     Gets the list of RunState objects that have been created and not yet disposed.
+    ///     Note, this is a static property and will affect all RunState objects.
+    ///     For debug purposes to verify objects are being disposed properly.
+    ///     Only valid when DEBUG_IDISPOSABLE is defined.
+    /// </summary>
+    public static ConcurrentBag<RunState> Instances { get; private set; } = [];
 
     /// <summary>Creates a new RunState object.</summary>
     public RunState ()
     {
-        if (View.DebugIDisposable)
-        {
-            Instances.Add (this);
-        }
+        Instances.Add (this);
     }
 #endif
 }

Terminal.Gui/Configuration/AttributeJsonConverter.cs

@@ -92,7 +92,7 @@ internal class AttributeJsonConverter : JsonConverter<Attribute>
             }
         }
 
-        throw new JsonException ();
+        throw new JsonException ("Attribute");
     }
 
     public override void Write (Utf8JsonWriter writer, Attribute value, JsonSerializerOptions options)

Terminal.Gui/Configuration/ConfigurationManager.cs

@@ -258,6 +258,7 @@ public static class ConfigurationManager
             Settings?.UpdateFromResource (Assembly.GetEntryAssembly ()!, embeddedStylesResourceName!, ConfigLocations.AppResources);
         }
 
+        // TODO: Determine if Runtime should be applied last.
         if (Locations.HasFlag (ConfigLocations.Runtime) && !string.IsNullOrEmpty (RuntimeConfig))
         {
             Settings?.Update (RuntimeConfig, "ConfigurationManager.RuntimeConfig", ConfigLocations.Runtime);

Terminal.Gui/Configuration/ScopeJsonConverter.cs

@@ -96,6 +96,8 @@ internal class ScopeJsonConverter<[DynamicallyAccessedMembers (DynamicallyAccess
                        // Logging.Trace ($"scopeT Read: {ex}");
                     }
                 }
+                //Logging.Warning ($"{propertyName} = {scope! [propertyName].PropertyValue}");
+
             }
             else
             {
@@ -147,7 +149,7 @@ internal class ScopeJsonConverter<[DynamicallyAccessedMembers (DynamicallyAccess
             }
         }
 
-        throw new JsonException ();
+        throw new JsonException ("ScopeJsonConverter");
     }
 
     public override void Write (Utf8JsonWriter writer, scopeT scope, JsonSerializerOptions options)

Terminal.Gui/ConsoleDrivers/NetDriver/NetEvents.cs

@@ -6,7 +6,7 @@ namespace Terminal.Gui;
 
 internal class NetEvents : IDisposable
 {
-    private readonly CancellationTokenSource _netEventsDisposed = new CancellationTokenSource ();
+    private CancellationTokenSource? _netEventsDisposed = new CancellationTokenSource ();
 
     //CancellationTokenSource _waitForStartCancellationTokenSource;
     private readonly ManualResetEventSlim _winChange = new (false);
@@ -597,6 +597,7 @@ internal class NetEvents : IDisposable
     {
         _netEventsDisposed?.Cancel ();
         _netEventsDisposed?.Dispose ();
+        _netEventsDisposed = null;
 
         try
         {

Terminal.Gui/ConsoleDrivers/V2/ApplicationV2.cs

@@ -162,7 +162,7 @@ public class ApplicationV2 : ApplicationImpl
     /// <inheritdoc/>
     public override void Run (Toplevel view, Func<Exception, bool>? errorHandler = null)
     {
-        Logging.Logger.LogInformation ($"Run '{view}'");
+        Logging.Information ($"Run '{view}'");
         ArgumentNullException.ThrowIfNull (view);
 
         if (!Application.Initialized)
@@ -172,10 +172,12 @@ public class ApplicationV2 : ApplicationImpl
 
         Application.Top = view;
 
-        Application.Begin (view);
+        RunState rs = Application.Begin (view);
 
-        // TODO : how to know when we are done?
-        while (Application.TopLevels.TryPeek (out Toplevel? found) && found == view)
+        Application.Top.Running = true;
+
+        // QUESTION: how to know when we are done? - ANSWER: Running == false
+        while (Application.TopLevels.TryPeek (out Toplevel? found) && found == view && view.Running)
         {
             if (_coordinator is null)
             {
@@ -184,6 +186,9 @@ public class ApplicationV2 : ApplicationImpl
 
             _coordinator.RunIteration ();
         }
+
+        Logging.Information ($"Run - Calling End");
+        Application.End (rs);
     }
 
     /// <inheritdoc/>
@@ -197,7 +202,7 @@ public class ApplicationV2 : ApplicationImpl
     /// <inheritdoc/>
     public override void RequestStop (Toplevel? top)
     {
-        Logging.Logger.LogInformation ($"RequestStop '{top}'");
+        Logging.Logger.LogInformation ($"RequestStop '{(top is {} ? top : "null")}'");
 
         top ??= Application.Top;
 
@@ -214,22 +219,9 @@ public class ApplicationV2 : ApplicationImpl
             return;
         }
 
+        // All RequestStop does is set the Running property to false - In the next iteration
+        // this will be detected
         top.Running = false;
-
-        // TODO: This definition of stop seems sketchy
-        Application.TopLevels.TryPop (out _);
-
-        if (Application.TopLevels.Count > 0)
-        {
-            Application.Top = Application.TopLevels.Peek ();
-        }
-        else
-        {
-            Application.Top = null;
-        }
-
-        // Notify that it is closed
-        top.OnClosed (top);
     }
 
     /// <inheritdoc/>

Terminal.Gui/Drawing/Attribute.cs

@@ -4,6 +4,11 @@ using System.Text.Json.Serialization;
 
 namespace Terminal.Gui;
 
+
+// TODO: Add support for other attributes (bold, underline, etc.) once the platform drivers support them.
+// TODO: See https://github.com/gui-cs/Terminal.Gui/issues/457
+
+
 /// <summary>Attributes represent how text is styled when displayed in the terminal.</summary>
 /// <remarks>
 ///     <see cref="Attribute"/> provides a platform independent representation of colors (and someday other forms of

Terminal.Gui/Drawing/Color/ColorScheme.cs

@@ -4,6 +4,9 @@ using System.Text.Json.Serialization;
 
 namespace Terminal.Gui;
 
+// TODO: Rename "ColorScheme"->"AttributeScheme" given we'll soon have non-color information in Attributes?
+// TODO: See https://github.com/gui-cs/Terminal.Gui/issues/457
+
 /// <summary>Defines a standard set of <see cref="Attribute"/>s for common visible elements in a <see cref="View"/>.</summary>
 /// <remarks>
 ///     <para>

Terminal.Gui/Drawing/Region.cs

@@ -556,72 +556,122 @@ public class Region
     /// <returns>A list of merged rectangles.</returns>
     internal static List<Rectangle> MergeRectangles (List<Rectangle> rectangles, bool minimize)
     {
-        if (rectangles.Count == 0)
+        if (rectangles.Count <= 1)
         {
-            return [];
+            return rectangles.ToList ();
         }
 
-        // Sweep-line algorithm to merge rectangles
-        List<(int x, bool isStart, int yTop, int yBottom)> events = new (rectangles.Count * 2); // Pre-allocate
-
+        // Generate events
+        List<(int x, bool isStart, int yTop, int yBottom)> events = new (rectangles.Count * 2);
         foreach (Rectangle r in rectangles)
         {
             if (!r.IsEmpty)
             {
-                events.Add ((r.Left, true, r.Top, r.Bottom)); // Start event
-                events.Add ((r.Right, false, r.Top, r.Bottom)); // End event
+                events.Add ((r.Left, true, r.Top, r.Bottom));
+                events.Add ((r.Right, false, r.Top, r.Bottom));
             }
         }
 
         if (events.Count == 0)
         {
-            return []; // Return empty list if no non-empty rectangles exist
+            return [];
         }
 
+        // Sort events:
+        // 1. Primarily by x-coordinate.
+        // 2. Secondary: End events before Start events at the same x.
+        // 3. Tertiary: By yTop coordinate as a tie-breaker.
+        // 4. Quaternary: By yBottom coordinate as a final tie-breaker.
         events.Sort (
                      (a, b) =>
                      {
+                         // 1. Sort by X
                          int cmp = a.x.CompareTo (b.x);
+                         if (cmp != 0) return cmp;
 
-                         if (cmp != 0)
-                         {
-                             return cmp;
-                         }
+                         // 2. Sort End events before Start events
+                         bool aIsEnd = !a.isStart;
+                         bool bIsEnd = !b.isStart;
+                         cmp = aIsEnd.CompareTo (bIsEnd); // True (End) comes after False (Start)
+                         if (cmp != 0) return -cmp; // Reverse: End (true) should come before Start (false)
 
-                         return a.isStart.CompareTo (b.isStart); // Start events before end events at same x
+                         // 3. Tie-breaker: Sort by yTop
+                         cmp = a.yTop.CompareTo (b.yTop);
+                         if (cmp != 0) return cmp;
+
+                         // 4. Final Tie-breaker: Sort by yBottom
+                         return a.yBottom.CompareTo (b.yBottom);
                      });
 
         List<Rectangle> merged = [];
-
-        SortedSet<(int yTop, int yBottom)> active = new (
-                                                         Comparer<(int yTop, int yBottom)>.Create (
-                                                                                                   (a, b) =>
-                                                                                                   {
-                                                                                                       int cmp = a.yTop.CompareTo (b.yTop);
-
-                                                                                                       return cmp != 0 ? cmp : a.yBottom.CompareTo (b.yBottom);
-                                                                                                   }));
-        int lastX = events [0].x;
-
-        foreach ((int x, bool isStart, int yTop, int yBottom) evt in events)
+        // Use a dictionary to track active intervals and their overlap counts
+        Dictionary<(int yTop, int yBottom), int> activeCounts = new ();
+        // Comparer for sorting intervals when needed
+        var intervalComparer = Comparer<(int yTop, int yBottom)>.Create (
+                                                                         (a, b) =>
+                                                                         {
+                                                                             int cmp = a.yTop.CompareTo (b.yTop);
+                                                                             return cmp != 0 ? cmp : a.yBottom.CompareTo (b.yBottom);
+                                                                         });
+
+        // Helper to get the current active intervals (where count > 0) as a SortedSet
+        SortedSet<(int yTop, int yBottom)> GetActiveIntervals ()
         {
-            // Output rectangles for the previous segment if there are active rectangles
-            if (active.Count > 0 && evt.x > lastX)
+            var set = new SortedSet<(int yTop, int yBottom)> (intervalComparer);
+            foreach (var kvp in activeCounts)
             {
-                merged.AddRange (MergeVerticalIntervals (active, lastX, evt.x));
+                if (kvp.Value > 0)
+                {
+                    set.Add (kvp.Key);
+                }
             }
+            return set;
+        }
+
+        // Group events by x-coordinate to process all events at a given x together
+        var groupedEvents = events.GroupBy (e => e.x).OrderBy (g => g.Key);
+        int lastX = groupedEvents.First ().Key; // Initialize with the first event's x
 
-            // Process the event
-            if (evt.isStart)
+        foreach (var group in groupedEvents)
+        {
+            int currentX = group.Key;
+            // Get active intervals based on state *before* processing events at currentX
+            var currentActiveIntervals = GetActiveIntervals ();
+
+            // 1. Output rectangles for the segment ending *before* this x coordinate
+            if (currentX > lastX && currentActiveIntervals.Count > 0)
             {
-                active.Add ((evt.yTop, evt.yBottom));
+                merged.AddRange (MergeVerticalIntervals (currentActiveIntervals, lastX, currentX));
             }
-            else
+
+            // 2. Process all events *at* this x coordinate to update counts
+            foreach (var evt in group)
             {
-                active.Remove ((evt.yTop, evt.yBottom));
+                var interval = (evt.yTop, evt.yBottom);
+                if (evt.isStart)
+                {
+                    activeCounts.TryGetValue (interval, out int count);
+                    activeCounts [interval] = count + 1;
+                }
+                else
+                {
+                    // Only decrement/remove if the interval exists
+                    if (activeCounts.TryGetValue (interval, out int count))
+                    {
+                        if (count - 1 <= 0)
+                        {
+                            activeCounts.Remove (interval);
+                        }
+                        else
+                        {
+                            activeCounts [interval] = count - 1;
+                        }
+                    }
+                }
             }
 
-            lastX = evt.x;
+            // 3. Update lastX for the next segment
+            lastX = currentX;
         }
 
         return minimize ? MinimizeRectangles (merged) : merged;

Terminal.Gui/Resources/config.json

@@ -52,6 +52,9 @@
         "MessageBox.DefaultButtonAlignment": "Center",
         "MessageBox.DefaultBorderStyle": "Heavy",
         "Button.DefaultShadow": "Opaque",
+        "Menuv2.DefaultBorderStyle": "Single",
+        "MenuBarv2.DefaultBorderStyle": "None",
+        "StatusBar.DefaultSeparatorLineStyle": "Single",
         "ColorSchemes": [
           {
             "TopLevel": {
@@ -132,16 +135,16 @@
                 "Background": "DarkBlue"
               },
               "Focus": {
-                "Foreground": "White",
-                "Background": "Blue"
+                "Foreground": "DarkBlue",
+                "Background": "White"
               },
               "HotNormal": {
                 "Foreground": "Yellow",
                 "Background": "DarkBlue"
               },
               "HotFocus": {
-                "Foreground": "Yellow",
-                "Background": "Blue"
+                "Foreground": "Blue",
+                "Background": "White"
               },
               "Disabled": {
                 "Foreground": "Gray",
@@ -853,6 +856,18 @@
           }
         ]
       }
+    },
+    {
+      "Minimal": {
+        "Dialog.DefaultShadow": "None",
+        "FrameView.DefaultBorderStyle": "None",
+        "Window.DefaultBorderStyle": "None",
+        "MessageBox.DefaultBorderStyle": "None",
+        "Button.DefaultShadow": "None",
+        "Menuv2.DefaultBorderStyle": "None",
+        "Glyphs.LeftBracket": "[",
+        "Glyphs.RightBracket": "]"
+      }
     }
   ]
 }

Terminal.Gui/Terminal.Gui.sln

@@ -0,0 +1,24 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.5.2.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Terminal.Gui", "Terminal.Gui.csproj", "{79692A4F-7704-552C-0EF5-40B81C4F2E81}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{79692A4F-7704-552C-0EF5-40B81C4F2E81}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{79692A4F-7704-552C-0EF5-40B81C4F2E81}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{79692A4F-7704-552C-0EF5-40B81C4F2E81}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{79692A4F-7704-552C-0EF5-40B81C4F2E81}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {4B162456-436F-4899-B765-26C9DBD2991D}
+	EndGlobalSection
+EndGlobal

Terminal.Gui/View/Adornment/Border.cs

@@ -201,6 +201,7 @@ public class Border : Adornment
                    );
     }
 
+    // TODO: Make LineStyle nullable https://github.com/gui-cs/Terminal.Gui/issues/4021
     /// <summary>
     ///     Sets the style of the border by changing the <see cref="Thickness"/>. This is a helper API for setting the
     ///     <see cref="Thickness"/> to <c>(1,1,1,1)</c> and setting the line style of the views that comprise the border. If

Terminal.Gui/View/Adornment/Margin.cs

@@ -104,25 +104,86 @@ public class Margin : Adornment
         ShadowStyle = base.ShadowStyle;
     }
 
-    /// <summary>
-    ///     The color scheme for the Margin. If set to <see langword="null"/> (the default), the margin will be transparent.
-    /// </summary>
-    public override ColorScheme? ColorScheme
+    // TODO: We may actualy need this. Not clear what broke, if anything by commenting it out. See https://github.com/gui-cs/Terminal.Gui/issues/4016
+    /////// <summary>
+    ///////     The color scheme for the Margin. If set to <see langword="null"/> (the default), the margin will be transparent.
+    /////// </summary>
+    //public override ColorScheme? ColorScheme
+    //{
+    //    get
+    //    {
+    //        //if (base.ColorScheme is { })
+    //        {
+    //            return base.ColorScheme;
+    //        }
+
+    //        //return (Parent?.SuperView?.ColorScheme ?? Colors.ColorSchemes ["TopLevel"])!;
+    //    }
+    //    set
+    //    {
+    //        base.ColorScheme = value;
+    //        Parent?.SetNeedsDraw ();
+    //    }
+    //}
+
+    /// <inheritdoc />
+    public override Attribute GetNormalColor ()
     {
-        get
+        if (_colorScheme is { })
         {
-            if (base.ColorScheme is { })
-            {
-                return base.ColorScheme;
-            }
+            return _colorScheme.Normal;
+        }
+        if (Parent is { })
+        {
+            return Parent.GetNormalColor ();
+        }
 
-            return (Parent?.SuperView?.ColorScheme ?? Colors.ColorSchemes ["TopLevel"])!;
+        return base.GetNormalColor ();
+    }
+
+    /// <inheritdoc />
+    public override Attribute GetHotNormalColor ()
+    {
+        if (Parent is { })
+        {
+            return Parent.GetHotNormalColor ();
         }
-        set
+        return base.GetHotNormalColor ();
+    }
+
+    /// <inheritdoc />
+    public override Attribute GetFocusColor ()
+    {
+        if (Parent is { })
         {
-            base.ColorScheme = value;
-            Parent?.SetNeedsDraw ();
+            return Parent.GetFocusColor ();
         }
+        return base.GetFocusColor ();
+    }
+
+    /// <inheritdoc />
+    public override Attribute GetHotFocusColor ()
+    {
+        if (Parent is { })
+        {
+            return Parent.GetHotFocusColor ();
+        }
+
+        return base.GetHotFocusColor ();
+    }
+
+    /// <inheritdoc />
+    protected override bool OnSettingNormalAttribute ()
+    {
+        if (Parent is { })
+        {
+            SetAttribute (Parent.GetNormalColor ());
+
+            return true;
+        }
+
+        return false;
+
     }
 
     /// <inheritdoc/>
@@ -138,6 +199,8 @@ public class Margin : Adornment
         // This just draws/clears the thickness, not the insides.
         if (Diagnostics.HasFlag (ViewDiagnosticFlags.Thickness) || base.ColorScheme is { })
         {
+            // TODO: This is a hack. See https://github.com/gui-cs/Terminal.Gui/issues/4016
+            SetAttribute (GetNormalColor ());
             Thickness.Draw (screen, Diagnostics, ToString ());
         }
 

Terminal.Gui/View/Adornment/ShadowView.cs

@@ -54,6 +54,7 @@ internal class ShadowView : View
     /// <inheritdoc/>
     protected override bool OnDrawingContent ()
     {
+        SetAttribute (GetNormalColor ());
         switch (ShadowStyle)
         {
             case ShadowStyle.Opaque:

Terminal.Gui/View/IDesignable.cs

@@ -12,7 +12,7 @@ public interface IDesignable
     /// <param name="context">Optional arbitrary, View-specific, context.</param>
     /// <typeparam name="TContext">A non-null type for <paramref name="context"/>.</typeparam>
     /// <returns><see langword="true"/> if the view successfully loaded demo data.</returns>
-    public bool EnableForDesign<TContext> (ref readonly TContext context) where TContext : notnull => EnableForDesign ();
+    public bool EnableForDesign<TContext> (ref TContext context) where TContext : notnull => EnableForDesign ();
 
     /// <summary>
     ///     Causes the View to enable design-time mode. This typically means that the view will load demo data and

Terminal.Gui/View/View.Adornments.cs

@@ -121,6 +121,7 @@ public partial class View // Adornments
     /// </remarks>
     public Border? Border { get; private set; }
 
+    // TODO: Make BorderStyle nullable https://github.com/gui-cs/Terminal.Gui/issues/4021
     /// <summary>Gets or sets whether the view has a one row/col thick border.</summary>
     /// <remarks>
     ///     <para>
@@ -133,7 +134,7 @@ public partial class View // Adornments
     ///         <see cref="Adornment.Thickness"/> to `0` and <see cref="BorderStyle"/> to <see cref="LineStyle.None"/>.
     ///     </para>
     ///     <para>
-    ///         Calls <see cref="OnBorderStyleChanging"/> and raises <see cref="BorderStyleChanging"/>, which allows change
+    ///         Raises <see cref="OnBorderStyleChanged"/> and raises <see cref="BorderStyleChanged"/>, which allows change
     ///         to be cancelled.
     ///     </para>
     ///     <para>For more advanced customization of the view's border, manipulate see <see cref="Border"/> directly.</para>
@@ -148,44 +149,21 @@ public partial class View // Adornments
                 return;
             }
 
-            LineStyle old = Border?.LineStyle ?? LineStyle.None;
-
-            // It's tempting to try to optimize this by checking that old != value and returning.
-            // Do not.
-
-            CancelEventArgs<LineStyle> e = new (ref old, ref value);
-
-            if (OnBorderStyleChanging (e) || e.Cancel)
-            {
-                return;
-            }
-
-            BorderStyleChanging?.Invoke (this, e);
-
-            if (e.Cancel)
-            {
-                return;
-            }
-
-            SetBorderStyle (e.NewValue);
-            SetAdornmentFrames ();
-            SetNeedsLayout ();
+            SetBorderStyle (value);
+            OnBorderStyleChanged ();
+            BorderStyleChanged?.Invoke (this, EventArgs.Empty);
         }
     }
 
     /// <summary>
-    ///     Called when the <see cref="BorderStyle"/> is changing.
+    ///     Called when the <see cref="BorderStyle"/> has changed.
     /// </summary>
-    /// <remarks>
-    ///     Set e.Cancel to true to prevent the <see cref="BorderStyle"/> from changing.
-    /// </remarks>
-    /// <param name="e"></param>
-    protected virtual bool OnBorderStyleChanging (CancelEventArgs<LineStyle> e) { return false; }
+    protected virtual bool OnBorderStyleChanged () { return false; }
 
     /// <summary>
-    ///     Fired when the <see cref="BorderStyle"/> is changing. Allows the event to be cancelled.
+    ///     Fired when the <see cref="BorderStyle"/> has changed.
     /// </summary>
-    public event EventHandler<CancelEventArgs<LineStyle>>? BorderStyleChanging;
+    public event EventHandler<EventArgs>? BorderStyleChanged;
 
     /// <summary>
     ///     Sets the <see cref="BorderStyle"/> of the view to the specified value.
@@ -204,7 +182,7 @@ public partial class View // Adornments
     ///     <para>For more advanced customization of the view's border, manipulate see <see cref="Border"/> directly.</para>
     /// </remarks>
     /// <param name="style"></param>
-    public virtual void SetBorderStyle (LineStyle style)
+    internal void SetBorderStyle (LineStyle style)
     {
         if (style != LineStyle.None)
         {
@@ -219,6 +197,9 @@ public partial class View // Adornments
         }
 
         Border.LineStyle = style;
+
+        SetAdornmentFrames ();
+        SetNeedsLayout ();
     }
 
     /// <summary>

Terminal.Gui/View/View.Attribute.cs

@@ -1,121 +1,21 @@
 #nullable enable
+using System.ComponentModel;
+
 namespace Terminal.Gui;
 
 public partial class View
 {
-    // TODO: Rename "Color"->"Attribute" given we'll soon have non-color information in Attributes?
-    // TODO: See https://github.com/gui-cs/Terminal.Gui/issues/457
-
-    #region ColorScheme
-
-    private ColorScheme? _colorScheme;
-
-    /// <summary>The color scheme for this view, if it is not defined, it returns the <see cref="SuperView"/>'s color scheme.</summary>
-    public virtual ColorScheme? ColorScheme
-    {
-        get => _colorScheme ?? SuperView?.ColorScheme;
-        set
-        {
-            if (_colorScheme == value)
-            {
-                return;
-            }
-
-            _colorScheme = value;
-
-            // BUGBUG: This should be in Border.cs somehow
-            if (Border is { } && Border.LineStyle != LineStyle.None && Border.ColorScheme is { })
-            {
-                Border.ColorScheme = _colorScheme;
-            }
-
-            SetNeedsDraw ();
-        }
-    }
-
-    /// <summary>Determines the current <see cref="ColorScheme"/> based on the <see cref="Enabled"/> value.</summary>
-    /// <returns>
-    ///     <see cref="ColorScheme.Focus"/> if <see cref="Enabled"/> is <see langword="true"/> or
-    ///     <see cref="ColorScheme.Disabled"/> if <see cref="Enabled"/> is <see langword="false"/>. If it's
-    ///     overridden can return other values.
-    /// </returns>
-    public virtual Attribute GetFocusColor ()
-    {
-        ColorScheme? cs = ColorScheme ?? new ();
-
-        return Enabled ? GetColor (cs.Focus) : cs.Disabled;
-    }
-
-    /// <summary>Determines the current <see cref="ColorScheme"/> based on the <see cref="Enabled"/> value.</summary>
-    /// <returns>
-    ///     <see cref="ColorScheme.Focus"/> if <see cref="Enabled"/> is <see langword="true"/> or
-    ///     <see cref="ColorScheme.Disabled"/> if <see cref="Enabled"/> is <see langword="false"/>. If it's
-    ///     overridden can return other values.
-    /// </returns>
-    public virtual Attribute GetHotFocusColor ()
-    {
-        ColorScheme? cs = ColorScheme ?? new ();
-
-        return Enabled ? GetColor (cs.HotFocus) : cs.Disabled;
-    }
-
-    /// <summary>Determines the current <see cref="ColorScheme"/> based on the <see cref="Enabled"/> value.</summary>
-    /// <returns>
-    ///     <see cref="ColorScheme.HotNormal"/> if <see cref="Enabled"/> is <see langword="true"/> or
-    ///     <see cref="ColorScheme.Disabled"/> if <see cref="Enabled"/> is <see langword="false"/>. If it's
-    ///     overridden can return other values.
-    /// </returns>
-    public virtual Attribute GetHotNormalColor ()
-    {
-        ColorScheme? cs = ColorScheme ?? new ();
-
-        return Enabled ? GetColor (cs.HotNormal) : cs.Disabled;
-    }
-
-    /// <summary>Determines the current <see cref="ColorScheme"/> based on the <see cref="Enabled"/> value.</summary>
-    /// <returns>
-    ///     <see cref="ColorScheme.Normal"/> if <see cref="Enabled"/> is <see langword="true"/> or
-    ///     <see cref="ColorScheme.Disabled"/> if <see cref="Enabled"/> is <see langword="false"/>. If it's
-    ///     overridden can return other values.
-    /// </returns>
-    public virtual Attribute GetNormalColor ()
-    {
-        ColorScheme? cs = ColorScheme ?? new ();
-
-        Attribute disabled = new (cs.Disabled.Foreground, cs.Disabled.Background);
-
-        if (Diagnostics.HasFlag (ViewDiagnosticFlags.Hover) && _hovering)
-        {
-            disabled = new (disabled.Foreground.GetDarkerColor (), disabled.Background.GetDarkerColor ());
-        }
-
-        return Enabled ? GetColor (cs.Normal) : disabled;
-    }
-
-    private Attribute GetColor (Attribute inputAttribute)
-    {
-        Attribute attr = inputAttribute;
-
-        if (Diagnostics.HasFlag (ViewDiagnosticFlags.Hover) && _hovering)
-        {
-            attr = new (attr.Foreground.GetDarkerColor (), attr.Background.GetDarkerColor ());
-        }
-
-        return attr;
-    }
-
-    #endregion ColorScheme
-
-    #region Attribute
-
     /// <summary>Selects the specified attribute as the attribute to use for future calls to AddRune and AddString.</summary>
     /// <remarks></remarks>
     /// <param name="attribute">THe Attribute to set.</param>
-    public Attribute SetAttribute (Attribute attribute) { return Driver?.SetAttribute (attribute) ?? Attribute.Default; }
+    public Attribute SetAttribute (Attribute attribute)
+    {
+        return Driver?.SetAttribute (attribute) ?? Attribute.Default;
+    }
 
     /// <summary>Gets the current <see cref="Attribute"/>.</summary>
     /// <returns>The current attribute.</returns>
     public Attribute GetAttribute () { return Driver?.GetAttribute () ?? Attribute.Default; }
 
-    #endregion Attribute
+
 }

Terminal.Gui/View/View.ColorScheme.cs

@@ -0,0 +1,211 @@
+#nullable enable
+using System.ComponentModel;
+
+namespace Terminal.Gui;
+
+public partial class View
+{
+    // TODO: See https://github.com/gui-cs/Terminal.Gui/issues/4014
+    // TODO: See https://github.com/gui-cs/Terminal.Gui/issues/4016
+    // TODO: Enable ability to tell if ColorScheme was explicitly set; ColorScheme, as is, hides this.
+    internal ColorScheme? _colorScheme;
+
+    /// <summary>The color scheme for this view, if it is not defined, it returns the <see cref="SuperView"/>'s color scheme.</summary>
+    public virtual ColorScheme? ColorScheme
+    {
+        // BUGBUG: This prevents the ability to know if ColorScheme was explicitly set or not.
+        get => _colorScheme ?? SuperView?.ColorScheme;
+        set
+        {
+            if (_colorScheme == value)
+            {
+                return;
+            }
+
+            _colorScheme = value;
+
+            // BUGBUG: This should be in Border.cs somehow
+            if (Border is { } && Border.LineStyle != LineStyle.None && Border.ColorScheme is { })
+            {
+                Border.ColorScheme = _colorScheme;
+            }
+
+            SetNeedsDraw ();
+        }
+    }
+
+    /// <summary>Determines the current <see cref="ColorScheme"/> based on the <see cref="Enabled"/> value.</summary>
+    /// <returns>
+    ///     <see cref="ColorScheme.Focus"/> if <see cref="Enabled"/> is <see langword="true"/> or
+    ///     <see cref="ColorScheme.Disabled"/> if <see cref="Enabled"/> is <see langword="false"/>. If it's
+    ///     overridden can return other values.
+    /// </returns>
+    public virtual Attribute GetFocusColor ()
+    {
+        Attribute currAttribute = ColorScheme?.Normal ?? Attribute.Default;
+        var newAttribute = new Attribute ();
+        CancelEventArgs<Attribute> args = new (in currAttribute, ref newAttribute);
+        GettingFocusColor?.Invoke (this, args);
+
+        if (args.Cancel)
+        {
+            return args.NewValue;
+        }
+
+        ColorScheme? cs = ColorScheme ?? new ();
+
+        return Enabled ? GetColor (cs.Focus) : cs.Disabled;
+    }
+
+    /// <summary>
+    ///     Raised the Focus Color is being retrieved, from <see cref="GetFocusColor"/>. Cancel the event and set the new
+    ///     attribute in the event args to
+    ///     a different value to change the focus color.
+    /// </summary>
+    public event EventHandler<CancelEventArgs<Attribute>>? GettingFocusColor;
+
+    /// <summary>Determines the current <see cref="ColorScheme"/> based on the <see cref="Enabled"/> value.</summary>
+    /// <returns>
+    ///     <see cref="ColorScheme.Focus"/> if <see cref="Enabled"/> is <see langword="true"/> or
+    ///     <see cref="ColorScheme.Disabled"/> if <see cref="Enabled"/> is <see langword="false"/>. If it's
+    ///     overridden can return other values.
+    /// </returns>
+    public virtual Attribute GetHotFocusColor ()
+    {
+        Attribute currAttribute = ColorScheme?.Normal ?? Attribute.Default;
+        var newAttribute = new Attribute ();
+        CancelEventArgs<Attribute> args = new (in currAttribute, ref newAttribute);
+        GettingHotFocusColor?.Invoke (this, args);
+
+        if (args.Cancel)
+        {
+            return args.NewValue;
+        }
+
+        ColorScheme? cs = ColorScheme ?? new ();
+
+        return Enabled ? GetColor (cs.HotFocus) : cs.Disabled;
+    }
+
+    /// <summary>
+    ///     Raised the HotFocus Color is being retrieved, from <see cref="GetHotFocusColor"/>. Cancel the event and set the new
+    ///     attribute in the event args to
+    ///     a different value to change the focus color.
+    /// </summary>
+    public event EventHandler<CancelEventArgs<Attribute>>? GettingHotFocusColor;
+
+    /// <summary>Determines the current <see cref="ColorScheme"/> based on the <see cref="Enabled"/> value.</summary>
+    /// <returns>
+    ///     <see cref="ColorScheme.HotNormal"/> if <see cref="Enabled"/> is <see langword="true"/> or
+    ///     <see cref="ColorScheme.Disabled"/> if <see cref="Enabled"/> is <see langword="false"/>. If it's
+    ///     overridden can return other values.
+    /// </returns>
+    public virtual Attribute GetHotNormalColor ()
+    {
+        Attribute currAttribute = ColorScheme?.Normal ?? Attribute.Default;
+        var newAttribute = new Attribute ();
+        CancelEventArgs<Attribute> args = new (in currAttribute, ref newAttribute);
+        GettingHotNormalColor?.Invoke (this, args);
+
+        if (args.Cancel)
+        {
+            return args.NewValue;
+        }
+
+        ColorScheme? cs = ColorScheme ?? new ();
+
+        return Enabled ? GetColor (cs.HotNormal) : cs.Disabled;
+    }
+
+    /// <summary>
+    ///     Raised the HotNormal Color is being retrieved, from <see cref="GetHotNormalColor"/>. Cancel the event and set the
+    ///     new attribute in the event args to
+    ///     a different value to change the focus color.
+    /// </summary>
+    public event EventHandler<CancelEventArgs<Attribute>>? GettingHotNormalColor;
+
+    /// <summary>Determines the current <see cref="ColorScheme"/> based on the <see cref="Enabled"/> value.</summary>
+    /// <returns>
+    ///     <see cref="ColorScheme.Normal"/> if <see cref="Enabled"/> is <see langword="true"/> or
+    ///     <see cref="ColorScheme.Disabled"/> if <see cref="Enabled"/> is <see langword="false"/>. If it's
+    ///     overridden can return other values.
+    /// </returns>
+    public virtual Attribute GetNormalColor ()
+    {
+        Attribute currAttribute = ColorScheme?.Normal ?? Attribute.Default;
+        var newAttribute = new Attribute ();
+        CancelEventArgs<Attribute> args = new (in currAttribute, ref newAttribute);
+        GettingNormalColor?.Invoke (this, args);
+
+        if (args.Cancel)
+        {
+            return args.NewValue;
+        }
+
+        ColorScheme? cs = ColorScheme ?? new ();
+        Attribute disabled = new (cs.Disabled.Foreground, cs.Disabled.Background);
+
+        if (Diagnostics.HasFlag (ViewDiagnosticFlags.Hover) && _hovering)
+        {
+            disabled = new (disabled.Foreground.GetDarkerColor (), disabled.Background.GetDarkerColor ());
+        }
+
+        return Enabled ? GetColor (cs.Normal) : disabled;
+    }
+
+    /// <summary>
+    ///     Raised the Normal Color is being retrieved, from <see cref="GetNormalColor"/>. Cancel the event and set the new
+    ///     attribute in the event args to
+    ///     a different value to change the focus color.
+    /// </summary>
+    public event EventHandler<CancelEventArgs<Attribute>>? GettingNormalColor;
+
+    /// <summary>
+    ///     Sets the Normal attribute if the setting process is not canceled. It triggers an event and checks for
+    ///     cancellation before proceeding.
+    /// </summary>
+    public void SetNormalAttribute ()
+    {
+        if (OnSettingNormalAttribute ())
+        {
+            return;
+        }
+
+        var args = new CancelEventArgs ();
+        SettingNormalAttribute?.Invoke (this, args);
+
+        if (args.Cancel)
+        {
+            return;
+        }
+
+        if (ColorScheme is { })
+        {
+            SetAttribute (GetNormalColor ());
+        }
+    }
+
+    /// <summary>
+    ///     Called when the normal attribute for the View is to be set. This is called before the View is drawn.
+    /// </summary>
+    /// <returns><see langword="true"/> to stop default behavior.</returns>
+    protected virtual bool OnSettingNormalAttribute () { return false; }
+
+    /// <summary>Raised  when the normal attribute for the View is to be set. This is raised before the View is drawn.</summary>
+    /// <returns>
+    ///     Set <see cref="CancelEventArgs.Cancel"/> to <see langword="true"/> to stop default behavior.
+    /// </returns>
+    public event EventHandler<CancelEventArgs>? SettingNormalAttribute;
+
+    private Attribute GetColor (Attribute inputAttribute)
+    {
+        Attribute attr = inputAttribute;
+
+        if (Diagnostics.HasFlag (ViewDiagnosticFlags.Hover) && _hovering)
+        {
+            attr = new (attr.Foreground.GetDarkerColor (), attr.Background.GetDarkerColor ());
+        }
+
+        return attr;
+    }
+}

Terminal.Gui/View/View.Command.cs

@@ -1,5 +1,6 @@
 #nullable enable
 using System.ComponentModel;
+using System.Dynamic;
 
 namespace Terminal.Gui;
 
@@ -115,18 +116,18 @@ public partial class View // Command APIs
     /// </returns>
     protected bool? RaiseAccepting (ICommandContext? ctx)
     {
-        Logging.Trace($"{ctx?.Source?.Title}");
+        Logging.Debug ($"{Title} ({ctx?.Source?.Title})");
         CommandEventArgs args = new () { Context = ctx };
 
         // Best practice is to invoke the virtual method first.
         // This allows derived classes to handle the event and potentially cancel it.
-        Logging.Trace ($"Calling OnAccepting...");
+        Logging.Debug ($"{Title} ({ctx?.Source?.Title}) - Calling OnAccepting...");
         args.Cancel = OnAccepting (args) || args.Cancel;
 
-        if (!args.Cancel)
+        if (!args.Cancel && Accepting is {})
         {
             // If the event is not canceled by the virtual method, raise the event to notify any external subscribers.
-            Logging.Trace ($"Raising Accepting...");
+            Logging.Debug ($"{Title} ({ctx?.Source?.Title}) - Raising Accepting...");
             Accepting?.Invoke (this, args);
         }
 
@@ -142,7 +143,9 @@ public partial class View // Command APIs
             {
                 // TODO: It's a bit of a hack that this uses KeyBinding. There should be an InvokeCommmand that 
                 // TODO: is generic?
-                bool? handled = isDefaultView.InvokeCommand (Command.Accept, ctx);
+
+                Logging.Debug ($"{Title} ({ctx?.Source?.Title}) - InvokeCommand on Default View ({isDefaultView.Title})");
+                bool ? handled = isDefaultView.InvokeCommand (Command.Accept, ctx);
                 if (handled == true)
                 {
                     return true;
@@ -151,7 +154,7 @@ public partial class View // Command APIs
 
             if (SuperView is { })
             {
-                Logging.Trace ($"Invoking Accept on SuperView: {SuperView.Title}...");
+                Logging.Debug ($"{Title} ({ctx?.Source?.Title}) - Invoking Accept on SuperView ({SuperView.Title}/{SuperView.Id})...");
                 return SuperView?.InvokeCommand (Command.Accept, ctx);
             }
         }
@@ -197,6 +200,7 @@ public partial class View // Command APIs
     /// </returns>
     protected bool? RaiseSelecting (ICommandContext? ctx)
     {
+        Logging.Debug ($"{Title} ({ctx?.Source?.Title})");
         CommandEventArgs args = new () { Context = ctx };
 
         // Best practice is to invoke the virtual method first.
@@ -239,6 +243,7 @@ public partial class View // Command APIs
     protected bool? RaiseHandlingHotKey ()
     {
         CommandEventArgs args = new () { Context = new CommandContext<KeyBinding> () { Command = Command.HotKey } };
+        Logging.Debug ($"{Title} ({args.Context?.Source?.Title})");
 
         // Best practice is to invoke the virtual method first.
         // This allows derived classes to handle the event and potentially cancel it.
@@ -421,7 +426,12 @@ public partial class View // Command APIs
             _commandImplementations.TryGetValue (Command.NotBound, out implementation);
         }
 
-        return implementation! (null);
+        return implementation! (new CommandContext<object> ()
+        {
+            Command = command,
+            Source = this,
+            Binding = null,
+        });
 
     }
 }

Terminal.Gui/View/View.Drawing.cs

@@ -76,25 +76,25 @@ public partial class View // Drawing APIs
             context ??= new DrawContext ();
 
             // TODO: Simplify/optimize SetAttribute system.
-            DoSetAttribute ();
+            SetNormalAttribute ();
             DoClearViewport (context);
 
             // ------------------------------------
             // Draw the subviews first (order matters: SubViews, Text, Content)
             if (SubViewNeedsDraw)
             {
-                DoSetAttribute ();
+                SetNormalAttribute ();
                 DoDrawSubViews (context);
             }
 
             // ------------------------------------
             // Draw the text
-            DoSetAttribute ();
+            SetNormalAttribute ();
             DoDrawText (context);
 
             // ------------------------------------
             // Draw the content
-            DoSetAttribute ();
+            SetNormalAttribute ();
             DoDrawContent (context);
 
             // ------------------------------------
@@ -268,51 +268,6 @@ public partial class View // Drawing APIs
 
     #endregion DrawAdornments
 
-    #region SetAttribute
-
-    private void DoSetAttribute ()
-    {
-        if (OnSettingAttribute ())
-        {
-            return;
-        }
-
-        var args = new CancelEventArgs ();
-        SettingAttribute?.Invoke (this, args);
-
-        if (args.Cancel)
-        {
-            return;
-        }
-
-        SetNormalAttribute ();
-    }
-
-    /// <summary>
-    ///     Called when the normal attribute for the View is to be set. This is called before the View is drawn.
-    /// </summary>
-    /// <returns><see langword="true"/> to stop default behavior.</returns>
-    protected virtual bool OnSettingAttribute () { return false; }
-
-    /// <summary>Raised  when the normal attribute for the View is to be set. This is raised before the View is drawn.</summary>
-    /// <returns>
-    ///     Set <see cref="CancelEventArgs.Cancel"/> to <see langword="true"/> to stop default behavior.
-    /// </returns>
-    public event EventHandler<CancelEventArgs>? SettingAttribute;
-
-    /// <summary>
-    ///     Sets the attribute for the View. This is called before the View is drawn.
-    /// </summary>
-    public void SetNormalAttribute ()
-    {
-        if (ColorScheme is { })
-        {
-            SetAttribute (GetNormalColor ());
-        }
-    }
-
-    #endregion
-
     #region ClearViewport
 
     internal void DoClearViewport (DrawContext? context = null)
@@ -673,7 +628,7 @@ public partial class View // Drawing APIs
                 // Get the entire map
                 if (p.Value is { })
                 {
-                    SetAttribute (p.Value.Value.Attribute ?? ColorScheme!.Normal);
+                    SetAttribute (p.Value.Value.Attribute ?? GetNormalColor ());
                     Driver.Move (p.Key.X, p.Key.Y);
 
                     // TODO: #2616 - Support combining sequences that don't normalize

Terminal.Gui/View/View.Hierarchy.cs

@@ -1,4 +1,5 @@
 #nullable enable
+using System.Collections.ObjectModel;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 
@@ -302,7 +303,7 @@ public partial class View // SuperView/SubView hierarchy management (SuperView,
     public event EventHandler<SuperViewChangedEventArgs>? SubViewRemoved;
 
     /// <summary>
-    ///     Removes all SubView (children) added via <see cref="Add(View)"/> or <see cref="Add(View[])"/> from this View.
+    ///     Removes all SubViews added via <see cref="Add(View)"/> or <see cref="Add(View[])"/> from this View.
     /// </summary>
     /// <remarks>
     ///     <para>
@@ -312,12 +313,47 @@ public partial class View // SuperView/SubView hierarchy management (SuperView,
     ///         added.
     ///     </para>
     /// </remarks>
-    public virtual void RemoveAll ()
+    /// <returns>
+    ///     A list of removed Views.
+    /// </returns>
+    public virtual IReadOnlyCollection<View> RemoveAll ()
     {
+        List<View> removedList = new List<View> ();
         while (InternalSubViews.Count > 0)
         {
-            Remove (InternalSubViews [0]);
+            View? removed = Remove (InternalSubViews [0]);
+            if (removed is { })
+            {
+                removedList.Add (removed);
+            }
+        }
+
+        return removedList.AsReadOnly ();
+    }
+
+    /// <summary>
+    ///     Removes all SubViews of a type added via <see cref="Add(View)"/> or <see cref="Add(View[])"/> from this View.
+    /// </summary>
+    /// <remarks>
+    ///     <para>
+    ///         Normally SubViews will be disposed when this View is disposed. Removing a SubView causes ownership of the
+    ///         SubView's
+    ///         lifecycle to be transferred to the caller; the caller must call <see cref="Dispose()"/> on any Views that were
+    ///         added.
+    ///     </para>
+    /// </remarks>
+    /// <returns>
+    ///     A list of removed Views.
+    /// </returns>
+    public virtual IReadOnlyCollection<TView> RemoveAll<TView> () where TView : View
+    {
+        List<TView> removedList = new List<TView> ();
+        foreach (TView view in InternalSubViews.OfType<TView> ().ToList ())
+        {
+            Remove (view);
+            removedList.Add (view);
         }
+        return removedList.AsReadOnly ();
     }
 
 #pragma warning disable CS0067 // The event is never used

Terminal.Gui/View/View.Keyboard.cs

@@ -282,6 +282,10 @@ public partial class View // Keyboard APIs
             return false;
         }
 
+        // TODO: We really need an event before recursing into Focused. Without, there's no way for 
+        // TODO: SuperViews to prevent SubViews from seeing certain keys. A use-case for this:
+        // TODO:    - MenuBar needs to prevent MenuItems from seeing QuitKey if the MenuItem is not visible
+
         // If there's a Focused subview, give it a chance (this recurses down the hierarchy)
         if (Focused?.NewKeyDownEvent (key) == true)
         {
@@ -613,6 +617,11 @@ public partial class View // Keyboard APIs
         // Process this View
         if (HotKeyBindings.TryGet (hotKey, out KeyBinding binding))
         {
+            if (binding.Key is null || binding.Key == Key.Empty)
+            {
+                binding.Key = hotKey;
+            }
+
             if (InvokeCommands (binding.Commands, binding) is true)
             {
                 return true;
@@ -657,6 +666,12 @@ public partial class View // Keyboard APIs
             return null;
         }
 
+        // TODO: Should we set binding.Key = key if it's not set?
+        if (binding is {} && (binding.Key is null || !binding.Key.IsValid))
+        {
+            binding.Key = key;
+        }
+
         return InvokeCommands (binding.Commands, binding);
     }
 

Terminal.Gui/View/View.Mouse.cs

@@ -1,5 +1,6 @@
 #nullable enable
 using System.ComponentModel;
+using static Unix.Terminal.Delegates;
 
 namespace Terminal.Gui;
 
@@ -97,21 +98,35 @@ public partial class View // Mouse APIs
                 return args.Cancel;
             }
 
-            ColorScheme? cs = ColorScheme;
-
-            if (cs is null)
-            {
-                cs = new ();
-            }
+            ColorScheme? cs = _colorScheme;
 
             _savedNonHoverColorScheme = cs;
 
-            ColorScheme = ColorScheme?.GetHighlightColorScheme ();
+            _colorScheme = GetHighlightColorScheme ();
+            SetNeedsDraw ();
         }
 
         return false;
     }
 
+    /// <summary>
+    ///     Gets the <see cref="ColorScheme"/> to use when the view is highlighted. The highlight colorscheme
+    ///     is based on the current <see cref="ColorScheme"/>, using <see cref="Color.GetHighlightColor()"/>.
+    /// </summary>
+    /// <remarks>The highlight color scheme.</remarks>
+    public ColorScheme? GetHighlightColorScheme ()
+    {
+        ColorScheme? cs = _colorScheme ?? SuperView?.ColorScheme ?? new ColorScheme ();
+
+        return cs with
+        {
+            Normal = new (GetNormalColor ().Foreground.GetHighlightColor (), GetNormalColor ().Background),
+            HotNormal = new (GetHotNormalColor ().Foreground.GetHighlightColor (), GetHotNormalColor ().Background),
+            Focus = new (GetFocusColor ().Foreground.GetHighlightColor (), GetFocusColor ().Background),
+            HotFocus = new (GetHotFocusColor ().Foreground.GetHighlightColor (), GetHotFocusColor ().Background)
+        };
+    }
+
     /// <summary>
     ///     Called when the mouse moves over the View's <see cref="Frame"/> and no other non-SubView occludes it.
     ///     <see cref="MouseLeave"/> will
@@ -199,10 +214,12 @@ public partial class View // Mouse APIs
             var hover = HighlightStyle.None;
             RaiseHighlight (new (ref copy, ref hover));
 
-            if (_savedNonHoverColorScheme is { })
+            // if (_savedNonHoverColorScheme is { })
             {
-                ColorScheme = _savedNonHoverColorScheme;
+                _colorScheme = _savedNonHoverColorScheme;
                 _savedNonHoverColorScheme = null;
+                SetNeedsDraw ();
+
             }
         }
     }
@@ -715,9 +732,14 @@ public partial class View // Mouse APIs
 
         if (args.NewValue.HasFlag (HighlightStyle.Pressed) || args.NewValue.HasFlag (HighlightStyle.PressedOutside))
         {
-            if (_savedHighlightColorScheme is null && ColorScheme is { })
+            if (_savedHighlightColorScheme is null && _colorScheme is { })
             {
-                _savedHighlightColorScheme ??= ColorScheme;
+                _savedHighlightColorScheme = _colorScheme;
+
+                if (ColorScheme is null)
+                {
+                    return false;
+                }
 
                 if (CanFocus)
                 {
@@ -726,7 +748,7 @@ public partial class View // Mouse APIs
                         // Highlight the foreground focus color
                         Focus = new (ColorScheme.Focus.Foreground.GetHighlightColor (), ColorScheme.Focus.Background.GetHighlightColor ())
                     };
-                    ColorScheme = cs;
+                    _colorScheme = cs;
                 }
                 else
                 {
@@ -735,7 +757,7 @@ public partial class View // Mouse APIs
                         // Invert Focus color foreground/background. We can do this because we know the view is not going to be focused.
                         Normal = new (ColorScheme.Focus.Background, ColorScheme.Normal.Foreground)
                     };
-                    ColorScheme = cs;
+                    _colorScheme = cs;
                 }
             }
 
@@ -746,11 +768,9 @@ public partial class View // Mouse APIs
         if (args.NewValue == HighlightStyle.None)
         {
             // Unhighlight
-            if (_savedHighlightColorScheme is { })
-            {
-                ColorScheme = _savedHighlightColorScheme;
-                _savedHighlightColorScheme = null;
-            }
+            _colorScheme = _savedHighlightColorScheme;
+            _savedHighlightColorScheme = null;
+            SetNeedsDraw ();
         }
 
         return false;
@@ -771,7 +791,7 @@ public partial class View // Mouse APIs
         View? start = Application.Top;
 
         // PopoverHost - If visible, start with it instead of Top
-        if (Application.Popover?.GetActivePopover () is View {Visible: true } visiblePopover && !ignoreTransparent)
+        if (Application.Popover?.GetActivePopover () is View { Visible: true } visiblePopover && !ignoreTransparent)
         {
             start = visiblePopover;
 
@@ -783,7 +803,7 @@ public partial class View // Mouse APIs
 
         while (start is { Visible: true } && start.Contains (currentLocation))
         {
-            if (!start.ViewportSettings.HasFlag(ViewportSettings.TransparentMouse))
+            if (!start.ViewportSettings.HasFlag (ViewportSettings.TransparentMouse))
             {
                 viewsUnderMouse.Add (start);
             }

Terminal.Gui/View/View.Navigation.cs

@@ -245,7 +245,7 @@ public partial class View // Focus and cross-view navigation management (TabStop
             {
                 // If CanFocus is set to false and this view has focus, make it leave focus
                 // Set transversing down so we don't go back up the hierarchy...
-                SetHasFocusFalse (null, false);
+                SetHasFocusFalse (null);
             }
 
             if (_canFocus && !HasFocus && Visible && SuperView is { Focused: null })
@@ -319,7 +319,7 @@ public partial class View // Focus and cross-view navigation management (TabStop
     {
         //Logging.Trace($"RaiseFocusedChanged: {focused.Title}");
         OnFocusedChanged (previousFocused, focused);
-        FocusedChanged?.Invoke (this, new HasFocusEventArgs (true, true, previousFocused, focused));
+        FocusedChanged?.Invoke (this, new (true, true, previousFocused, focused));
     }
 
     /// <summary>
@@ -395,10 +395,7 @@ public partial class View // Focus and cross-view navigation management (TabStop
     /// <summary>
     ///     Clears any focus state (e.g. the previously focused subview) from this view.
     /// </summary>
-    public void ClearFocus ()
-    {
-        _previouslyFocused = null;
-    }
+    public void ClearFocus () { _previouslyFocused = null; }
 
     private View? FindDeepestFocusableView (NavigationDirection direction, TabBehavior? behavior)
     {
@@ -523,11 +520,17 @@ public partial class View // Focus and cross-view navigation management (TabStop
     /// <exception cref="InvalidOperationException"></exception>
     private (bool focusSet, bool cancelled) SetHasFocusTrue (View? currentFocusedView, bool traversingUp = false)
     {
-        Debug.Assert (SuperView is null || View.IsInHierarchy (SuperView, this));
+        Debug.Assert (SuperView is null || IsInHierarchy (SuperView, this));
 
         // Pre-conditions
         if (_hasFocus)
         {
+            //// See https://github.com/gui-cs/Terminal.Gui/pull/4013#issuecomment-2823934197
+            //if (Application.Navigation is { } && (Application.Navigation.GetFocused () == this || Application.Navigation.GetFocused () == MostFocused))
+            //{
+            //    throw new InvalidOperationException (@"Do not SetFocus on a view that is already MostFocused.");
+            //}
+
             return (false, false);
         }
 

Terminal.Gui/View/View.Text.cs

@@ -68,12 +68,6 @@ public partial class View // Text Property APIs
 
             UpdateTextFormatterText ();
             SetNeedsLayout ();
-#if DEBUG
-            if (_text is { } && string.IsNullOrEmpty (Id))
-            {
-                Id = _text;
-            }
-#endif
             OnTextChanged ();
         }
     }

Terminal.Gui/View/View.cs

@@ -1,4 +1,5 @@
 #nullable enable
+using System.Collections.Concurrent;
 using System.ComponentModel;
 using System.Diagnostics;
 
@@ -31,28 +32,15 @@ public partial class View : IDisposable, ISupportInitializeNotification
     {
         // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
         Disposing?.Invoke (this, EventArgs.Empty);
+
         Dispose (true);
         GC.SuppressFinalize (this);
+
 #if DEBUG_IDISPOSABLE
-        if (DebugIDisposable)
-        {
-            WasDisposed = true;
-
-            foreach (View? instance in Instances.Where (
-                                                        x =>
-                                                        {
-                                                            if (x is { })
-                                                            {
-                                                                return x.WasDisposed;
-                                                            }
-
-                                                            return false;
-                                                        })
-                                                .ToList ())
-            {
-                Instances.Remove (instance);
-            }
-        }
+        WasDisposed = true;
+        // Safely remove any disposed views from the Instances list
+        List<View> itemsToKeep = Instances.Where (view => !view.WasDisposed).ToList ();
+        Instances = new ConcurrentBag<View> (itemsToKeep);
 #endif
     }
 
@@ -74,31 +62,34 @@ public partial class View : IDisposable, ISupportInitializeNotification
     /// <param name="disposing"></param>
     protected virtual void Dispose (bool disposing)
     {
-        LineCanvas.Dispose ();
+        if (disposing)
+        {
+            LineCanvas.Dispose ();
 
-        DisposeMouse ();
-        DisposeKeyboard ();
-        DisposeAdornments ();
-        DisposeScrollBars ();
+            DisposeMouse ();
+            DisposeKeyboard ();
+            DisposeAdornments ();
+            DisposeScrollBars ();
 
-        for (int i = InternalSubViews.Count - 1; i >= 0; i--)
-        {
-            View subview = InternalSubViews [i];
-            Remove (subview);
-            subview.Dispose ();
-        }
+            for (int i = InternalSubViews.Count - 1; i >= 0; i--)
+            {
+                View subview = InternalSubViews [i];
+                Remove (subview);
+                subview.Dispose ();
+            }
 
-        if (!_disposedValue)
-        {
-            if (disposing)
+            if (!_disposedValue)
             {
-                // TODO: dispose managed state (managed objects)
+                if (disposing)
+                {
+                    // TODO: dispose managed state (managed objects)
+                }
+
+                _disposedValue = true;
             }
 
-            _disposedValue = true;
+            Debug.Assert (InternalSubViews.Count == 0);
         }
-
-        Debug.Assert (InternalSubViews.Count == 0);
     }
 
     #region Constructors and Initialization
@@ -128,10 +119,7 @@ public partial class View : IDisposable, ISupportInitializeNotification
     public View ()
     {
 #if DEBUG_IDISPOSABLE
-        if (DebugIDisposable)
-        {
-            Instances.Add (this);
-        }
+        Instances.Add (this);
 #endif
 
         SetupAdornments ();
@@ -338,7 +326,7 @@ public partial class View : IDisposable, ISupportInitializeNotification
             if (!_visible)
             {
                 // BUGBUG: Ideally we'd reset _previouslyFocused to the first focusable subview
-                _previouslyFocused = SubViews.FirstOrDefault(v => v.CanFocus);
+                _previouslyFocused = SubViews.FirstOrDefault (v => v.CanFocus);
                 if (HasFocus)
                 {
                     HasFocus = false;
@@ -445,18 +433,12 @@ public partial class View : IDisposable, ISupportInitializeNotification
     {
         get
         {
-#if DEBUG_IDISPOSABLE
-            if (DebugIDisposable && WasDisposed)
-            {
-                throw new ObjectDisposedException (GetType ().FullName);
-            }
-#endif
             return _title;
         }
         set
         {
 #if DEBUG_IDISPOSABLE
-            if (DebugIDisposable && WasDisposed)
+            if (EnableDebugIDisposableAsserts && WasDisposed)
             {
                 throw new ObjectDisposedException (GetType ().FullName);
             }
@@ -475,12 +457,6 @@ public partial class View : IDisposable, ISupportInitializeNotification
                 SetTitleTextFormatterSize ();
                 SetHotKeyFromTitle ();
                 SetNeedsDraw ();
-#if DEBUG
-                if (string.IsNullOrEmpty (Id))
-                {
-                    Id = _title;
-                }
-#endif // DEBUG
                 OnTitleChanged ();
             }
         }
@@ -527,17 +503,34 @@ public partial class View : IDisposable, ISupportInitializeNotification
 
 #if DEBUG_IDISPOSABLE
     /// <summary>
-    ///     Set to false to disable the debug IDisposable feature.
+    ///     Gets or sets whether failure to appropriately call Dispose() on a View will result in an Assert.
+    ///     The default is <see langword="true"/>.
+    ///     Note, this is a static property and will affect all Views.
+    ///     For debug purposes to verify objects are being disposed properly.
+    ///     Only valid when DEBUG_IDISPOSABLE is defined.
     /// </summary>
-    public static bool DebugIDisposable { get; set; } = false;
+    public static bool EnableDebugIDisposableAsserts { get; set; } = true;
 
-    /// <summary>For debug purposes to verify objects are being disposed properly</summary>
-    public bool WasDisposed { get; set; }
+    /// <summary>
+    ///     Gets whether <see cref="Dispose"/> was called on this view or not.
+    ///     For debug purposes to verify objects are being disposed properly.
+    ///     Only valid when DEBUG_IDISPOSABLE is defined.
+    /// </summary>
+    public bool WasDisposed { get; private set; }
 
-    /// <summary>For debug purposes to verify objects are being disposed properly</summary>
-    public int DisposedCount { get; set; } = 0;
+    /// <summary>
+    ///     Gets the number of times <see cref="Dispose"/> was called on this view.
+    ///     For debug purposes to verify objects are being disposed properly.
+    ///     Only valid when DEBUG_IDISPOSABLE is defined.
+    /// </summary>
+    public int DisposedCount { get; private set; } = 0;
 
-    /// <summary>For debug purposes</summary>
-    public static List<View> Instances { get; set; } = [];
+    /// <summary>
+    ///     Gets the list of Views that have been created and not yet disposed.
+    ///     Note, this is a static property and will affect all Views.
+    ///     For debug purposes to verify objects are being disposed properly.
+    ///     Only valid when DEBUG_IDISPOSABLE is defined.
+    /// </summary>
+    public static ConcurrentBag<View> Instances { get; private set; } = [];
 #endif
 }

Terminal.Gui/Views/Bar.cs

@@ -74,24 +74,6 @@ public class Bar : View, IOrientation, IDesignable
         }
     }
 
-    /// <inheritdoc />
-    public override void EndInit ()
-    {
-        base.EndInit ();
-        ColorScheme = Colors.ColorSchemes ["Menu"];
-    }
-
-    /// <inheritdoc/>
-    public override void SetBorderStyle (LineStyle lineStyle)
-    {
-        if (Border is { })
-        {
-            // The default changes the thickness. We don't want that. We just set the style.
-           Border.LineStyle = lineStyle;
-        }
-        //base.SetBorderStyle(lineStyle);
-    }
-
     #region IOrientation members
 
     /// <summary>
@@ -216,7 +198,7 @@ public class Bar : View, IOrientation, IDesignable
                 {
                     View barItem = SubViews.ElementAt (index);
 
-                    barItem.ColorScheme = ColorScheme;
+                    //barItem.ColorScheme = ColorScheme;
                     barItem.X = Pos.Align (Alignment.Start, AlignmentModes);
                     barItem.Y = 0; //Pos.Center ();
 
@@ -235,7 +217,7 @@ public class Bar : View, IOrientation, IDesignable
 
                     var minKeyWidth = 0;
 
-                    List<Shortcut> shortcuts = SubViews.Where (s => s is Shortcut && s.Visible).Cast<Shortcut> ().ToList ();
+                    List<Shortcut> shortcuts = SubViews.OfType<Shortcut> ().Where (s => s.Visible).ToList ();
 
                     foreach (Shortcut shortcut in shortcuts)
                     {
@@ -250,7 +232,7 @@ public class Bar : View, IOrientation, IDesignable
                         View barItem = SubViews.ElementAt (index);
 
 
-                        barItem.ColorScheme = ColorScheme;
+                       // barItem.ColorScheme = ColorScheme;
 
                         if (!barItem.Visible)
                         {

Terminal.Gui/Views/CheckBox.cs

@@ -1,7 +1,12 @@
 #nullable enable
 namespace Terminal.Gui;
 
-/// <summary>Shows a check box that can be cycled between two or three states.</summary>
+/// <summary>Shows a checkbox that can be cycled between two or three states.</summary>
+/// <remarks>
+///     <para>
+///         <see cref="RadioStyle"/> is used to display radio button style glyphs (●) instead of checkbox style glyphs (☑).
+///     </para>
+/// </remarks>
 public class CheckBox : View
 {
     /// <summary>
@@ -250,22 +255,23 @@ public class CheckBox : View
     {
         base.UpdateTextFormatterText ();
 
+        Rune glyph = RadioStyle ? GetRadioGlyph () : GetCheckGlyph ();
         switch (TextAlignment)
         {
             case Alignment.Start:
             case Alignment.Center:
             case Alignment.Fill:
-                TextFormatter.Text = $"{GetCheckedGlyph ()} {Text}";
+                TextFormatter.Text = $"{glyph} {Text}";
 
                 break;
             case Alignment.End:
-                TextFormatter.Text = $"{Text} {GetCheckedGlyph ()}";
+                TextFormatter.Text = $"{Text} {glyph}";
 
                 break;
         }
     }
 
-    private Rune GetCheckedGlyph ()
+    private Rune GetCheckGlyph ()
     {
         return CheckedState switch
         {
@@ -275,4 +281,21 @@ public class CheckBox : View
             _ => throw new ArgumentOutOfRangeException ()
         };
     }
+
+    /// <summary>
+    ///     If <see langword="true"/>, the <see cref="CheckBox"/> will display radio button style glyphs (●) instead of
+    ///     checkbox style glyphs (☑).
+    /// </summary>
+    public bool RadioStyle { get; set; }
+
+    private Rune GetRadioGlyph ()
+    {
+        return CheckedState switch
+               {
+                   CheckState.Checked => Glyphs.Selected,
+                   CheckState.UnChecked => Glyphs.UnSelected,
+                   CheckState.None => Glyphs.Dot,
+                   _ => throw new ArgumentOutOfRangeException ()
+               };
+    }
 }

Terminal.Gui/Views/Dialog.cs

@@ -107,7 +107,7 @@ public class Dialog : Window
         get
         {
 #if DEBUG_IDISPOSABLE
-            if (View.DebugIDisposable && WasDisposed)
+            if (View.EnableDebugIDisposableAsserts && WasDisposed)
             {
                 throw new ObjectDisposedException (GetType ().FullName);
             }
@@ -117,7 +117,7 @@ public class Dialog : Window
         set
         {
 #if DEBUG_IDISPOSABLE
-            if (View.DebugIDisposable && WasDisposed)
+            if (View.EnableDebugIDisposableAsserts && WasDisposed)
             {
                 throw new ObjectDisposedException (GetType ().FullName);
             }

Terminal.Gui/Views/FlagSelector.cs

@@ -1,12 +1,11 @@
 #nullable enable
 namespace Terminal.Gui;
 
-
 /// <summary>
 ///     Provides a user interface for displaying and selecting flags.
 ///     Flags can be set from a dictionary or directly from an enum type.
 /// </summary>
-public class FlagSelector : View, IDesignable, IOrientation
+public class FlagSelector : View, IOrientation, IDesignable
 {
     /// <summary>
     ///     Initializes a new instance of the <see cref="FlagSelector"/> class.
@@ -25,17 +24,17 @@ public class FlagSelector : View, IDesignable, IOrientation
         // Accept (Enter key or DoubleClick) - Raise Accept event - DO NOT advance state
         AddCommand (Command.Accept, HandleAcceptCommand);
 
-        CreateSubViews ();
+        CreateCheckBoxes ();
     }
 
     private bool? HandleAcceptCommand (ICommandContext? ctx) { return RaiseAccepting (ctx); }
 
-    private uint _value;
+    private uint? _value;
 
     /// <summary>
     /// Gets or sets the value of the selected flags.
     /// </summary>
-    public uint Value
+    public uint? Value
     {
         get => _value;
         set
@@ -47,19 +46,19 @@ public class FlagSelector : View, IDesignable, IOrientation
 
             _value = value;
 
-            if (_value == 0)
+            if (_value is null)
             {
+                UncheckNone ();
                 UncheckAll ();
             }
             else
             {
-                UncheckNone ();
                 UpdateChecked ();
             }
 
             if (ValueEdit is { })
             {
-                ValueEdit.Text = value.ToString ();
+                ValueEdit.Text = _value.ToString ();
             }
 
             RaiseValueChanged ();
@@ -69,7 +68,10 @@ public class FlagSelector : View, IDesignable, IOrientation
     private void RaiseValueChanged ()
     {
         OnValueChanged ();
-        ValueChanged?.Invoke (this, new (Value));
+        if (Value.HasValue)
+        {
+            ValueChanged?.Invoke (this, new EventArgs<uint> (Value.Value));
+        }
     }
 
     /// <summary>
@@ -99,7 +101,7 @@ public class FlagSelector : View, IDesignable, IOrientation
 
             _styles = value;
 
-            CreateSubViews ();
+            CreateCheckBoxes ();
         }
     }
 
@@ -107,12 +109,14 @@ public class FlagSelector : View, IDesignable, IOrientation
     ///     Set the flags and flag names.
     /// </summary>
     /// <param name="flags"></param>
-    public void SetFlags (IReadOnlyDictionary<uint, string> flags)
+    public virtual void SetFlags (IReadOnlyDictionary<uint, string> flags)
     {
         Flags = flags;
-        CreateSubViews ();
+        CreateCheckBoxes ();
+        UpdateChecked ();
     }
 
+
     /// <summary>
     ///     Set the flags and flag names from an enum type.
     /// </summary>
@@ -167,27 +171,66 @@ public class FlagSelector : View, IDesignable, IOrientation
         SetFlags (flagsDictionary);
     }
 
+    private IReadOnlyDictionary<uint, string>? _flags;
+
     /// <summary>
-    ///     Gets the flags.
+    ///     Gets the flag values and names.
     /// </summary>
-    public IReadOnlyDictionary<uint, string>? Flags { get; internal set; }
+    public IReadOnlyDictionary<uint, string>? Flags
+    {
+        get => _flags;
+        internal set
+        {
+            _flags = value;
+
+            if (_value is null)
+            {
+               Value = Convert.ToUInt16 (_flags?.Keys.ElementAt (0));
+            }
+        }
+    }
 
     private TextField? ValueEdit { get; set; }
 
-    private void CreateSubViews ()
+    private bool _assignHotKeysToCheckBoxes;
+
+    /// <summary>
+    ///     If <see langword="true"/> the CheckBoxes will each be automatically assigned a hotkey.
+    ///     <see cref="UsedHotKeys"/> will be used to ensure unique keys are assigned. Set <see cref="UsedHotKeys"/>
+    ///     before setting <see cref="Flags"/> with any hotkeys that may conflict with other Views.
+    /// </summary>
+    public bool AssignHotKeysToCheckBoxes
     {
-        if (Flags is null)
+        get => _assignHotKeysToCheckBoxes;
+        set
         {
-            return;
+            if (_assignHotKeysToCheckBoxes == value)
+            {
+                return;
+            }
+            _assignHotKeysToCheckBoxes = value;
+            CreateCheckBoxes ();
+            UpdateChecked();
         }
+    }
 
-        View [] subviews = SubViews.ToArray ();
+    /// <summary>
+    ///     Gets the list of hotkeys already used by the CheckBoxes or that should not be used if
+    ///     <see cref="AssignHotKeysToCheckBoxes"/>
+    ///     is enabled.
+    /// </summary>
+    public List<Key> UsedHotKeys { get; } = [];
 
-        RemoveAll ();
+    private void CreateCheckBoxes ()
+    {
+        if (Flags is null)
+        {
+            return;
+        }
 
-        foreach (View v in subviews)
+        foreach (CheckBox cb in RemoveAll<CheckBox> ())
         {
-            v.Dispose ();
+            cb.Dispose ();
         }
 
         if (Styles.HasFlag (FlagSelectorStyles.ShowNone) && !Flags.ContainsKey (0))
@@ -213,7 +256,7 @@ public class FlagSelector : View, IDesignable, IOrientation
                 CanFocus = false,
                 Text = Value.ToString (),
                 Width = 5,
-                ReadOnly = true
+                ReadOnly = true,
             };
 
             Add (ValueEdit);
@@ -223,48 +266,146 @@ public class FlagSelector : View, IDesignable, IOrientation
 
         return;
 
-        CheckBox CreateCheckBox (string name, uint flag)
+
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="name"></param>
+    /// <param name="flag"></param>
+    /// <returns></returns>
+    protected virtual CheckBox CreateCheckBox (string name, uint flag)
+    {
+        string nameWithHotKey = name;
+        if (AssignHotKeysToCheckBoxes)
         {
-            var checkbox = new CheckBox
+            // Find the first char in label that is [a-z], [A-Z], or [0-9]
+            for (var i = 0; i < name.Length; i++)
             {
-                CanFocus = false,
-                Title = name,
-                Id = name,
-                Data = flag,
-                HighlightStyle = HighlightStyle
-            };
-
-            checkbox.Selecting += (sender, args) => { RaiseSelecting (args.Context); };
+                char c = char.ToLowerInvariant (name [i]);
+                if (UsedHotKeys.Contains (new (c)) || !char.IsAsciiLetterOrDigit (c))
+                {
+                    continue;
+                }
+
+                if (char.IsAsciiLetterOrDigit (c))
+                {
+                    char? hotChar = c;
+                    nameWithHotKey = name.Insert (i, HotKeySpecifier.ToString ());
+                    UsedHotKeys.Add (new (hotChar));
+
+                    break;
+                }
+            }
+        }
 
-            checkbox.CheckedStateChanged += (sender, args) =>
+        var checkbox = new CheckBox
+        {
+            CanFocus = true,
+            Title = nameWithHotKey,
+            Id = name,
+            Data = flag,
+            HighlightStyle = HighlightStyle.Hover
+        };
+
+        checkbox.GettingNormalColor += (_, e) =>
+                                       {
+                                           if (SuperView is { HasFocus: true })
+                                           {
+                                               e.Cancel = true;
+
+                                               if (!HasFocus)
+                                               {
+                                                   e.NewValue = GetFocusColor ();
+                                               }
+                                               else
+                                               {
+                                                   // If _colorScheme was set, it's because of Hover
+                                                   if (checkbox._colorScheme is { })
+                                                   {
+                                                       e.NewValue = checkbox._colorScheme.Normal;
+                                                   }
+                                                   else
+                                                   {
+                                                       e.NewValue = GetNormalColor ();
+                                                   }
+                                               }
+                                           }
+                                       };
+
+        checkbox.GettingHotNormalColor += (_, e) =>
+                                          {
+                                              if (SuperView is { HasFocus: true })
+                                              {
+                                                  e.Cancel = true;
+                                                  if (!HasFocus)
+                                                  {
+                                                      e.NewValue = GetHotFocusColor ();
+                                                  }
+                                                  else
+                                                  {
+                                                      e.NewValue = GetHotNormalColor ();
+                                                  }
+                                              }
+                                          };
+
+        //checkbox.GettingFocusColor += (_, e) =>
+        //                                  {
+        //                                      if (SuperView is { HasFocus: true })
+        //                                      {
+        //                                          e.Cancel = true;
+        //                                          if (!HasFocus)
+        //                                          {
+        //                                              e.NewValue = GetNormalColor ();
+        //                                          }
+        //                                          else
+        //                                          {
+        //                                              e.NewValue = GetFocusColor ();
+        //                                          }
+        //                                      }
+        //                                  };
+
+        checkbox.Selecting += (sender, args) =>
+                              {
+                                  if (RaiseSelecting (args.Context) is true)
+                                  {
+                                      args.Cancel = true;
+
+                                      return;
+                                  };
+
+                                  if (RaiseAccepting (args.Context) is true)
+                                  {
+                                      args.Cancel = true;
+                                  }
+                              };
+
+        checkbox.CheckedStateChanged += (sender, args) =>
+                                        {
+                                            uint? newValue = Value;
+
+                                            if (checkbox.CheckedState == CheckState.Checked)
                                             {
-                                                uint newValue = Value;
-
-                                                if (checkbox.CheckedState == CheckState.Checked)
+                                                if (flag == default!)
                                                 {
-                                                    if ((uint)checkbox.Data == 0)
-                                                    {
-                                                        newValue = 0;
-                                                    }
-                                                    else
-                                                    {
-                                                        newValue |= flag;
-                                                    }
+                                                    newValue = 0;
                                                 }
                                                 else
                                                 {
-                                                    newValue &= ~flag;
+                                                    newValue = newValue | flag;
                                                 }
+                                            }
+                                            else
+                                            {
+                                                newValue = newValue & ~flag;
+                                            }
 
-                                                Value = newValue;
-
-                                                //UpdateChecked();
-                                            };
+                                            Value = newValue;
+                                        };
 
-            return checkbox;
-        }
+        return checkbox;
     }
-
     private void SetLayout ()
     {
         foreach (View sv in SubViews)
@@ -285,7 +426,7 @@ public class FlagSelector : View, IDesignable, IOrientation
 
     private void UncheckAll ()
     {
-        foreach (CheckBox cb in SubViews.Where (sv => sv is CheckBox cb && cb.Title != "None").Cast<CheckBox> ())
+        foreach (CheckBox cb in SubViews.OfType<CheckBox> ().Where (sv => (uint)(sv.Data ?? default!) != default!))
         {
             cb.CheckedState = CheckState.UnChecked;
         }
@@ -293,7 +434,7 @@ public class FlagSelector : View, IDesignable, IOrientation
 
     private void UncheckNone ()
     {
-        foreach (CheckBox cb in SubViews.Where (sv => sv is CheckBox { Title: "None" }).Cast<CheckBox> ())
+        foreach (CheckBox cb in SubViews.OfType<CheckBox> ().Where (sv => sv.Title != "None"))
         {
             cb.CheckedState = CheckState.UnChecked;
         }
@@ -301,7 +442,7 @@ public class FlagSelector : View, IDesignable, IOrientation
 
     private void UpdateChecked ()
     {
-        foreach (CheckBox cb in SubViews.Where (sv => sv is CheckBox { }).Cast<CheckBox> ())
+        foreach (CheckBox cb in SubViews.OfType<CheckBox> ())
         {
             var flag = (uint)(cb.Data ?? throw new InvalidOperationException ("ComboBox.Data must be set"));
 
@@ -317,8 +458,6 @@ public class FlagSelector : View, IDesignable, IOrientation
         }
     }
 
-    /// <inheritdoc/>
-    protected override void OnSubViewAdded (View view) { }
 
     #region IOrientation
 
@@ -342,8 +481,6 @@ public class FlagSelector : View, IDesignable, IOrientation
     public event EventHandler<EventArgs<Orientation>>? OrientationChanged;
 #pragma warning restore CS0067 // The event is never used
 
-#pragma warning restore CS0067
-
     /// <summary>Called when <see cref="Orientation"/> has changed.</summary>
     /// <param name="newOrientation"></param>
     public void OnOrientationChanged (Orientation newOrientation) { SetLayout (); }
@@ -353,12 +490,14 @@ public class FlagSelector : View, IDesignable, IOrientation
     /// <inheritdoc/>
     public bool EnableForDesign ()
     {
+        Styles = FlagSelectorStyles.All;
         SetFlags<FlagSelectorStyles> (
                                       f => f switch
                                            {
-                                               FlagSelectorStyles.ShowNone => "Show _None Value",
-                                               FlagSelectorStyles.ShowValueEdit => "Show _Value Editor",
-                                               FlagSelectorStyles.All => "Show _All Flags Selector",
+                                               FlagSelectorStyles.None => "_No Style",
+                                               FlagSelectorStyles.ShowNone => "_Show None Value Style",
+                                               FlagSelectorStyles.ShowValueEdit => "Show _Value Editor Style",
+                                               FlagSelectorStyles.All => "_All Styles",
                                                _ => f.ToString ()
                                            });
 

Terminal.Gui/Views/FlagSelectorTEnum.cs

@@ -0,0 +1,99 @@
+#nullable enable
+namespace Terminal.Gui;
+
+/// <summary>
+///     Provides a user interface for displaying and selecting flags.
+///     Flags can be set from a dictionary or directly from an enum type.
+/// </summary>
+public sealed class FlagSelector<TEnum> : FlagSelector where TEnum : struct, Enum
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="FlagSelector{TEnum}"/> class.
+    /// </summary>
+    public FlagSelector ()
+    {
+        SetFlags ();
+    }
+
+    /// <summary>
+    /// Gets or sets the value of the selected flags.
+    /// </summary>
+    public new TEnum? Value
+    {
+        get => base.Value.HasValue ? (TEnum)Enum.ToObject (typeof (TEnum), base.Value.Value) : (TEnum?)null;
+        set => base.Value = value.HasValue ? Convert.ToUInt32 (value.Value) : (uint?)null;
+    }
+
+    /// <summary>
+    ///     Set the display names for the flags.
+    /// </summary>
+    /// <param name="nameSelector">A function that converts enum values to display names</param>
+    /// <remarks>
+    ///     This method allows changing the display names of the flags while keeping the flag values hard-defined by the enum type.
+    /// </remarks>
+    /// <example>
+    ///     <code>
+    ///        // Use enum values with custom display names
+    ///        var flagSelector = new FlagSelector&lt;FlagSelectorStyles&gt;();
+    ///        flagSelector.SetFlagNames(f => f switch {
+    ///             FlagSelectorStyles.ShowNone => "Show None Value",
+    ///             FlagSelectorStyles.ShowValueEdit => "Show Value Editor",
+    ///             FlagSelectorStyles.All => "Everything",
+    ///             _ => f.ToString()
+    ///        });
+    ///     </code>
+    /// </example>
+    public void SetFlagNames (Func<TEnum, string> nameSelector)
+    {
+        Dictionary<uint, string> flagsDictionary = Enum.GetValues<TEnum> ()
+                                                       .ToDictionary (f => Convert.ToUInt32 (f), nameSelector);
+        base.SetFlags (flagsDictionary);
+    }
+
+    private void SetFlags ()
+    {
+        Dictionary<uint, string> flagsDictionary = Enum.GetValues<TEnum> ()
+                                                       .ToDictionary (f => Convert.ToUInt32 (f), f => f.ToString ());
+        base.SetFlags (flagsDictionary);
+    }
+
+    /// <summary>
+    ///     Prevents calling the base SetFlags method with arbitrary flag values.
+    /// </summary>
+    /// <param name="flags"></param>
+    public override void SetFlags (IReadOnlyDictionary<uint, string> flags)
+    {
+        throw new InvalidOperationException ("Setting flag values directly is not allowed. Use SetFlagNames to change display names.");
+    }
+
+    /// <inheritdoc />
+    protected override CheckBox CreateCheckBox (string name, uint flag)
+    {
+        var checkbox = base.CreateCheckBox (name, flag);
+        checkbox.CheckedStateChanged += (sender, args) =>
+                                        {
+                                            TEnum? newValue = Value;
+
+                                            if (checkbox.CheckedState == CheckState.Checked)
+                                            {
+                                                if (flag == default!)
+                                                {
+                                                    newValue = new TEnum ();
+                                                }
+                                                else
+                                                {
+                                                    newValue = (TEnum)Enum.ToObject (typeof (TEnum), Convert.ToUInt32 (newValue) | flag);
+                                                }
+                                            }
+                                            else
+                                            {
+                                                newValue = (TEnum)Enum.ToObject (typeof (TEnum), Convert.ToUInt32 (newValue) & ~flag);
+                                            }
+
+                                            Value = newValue;
+                                        };
+
+        return checkbox;
+    }
+
+}

Terminal.Gui/Views/ListView.cs

@@ -807,34 +807,41 @@ public class ListView : View, IDesignable
     }
 
     /// <inheritdoc/>
-    protected override bool OnKeyDown (Key a)
+    protected override bool OnKeyDown (Key key)
     {
         // If marking is enabled and the user presses the space key don't let CollectionNavigator
         // at it
         if (AllowsMarking)
         {
-            var keys = KeyBindings.GetAllFromCommands (Command.Select);
+            IEnumerable<Key> keys = KeyBindings.GetAllFromCommands (Command.Select);
 
-            if (keys.Contains (a))
+            if (keys.Contains (key))
             {
                 return false;
             }
 
             keys = KeyBindings.GetAllFromCommands ([Command.Select, Command.Down]);
 
-            if (keys.Contains (a))
+            if (keys.Contains (key))
             {
                 return false;
             }
 
         }
 
+        // If the key was bound to a command, invoke the command. This enables overriding the default handling.
+        // See: https://github.com/gui-cs/Terminal.Gui/issues/3950#issuecomment-2807350939
+        if (KeyBindings.TryGet (key, out _))
+        {
+            return false;
+        }
+
         // Enable user to find & select an item by typing text
-        if (CollectionNavigatorBase.IsCompatibleKey (a))
+        if (CollectionNavigatorBase.IsCompatibleKey (key))
         {
-            int? newItem = KeystrokeNavigator?.GetNextMatchingItem (SelectedItem, (char)a);
+            int? newItem = KeystrokeNavigator?.GetNextMatchingItem (SelectedItem, (char)key);
 
-            if (newItem is int && newItem != -1)
+            if (newItem is { } && newItem != -1)
             {
                 SelectedItem = (int)newItem;
                 EnsureSelectedItemVisible ();

Terminal.Gui/Views/Menu/MenuBarItemv2.cs

@@ -4,7 +4,7 @@ namespace Terminal.Gui;
 
 /// <summary>
 ///     A <see cref="Shortcut"/>-derived object to be used as items in a <see cref="MenuBarv2"/>.
-///     MenuBarItems have a title, a hotkey, and an action to execute on activation.
+///     MenuBarItems hold a <see cref="PopoverMenu"/> instead of a <see cref="SubMenu"/>.
 /// </summary>
 public class MenuBarItemv2 : MenuItemv2
 {
@@ -74,7 +74,7 @@ public class MenuBarItemv2 : MenuItemv2
                 null,
                 Command.NotBound,
                 commandText,
-                new (menuItems))
+                new (menuItems) { Title = $"PopoverMenu for {commandText}" })
     { }
 
     /// <summary>
@@ -87,10 +87,81 @@ public class MenuBarItemv2 : MenuItemv2
         set => throw new InvalidOperationException ("MenuBarItem does not support SubMenu. Use PopoverMenu instead.");
     }
 
+    private PopoverMenu? _popoverMenu;
+
     /// <summary>
     ///     The Popover Menu that will be displayed when this item is selected.
     /// </summary>
-    public PopoverMenu? PopoverMenu { get; set; }
+    public PopoverMenu? PopoverMenu
+    {
+        get => _popoverMenu;
+        set
+        {
+            if (_popoverMenu == value)
+            {
+                return;
+            }
+
+            if (_popoverMenu is { })
+            {
+                _popoverMenu.VisibleChanged -= OnPopoverVisibleChanged;
+                _popoverMenu.Accepted -= OnPopoverMenuOnAccepted;
+            }
+
+            _popoverMenu = value;
+
+            if (_popoverMenu is { })
+            {
+                PopoverMenuOpen = _popoverMenu.Visible;
+                _popoverMenu.VisibleChanged += OnPopoverVisibleChanged;
+                _popoverMenu.Accepted += OnPopoverMenuOnAccepted;
+            }
+
+            return;
+
+            void OnPopoverVisibleChanged (object? sender, EventArgs args)
+            {
+                Logging.Debug ($"OnPopoverVisibleChanged - {Title} - Visible = {_popoverMenu?.Visible} ");
+                PopoverMenuOpen = _popoverMenu?.Visible ?? false;
+            }
+
+            void OnPopoverMenuOnAccepted (object? sender, CommandEventArgs args)
+            {
+                Logging.Debug ($"OnPopoverMenuOnAccepted - {Title} - {args.Context?.Source?.Title} - {args.Context?.Command}");
+                RaiseAccepted (args.Context);
+            }
+        }
+    }
+
+    private bool _popoverMenuOpen;
+
+    /// <summary>
+    ///     Gets or sets whether the MenuBarItem is active. This is used to determine if the MenuBarItem should be
+    /// </summary>
+    public bool PopoverMenuOpen
+    {
+        get => _popoverMenuOpen;
+        set
+        {
+            if (_popoverMenuOpen == value)
+            {
+                return;
+            }
+            _popoverMenuOpen = value;
+
+            RaisePopoverMenuOpenChanged();
+        }
+    }
+
+    public void RaisePopoverMenuOpenChanged ()
+    {
+        OnPopoverMenuOpenChanged();
+        PopoverMenuOpenChanged?.Invoke (this, new EventArgs<bool> (PopoverMenuOpen));
+    }
+
+    protected virtual void OnPopoverMenuOpenChanged () {}
+
+    public event EventHandler<EventArgs<bool>>? PopoverMenuOpenChanged;
 
     /// <inheritdoc />
     protected override bool OnKeyDownNotHandled (Key key)
@@ -112,6 +183,12 @@ public class MenuBarItemv2 : MenuItemv2
         return false;
     }
 
+    /// <inheritdoc/>
+    protected override void OnHasFocusChanged (bool newHasFocus, View? previousFocusedView, View? focusedView)
+    {
+        Logging.Debug ($"CanFocus = {CanFocus}, HasFocus = {HasFocus}");
+    }
+
     /// <inheritdoc/>
     protected override void Dispose (bool disposing)
     {

Terminal.Gui/Views/Menu/MenuBarv2.cs

@@ -24,27 +24,38 @@ public class MenuBarv2 : Menuv2, IDesignable
         TabStop = TabBehavior.TabGroup;
         Y = 0;
         Width = Dim.Fill ();
+        Height = Dim.Auto ();
         Orientation = Orientation.Horizontal;
 
         Key = DefaultKey;
-        AddCommand (Command.HotKey,
-                   () =>
-                   {
-                       if (HideActiveItem ())
-                       {
-                           return true;
-                       }
-
-                       if (SubViews.FirstOrDefault (sv => sv is MenuBarItemv2 { PopoverMenu: { } }) is MenuBarItemv2 { } first)
-                       {
-                           _active = true;
-                           ShowPopover (first);
-
-                           return true;
-                       }
-
-                       return false;
-                   });
+
+        AddCommand (
+                    Command.HotKey,
+                    () =>
+                    {
+                        Logging.Debug ($"{Title} - Command.HotKey");
+                        if (RaiseHandlingHotKey () is true)
+                        {
+                            return true;
+                        }
+
+                        if (HideActiveItem ())
+                        {
+                            return true;
+                        }
+
+                        if (SubViews.OfType<MenuBarItemv2> ().FirstOrDefault (mbi => mbi.PopoverMenu is { }) is { } first)
+                        {
+                            Active = true;
+                            ShowItem (first);
+
+                            return true;
+                        }
+
+                        return false;
+                    });
+
+        // If we're not focused, Key activates/deactivates
         HotKeyBindings.Add (Key, Command.HotKey);
 
         KeyBindings.Add (Key, Command.Quit);
@@ -54,6 +65,7 @@ public class MenuBarv2 : Menuv2, IDesignable
                     Command.Quit,
                     ctx =>
                     {
+                        Logging.Debug ($"{Title} - Command.Quit");
                         if (HideActiveItem ())
                         {
                             return true;
@@ -62,12 +74,12 @@ public class MenuBarv2 : Menuv2, IDesignable
                         if (CanFocus)
                         {
                             CanFocus = false;
-                            _active = false;
+                            Active = false;
 
                             return true;
                         }
 
-                        return false;//RaiseAccepted (ctx);
+                        return false; //RaiseAccepted (ctx);
                     });
 
         AddCommand (Command.Right, MoveRight);
@@ -76,6 +88,11 @@ public class MenuBarv2 : Menuv2, IDesignable
         AddCommand (Command.Left, MoveLeft);
         KeyBindings.Add (Key.CursorLeft, Command.Left);
 
+        BorderStyle = DefaultBorderStyle;
+
+        Applied += OnConfigurationManagerApplied;
+        SuperViewChanged += OnSuperViewChanged;
+
         return;
 
         bool? MoveLeft (ICommandContext? ctx) { return AdvanceFocus (NavigationDirection.Backward, TabBehavior.TabStop); }
@@ -83,6 +100,34 @@ public class MenuBarv2 : Menuv2, IDesignable
         bool? MoveRight (ICommandContext? ctx) { return AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop); }
     }
 
+    private void OnSuperViewChanged (object? sender, SuperViewChangedEventArgs e)
+    {
+        if (SuperView is null)
+        {
+            // BUGBUG: This is a hack for avoiding a race condition in ConfigurationManager.Apply
+            // BUGBUG: For some reason in some unit tests, when Top is disposed, MenuBar.Dispose does not get called.
+            // BUGBUG: Yet, the MenuBar does get Removed from Top (and it's SuperView set to null).
+            // BUGBUG: Related: https://github.com/gui-cs/Terminal.Gui/issues/4021
+            Applied -= OnConfigurationManagerApplied;
+        }
+    }
+
+    private void OnConfigurationManagerApplied (object? sender, ConfigurationManagerEventArgs e) { BorderStyle = DefaultBorderStyle; }
+
+    /// <inheritdoc/>
+    protected override bool OnBorderStyleChanged ()
+    {
+        //HideActiveItem ();
+
+        return base.OnBorderStyleChanged ();
+    }
+
+    /// <summary>
+    ///     Gets or sets the default Border Style for the MenuBar. The default is <see cref="LineStyle.None"/>.
+    /// </summary>
+    [SerializableConfigurationProperty (Scope = typeof (ThemeScope))]
+    public new static LineStyle DefaultBorderStyle { get; set; } = LineStyle.None;
+
     private Key _key = DefaultKey;
 
     /// <summary>Specifies the key that will activate the context menu.</summary>
@@ -110,10 +155,12 @@ public class MenuBarv2 : Menuv2, IDesignable
         set
         {
             RemoveAll ();
+
             if (value is null)
             {
                 return;
             }
+
             foreach (MenuBarItemv2 mbi in value)
             {
                 Add (mbi);
@@ -121,6 +168,52 @@ public class MenuBarv2 : Menuv2, IDesignable
         }
     }
 
+    /// <inheritdoc />
+    protected override void OnSubViewAdded (View view)
+    {
+        base.OnSubViewAdded (view);
+
+        if (view is MenuBarItemv2 mbi)
+        {
+            mbi.Accepted += OnMenuBarItemAccepted;
+            mbi.PopoverMenuOpenChanged += OnMenuBarItemPopoverMenuOpenChanged;
+        }
+    }
+
+    /// <inheritdoc />
+    protected override void OnSubViewRemoved (View view)
+    {
+        base.OnSubViewRemoved (view);
+        if (view is MenuBarItemv2 mbi)
+        {
+            mbi.Accepted -= OnMenuBarItemAccepted;
+            mbi.PopoverMenuOpenChanged -= OnMenuBarItemPopoverMenuOpenChanged;
+        }
+    }
+
+    private void OnMenuBarItemPopoverMenuOpenChanged (object? sender, EventArgs<bool> e)
+    {
+        if (sender is MenuBarItemv2 mbi)
+        {
+            if (e.CurrentValue)
+            {
+                Active = true;
+            }
+            else
+            {
+
+
+            }
+        }
+    }
+
+    private void OnMenuBarItemAccepted (object? sender, CommandEventArgs e)
+    {
+        Logging.Debug ($"{Title} ({e.Context?.Source?.Title}) Command: {e.Context?.Command}");
+
+        RaiseAccepted (e.Context);
+    }
+
     /// <summary>Raised when <see cref="Key"/> is changed.</summary>
     public event EventHandler<KeyChangedEventArgs>? KeyChanged;
 
@@ -132,61 +225,85 @@ public class MenuBarv2 : Menuv2, IDesignable
     ///     Gets whether any of the menu bar items have a visible <see cref="PopoverMenu"/>.
     /// </summary>
     /// <exception cref="NotImplementedException"></exception>
-    public bool IsOpen ()
-    {
-        return SubViews.Count (sv => sv is MenuBarItemv2 { PopoverMenu: { Visible: true } }) > 0;
-    }
+    public bool IsOpen () { return SubViews.OfType<MenuBarItemv2>().Count (sv => sv is { PopoverMenuOpen: true }) > 0; }
 
     private bool _active;
 
     /// <summary>
-    ///     Returns a value indicating whether the menu bar is active or not. When active, moving the mouse
-    ///     over a menu bar item will activate it.
+    ///     Gets or sets whether the menu bar is active or not. When active, the MenuBar can focus and moving the mouse
+    ///     over a MenuBarItem will switch focus to that item. Use <see cref="IsOpen"/> to determine if a PopoverMenu of
+    ///     a MenuBarItem is open.
     /// </summary>
     /// <returns></returns>
-    public bool IsActive ()
+    public bool Active
     {
-        return _active;
+        get => _active;
+        internal set
+        {
+            if (_active == value)
+            {
+                return;
+            }
+
+            _active = value;
+            Logging.Debug ($"Active set to {_active} - CanFocus: {CanFocus}, HasFocus: {HasFocus}");
+
+            if (!_active)
+            {
+                // Hide open Popovers
+                HideActiveItem ();
+            }
+
+            CanFocus = value;
+            Logging.Debug ($"Set CanFocus: {CanFocus}, HasFocus: {HasFocus}");
+
+        }
     }
 
-    /// <inheritdoc />
+    /// <inheritdoc/>
     protected override bool OnMouseEnter (CancelEventArgs eventArgs)
     {
         // If the MenuBar does not have focus and the mouse enters: Enable CanFocus
         // But do NOT show a Popover unless the user clicks or presses a hotkey
+        Logging.Debug ($"CanFocus = {CanFocus}, HasFocus = {HasFocus}");
         if (!HasFocus)
         {
-            CanFocus = true;
+            Active = true;
         }
+
         return base.OnMouseEnter (eventArgs);
     }
 
-    /// <inheritdoc />
+    /// <inheritdoc/>
     protected override void OnMouseLeave ()
     {
+        Logging.Debug ($"CanFocus = {CanFocus}, HasFocus = {HasFocus}");
         if (!IsOpen ())
         {
-            CanFocus = false;
+            Active = false;
         }
+
         base.OnMouseLeave ();
     }
 
-    /// <inheritdoc />
+    /// <inheritdoc/>
     protected override void OnHasFocusChanged (bool newHasFocus, View? previousFocusedView, View? focusedView)
     {
+        Logging.Debug ($"CanFocus = {CanFocus}, HasFocus = {HasFocus}");
         if (!newHasFocus)
         {
-            _active = false;
-            CanFocus = false;
+            Active = false;
         }
     }
 
     /// <inheritdoc/>
     protected override void OnSelectedMenuItemChanged (MenuItemv2? selected)
     {
-        if (selected is MenuBarItemv2 { PopoverMenu.Visible: false } selectedMenuBarItem)
+        Logging.Debug ($"{Title} ({selected?.Title}) - IsOpen: {IsOpen ()}");
+
+        if (IsOpen () && selected is MenuBarItemv2 { PopoverMenuOpen: false } selectedMenuBarItem)
         {
-            ShowPopover (selectedMenuBarItem);
+            ShowItem (selectedMenuBarItem);
         }
     }
 
@@ -211,45 +328,65 @@ public class MenuBarv2 : Menuv2, IDesignable
     /// <inheritdoc/>
     protected override bool OnAccepting (CommandEventArgs args)
     {
-        Logging.Trace ($"{args.Context?.Source?.Title}");
+        Logging.Debug ($"{Title} ({args.Context?.Source?.Title})");
 
-        if (Visible && args.Context?.Source is MenuBarItemv2 { PopoverMenu.Visible: false } sourceMenuBarItem)
+        // TODO: Ensure sourceMenuBar is actually one of our bar items
+        if (Visible && Enabled && args.Context?.Source is MenuBarItemv2 { PopoverMenuOpen: false } sourceMenuBarItem)
         {
-            _active = true;
-
             if (!CanFocus)
             {
-                // Enabling CanFocus will cause focus to change, which will cause OnSelectedMenuItem to change
-                // This will call ShowPopover
-                CanFocus = true;
-                sourceMenuBarItem.SetFocus ();
+                Debug.Assert (!Active);
+
+                // We are not Active; change that
+                Active = true;
+
+                ShowItem(sourceMenuBarItem);
+
+                if (!sourceMenuBarItem.HasFocus)
+                {
+                    sourceMenuBarItem.SetFocus ();
+                }
             }
             else
             {
-                ShowPopover (sourceMenuBarItem);
+                Debug.Assert (Active);
+                ShowItem (sourceMenuBarItem);
             }
 
             return true;
         }
 
-        return base.OnAccepting (args);
+        return false;
+    }
+
+    /// <inheritdoc />
+    protected override void OnAccepted (CommandEventArgs args)
+    {
+        Logging.Debug ($"{Title} ({args.Context?.Source?.Title}) Command: {args.Context?.Command}");
+        base.OnAccepted (args);
+
+        if (SubViews.OfType<MenuBarItemv2> ().Contains (args.Context?.Source))
+        {
+            return;
+        }
+
+        Active = false;
     }
 
     /// <summary>
     ///     Shows the specified popover, but only if the menu bar is active.
     /// </summary>
     /// <param name="menuBarItem"></param>
-    private void ShowPopover (MenuBarItemv2? menuBarItem)
+    private void ShowItem (MenuBarItemv2? menuBarItem)
     {
-        Logging.Trace ($"{menuBarItem?.Id}");
+        Logging.Debug ($"{Title} - {menuBarItem?.Id}");
 
-        if (!_active || !Visible)
+        if (!Active || !Visible)
         {
+            Logging.Debug ($"{Title} - {menuBarItem?.Id} - Not Active, not showing.");
             return;
         }
 
-        //menuBarItem!.PopoverMenu.Id = menuBarItem.Id;
-
         // TODO: We should init the PopoverMenu in a smarter way
         if (menuBarItem?.PopoverMenu is { IsInitialized: false })
         {
@@ -258,31 +395,21 @@ public class MenuBarv2 : Menuv2, IDesignable
         }
 
         // If the active Application Popover is part of this MenuBar, hide it.
-        //HideActivePopover ();
         if (Application.Popover?.GetActivePopover () is PopoverMenu popoverMenu
             && popoverMenu?.Root?.SuperMenuItem?.SuperView == this)
         {
+            Logging.Debug ($"{Title} - Calling Application.Popover?.Hide ({popoverMenu.Title})");
             Application.Popover?.Hide (popoverMenu);
         }
 
         if (menuBarItem is null)
         {
-            return;
-        }
+            Logging.Debug ($"{Title} - menuBarItem is null.");
 
-        if (menuBarItem.PopoverMenu is { })
-        {
-            menuBarItem.PopoverMenu.Accepted += (sender, args) =>
-                                                {
-                                                    if (HasFocus)
-                                                    {
-                                                        CanFocus = false;
-                                                    }
-                                                };
+            return;
         }
 
-        _active = true;
-        CanFocus = true;
+        Active = true;
         menuBarItem.SetFocus ();
 
         if (menuBarItem.PopoverMenu?.Root is { })
@@ -290,22 +417,33 @@ public class MenuBarv2 : Menuv2, IDesignable
             menuBarItem.PopoverMenu.Root.SuperMenuItem = menuBarItem;
         }
 
+        Logging.Debug ($"{Title} - \"{menuBarItem.PopoverMenu?.Title}\".MakeVisible");
         menuBarItem.PopoverMenu?.MakeVisible (new Point (menuBarItem.FrameToScreen ().X, menuBarItem.FrameToScreen ().Bottom));
-    }
 
-    private MenuBarItemv2? GetActiveItem ()
-    {
-        return SubViews.FirstOrDefault (sv => sv is MenuBarItemv2 { PopoverMenu: { Visible: true } }) as MenuBarItemv2;
+        menuBarItem.Accepting += OnMenuItemAccepted;
+
+        return;
+
+        void OnMenuItemAccepted (object? sender, EventArgs args)
+        {
+            Logging.Debug ($"{Title} - OnMenuItemAccepted");
+            menuBarItem.PopoverMenu!.VisibleChanged -= OnMenuItemAccepted;
+
+            if (Active && menuBarItem.PopoverMenu is { Visible: false })
+            {
+                Active = false;
+                HasFocus = false;
+            }
+        }
     }
 
+    private MenuBarItemv2? GetActiveItem () { return SubViews.OfType<MenuBarItemv2> ().FirstOrDefault (sv => sv is { PopoverMenu: { Visible: true } }); }
+
     /// <summary>
     ///     Hides the popover menu associated with the active menu bar item and updates the focus state.
     /// </summary>
     /// <returns><see langword="true"/> if the popover was hidden</returns>
-    public bool HideActiveItem ()
-    {
-        return HideItem (GetActiveItem ());
-    }
+    public bool HideActiveItem () { return HideItem (GetActiveItem ()); }
 
     /// <summary>
     ///     Hides popover menu associated with the specified menu bar item and updates the focus state.
@@ -314,67 +452,186 @@ public class MenuBarv2 : Menuv2, IDesignable
     /// <returns><see langword="true"/> if the popover was hidden</returns>
     public bool HideItem (MenuBarItemv2? activeItem)
     {
+        Logging.Debug ($"{Title} ({activeItem?.Title}) - Active: {Active}, CanFocus: {CanFocus}, HasFocus: {HasFocus}");
+
         if (activeItem is null || !activeItem.PopoverMenu!.Visible)
         {
+            Logging.Debug ($"{Title} No active item.");
+
             return false;
         }
-        _active = false;
-        HasFocus = false;
+
+        // IMPORTANT: Set Visible false before setting Active to false (Active changes Can/HasFocus)
         activeItem.PopoverMenu!.Visible = false;
-        CanFocus = false;
+
+        Active = false;
+        HasFocus = false;
 
         return true;
     }
 
+    /// <summary>
+    ///     Gets all menu items with the specified Title, anywhere in the menu hierarchy.
+    /// </summary>
+    /// <param name="title"></param>
+    /// <returns></returns>
+    public IEnumerable<MenuItemv2> GetMenuItemsWithTitle (string title)
+    {
+        List<MenuItemv2> menuItems = new ();
+        if (string.IsNullOrEmpty (title))
+        {
+            return menuItems;
+        }
+        foreach (MenuBarItemv2 mbi in SubViews.OfType<MenuBarItemv2> ())
+        {
+            if (mbi.PopoverMenu is { })
+            {
+                menuItems.AddRange (mbi.PopoverMenu.GetMenuItemsOfAllSubMenus ());
+            }
+        }
+        return menuItems.Where (mi => mi.Title == title);
+    }
+
     /// <inheritdoc/>
-    public bool EnableForDesign<TContext> (ref readonly TContext context) where TContext : notnull
+    public bool EnableForDesign<TContext> (ref TContext context) where TContext : notnull
     {
+        // Note: This menu is used by unit tests. If you modify it, you'll likely have to update
+        // unit tests.
+
+        Id = "DemonuBar";
+
+        var bordersCb = new CheckBox
+        {
+            Title = "_Borders",
+            CheckedState = CheckState.Checked
+        };
+
+        var autoSaveCb = new CheckBox
+        {
+            Title = "_Auto Save"
+        };
+
+        var enableOverwriteCb = new CheckBox
+        {
+            Title = "Enable _Overwrite",
+        };
+
+        var mutuallyExclusiveOptionsSelector = new OptionSelector
+        {
+            Options = ["G_ood", "_Bad", "U_gly"],
+            SelectedItem = 0
+        };
+
+        var menuBgColorCp = new ColorPicker ()
+        {
+            Width = 30
+        };
+
+        menuBgColorCp.ColorChanged += (sender, args) =>
+                                      {
+                                          ColorScheme = ColorScheme! with
+                                          {
+                                              Normal = new (ColorScheme.Normal.Foreground, args.CurrentValue)
+                                          };
+                                      };
+
         Add (
-             new MenuBarItemv2 (
-                                "_File",
-                                [
-                                    new MenuItemv2 (this, Command.New),
-                                    new MenuItemv2 (this, Command.Open),
-                                    new MenuItemv2 (this, Command.Save),
-                                    new MenuItemv2 (this, Command.SaveAs),
-                                    new Line (),
-                                    new MenuItemv2
-                                    {
-                                        Title = "_Preferences",
-                                        SubMenu = new (
-                                                       [
-                                                           new MenuItemv2
-                                                           {
-                                                               CommandView = new CheckBox ()
-                                                               {
-                                                                   Title = "O_ption",
-                                                               },
-                                                               HelpText = "Toggle option"
-                                                           },
-                                                           new MenuItemv2
-                                                           {
-                                                               Title = "_Settings...",
-                                                               HelpText = "More settings",
-                                                               Action = () =>  MessageBox.Query ("Settings", "This is the Settings Dialog\n", ["_Ok", "_Cancel"])
-                                                           }
-                                                       ]
-                                                      )
-                                    },
-                                    new Line (),
-                                    new MenuItemv2 (this, Command.Quit)
-                                ]
-                               )
-            );
+                        new MenuBarItemv2 (
+                                           "_File",
+                                           [
+                                               new MenuItemv2 (context as View, Command.New),
+                                               new MenuItemv2 (context as View, Command.Open),
+                                               new MenuItemv2 (context as View, Command.Save),
+                                               new MenuItemv2 (context as View, Command.SaveAs),
+                                               new Line (),
+                                               new MenuItemv2
+                                               {
+                                                   Title = "_File Options",
+                                                   SubMenu = new (
+                                                                  [
+                                                                      new ()
+                                                                      {
+                                                                          Id = "AutoSave",
+                                                                          Text = "(no Command)",
+                                                                          Key = Key.F10,
+                                                                          CommandView = autoSaveCb
+                                                                      },
+                                                                      new ()
+                                                                      {
+                                                                          Text = "Overwrite",
+                                                                          Id = "Overwrite",
+                                                                          Key = Key.W.WithCtrl,
+                                                                          CommandView = enableOverwriteCb,
+                                                                          Command = Command.EnableOverwrite,
+                                                                          TargetView = context as View
+                                                                      },
+                                                                      new ()
+                                                                      {
+                                                                          Title = "_File Settings...",
+                                                                          HelpText = "More file settings",
+                                                                          Action = () => MessageBox.Query (
+                                                                                    "File Settings",
+                                                                                    "This is the File Settings Dialog\n",
+                                                                                    "_Ok",
+                                                                                    "_Cancel")
+                                                                      }
+                                                                  ]
+                                                                 )
+                                               },
+                                               new Line (),
+                                               new MenuItemv2
+                                               {
+                                                   Title = "_Preferences",
+                                                   SubMenu = new (
+                                                                  [
+                                                                      new MenuItemv2 ()
+                                                                      {
+                                                                          CommandView = bordersCb,
+                                                                          HelpText = "Toggle Menu Borders",
+                                                                          Action = ToggleMenuBorders
+                                                                      },
+                                                                      new MenuItemv2 ()
+                                                                      {
+                                                                          HelpText = "3 Mutually Exclusive Options",
+                                                                          CommandView = mutuallyExclusiveOptionsSelector,
+                                                                          Key = Key.F7
+                                                                      },
+                                                                      new Line (),
+                                                                      new MenuItemv2 ()
+                                                                      {
+                                                                          HelpText = "MenuBar BG Color",
+                                                                          CommandView = menuBgColorCp,
+                                                                          Key = Key.F8,
+                                                                      }
+                                                                  ]
+                                                                 )
+                                               },
+                                               new Line (),
+                                               new MenuItemv2 ()
+                                               {
+                                                   TargetView = context as View,
+                                                   Key = Application.QuitKey,
+                                                   Command = Command.Quit
+                                               }
+                                           ]
+                                          )
+                       );
 
         Add (
              new MenuBarItemv2 (
                                 "_Edit",
                                 [
-                                    new MenuItemv2 (this, Command.Cut),
-                                    new MenuItemv2 (this, Command.Copy),
-                                    new MenuItemv2 (this, Command.Paste),
+                                    new MenuItemv2 (context as View, Command.Cut),
+                                    new MenuItemv2 (context as View, Command.Copy),
+                                    new MenuItemv2 (context as View, Command.Paste),
+                                    new Line (),
+                                    new MenuItemv2 (context as View, Command.SelectAll),
                                     new Line (),
-                                    new MenuItemv2 (this, Command.SelectAll)
+                                    new MenuItemv2 ()
+                                    {
+                                        Title = "_Details",
+                                        SubMenu = new (ConfigureDetailsSubMenu ())
+                                    },
                                 ]
                                )
             );
@@ -396,6 +653,91 @@ public class MenuBarv2 : Menuv2, IDesignable
                                 ]
                                )
             );
+
         return true;
+
+        void ToggleMenuBorders ()
+        {
+            foreach (MenuBarItemv2 mbi in SubViews.OfType<MenuBarItemv2> ())
+            {
+                if (mbi is not { PopoverMenu: { } })
+                {
+                    continue;
+                }
+
+                foreach (Menuv2? subMenu in mbi.PopoverMenu.GetAllSubMenus ())
+                {
+                    if (bordersCb.CheckedState == CheckState.Checked)
+                    {
+                        subMenu.Border!.Thickness = new (1);
+                    }
+                    else
+                    {
+                        subMenu.Border!.Thickness = new (0);
+                    }
+                }
+            }
+        }
+
+        MenuItemv2 [] ConfigureDetailsSubMenu ()
+        {
+            var detail = new MenuItemv2
+            {
+                Title = "_Detail 1",
+                Text = "Some detail #1"
+            };
+
+            var nestedSubMenu = new MenuItemv2
+            {
+                Title = "_Moar Details",
+                SubMenu = new (ConfigureMoreDetailsSubMenu ()),
+            };
+
+            var editMode = new MenuItemv2
+            {
+                Text = "App Binding to Command.Edit",
+                Id = "EditMode",
+                Command = Command.Edit,
+                CommandView = new CheckBox
+                {
+                    Title = "E_dit Mode",
+                }
+            };
+
+            return [detail, nestedSubMenu, null!, editMode];
+
+            View [] ConfigureMoreDetailsSubMenu ()
+            {
+                var deeperDetail = new MenuItemv2
+                {
+                    Title = "_Deeper Detail",
+                    Text = "Deeper Detail",
+                    Action = () => { MessageBox.Query ("Deeper Detail", "Lots of details", "_Ok"); }
+                };
+
+                var belowLineDetail = new MenuItemv2
+                {
+                    Title = "_Even more detail",
+                    Text = "Below the line"
+                };
+
+                // This ensures the checkbox state toggles when the hotkey of Title is pressed.
+                //shortcut4.Accepting += (sender, args) => args.Cancel = true;
+
+                return [deeperDetail, new Line (), belowLineDetail];
+            }
+        }
+
+    }
+
+    /// <inheritdoc/>
+    protected override void Dispose (bool disposing)
+    {
+        base.Dispose (disposing);
+        if (disposing)
+        {
+            SuperViewChanged += OnSuperViewChanged;
+            Applied -= OnConfigurationManagerApplied;
+        }
     }
 }

Terminal.Gui/Views/Menu/MenuItemv2.cs

@@ -55,7 +55,7 @@ public class MenuItemv2 : Shortcut
     { }
 
     /// <inheritdoc/>
-    public MenuItemv2 (string commandText, Key key, Action ? action = null)
+    public MenuItemv2 (string commandText, Key key, Action? action = null)
         : base (key ?? Key.Empty, commandText, action, null)
     { }
 
@@ -104,35 +104,75 @@ public class MenuItemv2 : Shortcut
 
     internal override bool? DispatchCommand (ICommandContext? commandContext)
     {
-        Logging.Trace($"{commandContext?.Source?.Title}");
+        Logging.Debug ($"{Title} - {commandContext?.Source?.Title} Command: {commandContext?.Command}");
         bool? ret = null;
 
-        if (commandContext is { Command: not Command.HotKey })
+        bool quit = false;
+
+        if (commandContext is CommandContext<KeyBinding> keyCommandContext)
+        {
+            if (keyCommandContext.Binding.Key is { } && keyCommandContext.Binding.Key == Application.QuitKey && SuperView is { Visible: true })
+            {
+                // This supports a MenuItem with Key = Application.QuitKey/Command = Command.Quit
+                Logging.Debug ($"{Title} - Ignoring Key = Application.QuitKey/Command = Command.Quit");
+                quit = true;
+                //ret = true;
+            }
+        }
+
+        // Translate the incoming command to Command
+        if (Command != Command.NotBound && commandContext is { })
+        {
+            commandContext.Command = Command;
+        }
+
+        if (!quit)
         {
             if (TargetView is { })
             {
-                commandContext.Command = Command;
+                Logging.Debug ($"{Title} - InvokeCommand on TargetView ({TargetView.Title})...");
                 ret = TargetView.InvokeCommand (Command, commandContext);
             }
             else
             {
                 // Is this an Application-bound command?
+                Logging.Debug ($"{Title} - Application.InvokeCommandsBoundToKey ({Key})...");
                 ret = Application.InvokeCommandsBoundToKey (Key);
             }
         }
 
         if (ret is not true)
         {
-            Logging.Trace($"Calling base.DispatchCommand");
+            Logging.Debug ($"{Title} - calling base.DispatchCommand...");
+            // Base will Raise Selected, then Accepting, then invoke the Action, if any
             ret = base.DispatchCommand (commandContext);
         }
 
-        Logging.Trace($"Calling RaiseAccepted");
-        RaiseAccepted (commandContext);
+        if (ret is true)
+        {
+            Logging.Debug ($"{Title} - Calling RaiseAccepted");
+            RaiseAccepted (commandContext);
+        }
 
         return ret;
     }
 
+    ///// <inheritdoc />
+    //protected override bool OnAccepting (CommandEventArgs e)
+    //{
+    //    Logging.Debug ($"{Title} - calling base.OnAccepting: {e.Context?.Command}");
+    //    bool? ret = base.OnAccepting (e);
+
+    //    if (ret is true || e.Cancel)
+    //    {
+    //        return true;
+    //    }
+
+    //    //RaiseAccepted (e.Context);
+
+    //    return ret is true;
+    //}
+
     private Menuv2? _subMenu;
 
     /// <summary>
@@ -147,6 +187,7 @@ public class MenuItemv2 : Shortcut
 
             if (_subMenu is { })
             {
+                SubMenu!.Visible = false;
                 // TODO: This is a temporary hack - add a flag or something instead
                 KeyView.Text = $"{Glyphs.RightArrow}";
                 _subMenu.SuperMenuItem = this;
@@ -173,15 +214,13 @@ public class MenuItemv2 : Shortcut
     /// </summary>
     /// <param name="ctx"></param>
     /// <returns></returns>
-    protected bool? RaiseAccepted (ICommandContext? ctx)
+    protected void RaiseAccepted (ICommandContext? ctx)
     {
-        Logging.Trace ($"RaiseAccepted: {ctx}");
+        //Logging.Trace ($"RaiseAccepted: {ctx}");
         CommandEventArgs args = new () { Context = ctx };
 
         OnAccepted (args);
         Accepted?.Invoke (this, args);
-
-        return true;
     }
 
     /// <summary>

Terminal.Gui/Views/Menu/Menuv2.cs

@@ -15,14 +15,38 @@ public class Menuv2 : Bar
     /// <inheritdoc/>
     public Menuv2 (IEnumerable<View>? shortcuts) : base (shortcuts)
     {
+        // Do this to support debugging traces where Title gets set
+        base.HotKeySpecifier = (Rune)'\xffff';
+
         Orientation = Orientation.Vertical;
         Width = Dim.Auto ();
         Height = Dim.Auto (DimAutoStyle.Content, 1);
+        base.ColorScheme = Colors.ColorSchemes ["Menu"];
+
+        if (Border is { })
+        {
+            Border.Settings &= ~BorderSettings.Title;
+        }
 
-        Border!.Thickness = new Thickness (1, 1, 1, 1);
-        Border.LineStyle = LineStyle.Single;
+        BorderStyle = DefaultBorderStyle;
+
+        Applied += OnConfigurationManagerApplied;
+    }
+
+    private void OnConfigurationManagerApplied (object? sender, ConfigurationManagerEventArgs e)
+    {
+        if (SuperView is { })
+        {
+            BorderStyle = DefaultBorderStyle;
+        }
     }
 
+    /// <summary>
+    ///     Gets or sets the default Border Style for Menus. The default is <see cref="LineStyle.Single"/>.
+    /// </summary>
+    [SerializableConfigurationProperty (Scope = typeof (ThemeScope))]
+    public static LineStyle DefaultBorderStyle { get; set; } = LineStyle.Rounded;
+
     /// <summary>
     ///     Gets or sets the menu item that opened this menu as a sub-menu.
     /// </summary>
@@ -37,16 +61,6 @@ public class Menuv2 : Bar
         }
     }
 
-    /// <inheritdoc />
-    public override void EndInit ()
-    {
-        base.EndInit ();
-
-        if (Border is { })
-        {
-        }
-    }
-
     /// <inheritdoc />
     protected override void OnSubViewAdded (View view)
     {
@@ -58,7 +72,13 @@ public class Menuv2 : Bar
                 {
                     menuItem.CanFocus = true;
 
-                    AddCommand (menuItem.Command, RaiseAccepted);
+                    AddCommand (menuItem.Command, (ctx) =>
+                                                  {
+                                                      RaiseAccepted (ctx);
+
+                                                      return true;
+
+                                                  });
 
                     menuItem.Accepted += MenuItemOnAccepted;
 
@@ -66,7 +86,7 @@ public class Menuv2 : Bar
 
                     void MenuItemOnAccepted (object? sender, CommandEventArgs e)
                     {
-                        Logging.Trace ($"MenuItemOnAccepted: {e.Context?.Source?.Title}");
+                        Logging.Debug ($"MenuItemOnAccepted: Calling RaiseAccepted {e.Context?.Source?.Title}");
                         RaiseAccepted (e.Context);
                     }
                 }
@@ -79,15 +99,38 @@ public class Menuv2 : Bar
         }
     }
 
+
     /// <inheritdoc />
     protected override bool OnAccepting (CommandEventArgs args)
     {
-        Logging.Trace ($"{args.Context}");
+        // When the user accepts a menuItem, Menu.RaiseAccepting is called, and we intercept that here.
+
+        Logging.Debug ($"{Title} - {args.Context?.Source?.Title} Command: {args.Context?.Command}");
+
+        // TODO: Consider having PopoverMenu subscribe to Accepting instead of us overriding OnAccepting here
+        // TODO: Doing so would be better encapsulation and might allow us to remove the SuperMenuItem property.
+        if (SuperView is { })
+        {
+            Logging.Debug ($"{Title} - SuperView is null");
+            //return false;
+        }
+
+        Logging.Debug ($"{Title} - {args.Context}");
 
-        if (SuperMenuItem is { })
+        if (args.Context is CommandContext<KeyBinding> { Binding.Key: { } } keyCommandContext && keyCommandContext.Binding.Key == Application.QuitKey)
         {
-            Logging.Trace ($"Invoking Accept on SuperMenuItem: {SuperMenuItem.Title}...");
-            return SuperMenuItem?.SuperView?.InvokeCommand (Command.Accept, args.Context) is true;
+            // Special case QuitKey if we are Visible - This supports a MenuItem with Key = Application.QuitKey/Command = Command.Quit
+            // And causes just the menu to quit.
+            Logging.Debug ($"{Title} - Returning true - Application.QuitKey/Command = Command.Quit");
+            return true;
+        }
+
+        // Because we may not have a SuperView (if we are in a PopoverMenu), we need to propagate
+        // Command.Accept to the SuperMenuItem if it exists.
+        if (SuperView is null && SuperMenuItem is { })
+        {
+            Logging.Debug ($"{Title} - Invoking Accept on SuperMenuItem: {SuperMenuItem?.Title}...");
+            return SuperMenuItem?.InvokeCommand (Command.Accept, args.Context) is true;
         }
         return false;
     }
@@ -100,15 +143,13 @@ public class Menuv2 : Bar
     /// </summary>
     /// <param name="ctx"></param>
     /// <returns></returns>
-    protected bool? RaiseAccepted (ICommandContext? ctx)
+    protected void RaiseAccepted (ICommandContext? ctx)
     {
         //Logging.Trace ($"RaiseAccepted: {ctx}");
         CommandEventArgs args = new () { Context = ctx };
 
         OnAccepted (args);
         Accepted?.Invoke (this, args);
-
-        return true;
     }
 
     /// <summary>
@@ -158,7 +199,7 @@ public class Menuv2 : Bar
 
     internal void RaiseSelectedMenuItemChanged (MenuItemv2? selected)
     {
-        //Logging.Trace ($"RaiseSelectedMenuItemChanged: {selected?.Title}");
+        Logging.Debug ($"{Title} ({selected?.Title})");
 
         OnSelectedMenuItemChanged (selected);
         SelectedMenuItemChanged?.Invoke (this, selected);
@@ -177,4 +218,14 @@ public class Menuv2 : Bar
     /// </summary>
     public event EventHandler<MenuItemv2?>? SelectedMenuItemChanged;
 
+    /// <inheritdoc />
+    protected override void Dispose (bool disposing)
+    {
+        base.Dispose (disposing);
+
+        if (disposing)
+        {
+            Applied -= OnConfigurationManagerApplied;
+        }
+    }
 }

Terminal.Gui/Views/Menu/PopoverMenu.cs

@@ -4,7 +4,7 @@ namespace Terminal.Gui;
 /// <summary>
 ///     Provides a cascading menu that pops over all other content. Can be used as a context menu or a drop-down
 ///     all other content. Can be used as a context menu or a drop-down
-///     menu as part of <see cref="MenuBar"/> as part of <see cref="MenuBar"/>.
+///     menu as part of <see cref="MenuBarv2"/> as part of <see cref="MenuBarv2"/>.
 /// </summary>
 /// <remarks>
 ///     <para>
@@ -19,17 +19,39 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
     /// </summary>
     public PopoverMenu () : this ((Menuv2?)null) { }
 
-    /// <inheritdoc/>
-    public PopoverMenu (IEnumerable<View>? menuItems) : this (new Menuv2 (menuItems)) { }
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="PopoverMenu"/> class. If any of the elements of
+    ///     <paramref name="menuItems"/> is <see langword="null"/>,
+    ///     a see <see cref="Line"/> will be created instead.
+    /// </summary>
+    public PopoverMenu (IEnumerable<View>? menuItems) : this (
+                                                              new Menuv2 (menuItems?.Select (item => item ?? new Line ()))
+                                                              {
+                                                                  Title = "Popover Root"
+                                                              })
+    { }
 
     /// <inheritdoc/>
-    public PopoverMenu (IEnumerable<MenuItemv2>? menuItems) : this (new Menuv2 (menuItems)) { }
+    public PopoverMenu (IEnumerable<MenuItemv2>? menuItems) : this (
+                                                                    new Menuv2 (menuItems)
+                                                                    {
+                                                                        Title = "Popover Root"
+                                                                    })
+    { }
 
     /// <summary>
     ///     Initializes a new instance of the <see cref="PopoverMenu"/> class with the specified root <see cref="Menuv2"/>.
     /// </summary>
     public PopoverMenu (Menuv2? root)
     {
+        // Do this to support debugging traces where Title gets set
+        base.HotKeySpecifier = (Rune)'\xffff';
+
+        if (Border is { })
+        {
+            Border.Settings &= ~BorderSettings.Title;
+        }
+
         Key = DefaultKey;
 
         base.Visible = false;
@@ -42,34 +64,38 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
         AddCommand (Command.Left, MoveLeft);
         KeyBindings.Add (Key.CursorLeft, Command.Left);
 
-        // TODO: Remove; for debugging for now
-        AddCommand (
-                    Command.NotBound,
-                    ctx =>
-                    {
-                        Logging.Trace ($"popoverMenu NotBound: {ctx}");
+        AddCommand (Command.Quit, Quit);
 
-                        return false;
-                    });
+        return;
 
-        KeyBindings.Add (Key, Command.Quit);
-        KeyBindings.ReplaceCommands (Application.QuitKey, Command.Quit);
+        bool? Quit (ICommandContext? ctx)
+        {
+            Logging.Debug ($"{Title} Command.Quit - {ctx?.Source?.Title}");
 
-        AddCommand (
-                    Command.Quit,
-                    ctx =>
-                    {
-                        if (!Visible)
-                        {
-                            return false;
-                        }
+            if (!Visible)
+            {
+                // If we're not visible, the command is not for us
+                return false;
+            }
 
-                        Visible = false;
+            // This ensures the quit command gets propagated to the owner of the popover.
+            // This is important for MenuBarItems to ensure the MenuBar loses focus when
+            // the user presses QuitKey to cause the menu to close.
+            // Note, we override OnAccepting, which will set Visible to false
+            Logging.Debug ($"{Title} Command.Quit - Calling RaiseAccepting {ctx?.Source?.Title}");
+            bool? ret = RaiseAccepting (ctx);
 
-                        return false;
-                    });
+            if (Visible && ret is not true)
+            {
+                Visible = false;
 
-        return;
+                return true;
+            }
+
+            // If we are Visible, returning true will stop the QuitKey from propagating
+            // If we are not Visible, returning false will allow the QuitKey to propagate
+            return Visible;
+        }
 
         bool? MoveLeft (ICommandContext? ctx)
         {
@@ -97,7 +123,7 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
                 return true;
             }
 
-            return false; //AdvanceFocus (NavigationDirection.Forward, TabBehavior.TabStop);
+            return false;
         }
     }
 
@@ -138,6 +164,13 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
     /// <param name="idealScreenPosition">If <see langword="null"/>, the current mouse position will be used.</param>
     public void MakeVisible (Point? idealScreenPosition = null)
     {
+        if (Visible)
+        {
+            Logging.Debug ($"{Title} - Already Visible");
+
+            return;
+        }
+
         UpdateKeyBindings ();
         SetPosition (idealScreenPosition);
         Application.Popover?.Show (this);
@@ -177,6 +210,7 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
     /// <inheritdoc/>
     protected override void OnVisibleChanged ()
     {
+        Logging.Debug ($"{Title} - Visible: {Visible}");
         base.OnVisibleChanged ();
 
         if (Visible)
@@ -205,20 +239,10 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
                 return;
             }
 
-            if (_root is { })
-            {
-                _root.Accepting -= MenuOnAccepting;
-            }
-
             HideAndRemoveSubMenu (_root);
 
             _root = value;
 
-            if (_root is { })
-            {
-                _root.Accepting += MenuOnAccepting;
-            }
-
             // TODO: This needs to be done whenever any MenuItem in the menu tree changes to support dynamic menus
             // TODO: And it needs to clear the old bindings first
             UpdateKeyBindings ();
@@ -228,6 +252,7 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
 
             foreach (Menuv2 menu in allMenus)
             {
+                menu.Visible = false;
                 menu.Accepting += MenuOnAccepting;
                 menu.Accepted += MenuAccepted;
                 menu.SelectedMenuItemChanged += MenuOnSelectedMenuItemChanged;
@@ -266,7 +291,7 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
 
             menuItem.Key = key;
 
-            //Logging.Trace ($"HotKey: {menuItem.Key}->{menuItem.Command}");
+            Logging.Debug ($"{Title} - HotKey: {menuItem.Key}->{menuItem.Command}");
         }
     }
 
@@ -278,8 +303,10 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
 
         foreach (MenuItemv2 menuItem in all)
         {
-            if (menuItem.Key == key)
+            if (key != Application.QuitKey && menuItem.Key == key)
             {
+                Logging.Debug ($"{Title} - key: {key}");
+
                 return menuItem.NewKeyDownEvent (key);
             }
         }
@@ -291,7 +318,7 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
     ///     Gets all the submenus in the PopoverMenu.
     /// </summary>
     /// <returns></returns>
-    internal IEnumerable<Menuv2> GetAllSubMenus ()
+    public IEnumerable<Menuv2> GetAllSubMenus ()
     {
         List<Menuv2> result = [];
 
@@ -310,7 +337,7 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
 
             foreach (View subView in currentMenu.SubViews)
             {
-                if (subView is MenuItemv2 menuItem && menuItem.SubMenu != null)
+                if (subView is MenuItemv2 { SubMenu: { } } menuItem)
                 {
                     stack.Push (menuItem.SubMenu);
                 }
@@ -350,6 +377,8 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
     {
         var menu = menuItem?.SuperView as Menuv2;
 
+        Logging.Debug ($"{Title} - menuItem: {menuItem?.Title}, menu: {menu?.Title}");
+
         menu?.Layout ();
 
         // If there's a visible peer, remove / hide it
@@ -399,15 +428,13 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
 
     private void AddAndShowSubMenu (Menuv2? menu)
     {
-        if (menu is { SuperView: null })
+        if (menu is { SuperView: null, Visible: false })
         {
-            // TODO: Find the menu item below the mouse, if any, and select it
+            Logging.Debug ($"{Title} ({menu?.Title}) - menu.Visible: {menu?.Visible}");
 
-            // TODO: Enable No Border menu style
-            menu.Border!.LineStyle = LineStyle.Single;
-            menu.Border.Thickness = new (1);
+            // TODO: Find the menu item below the mouse, if any, and select it
 
-            if (!menu.IsInitialized)
+            if (!menu!.IsInitialized)
             {
                 menu.BeginInit ();
                 menu.EndInit ();
@@ -428,6 +455,8 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
     {
         if (menu is { Visible: true })
         {
+            Logging.Debug ($"{Title} ({menu?.Title}) - menu.Visible: {menu?.Visible}");
+
             // If there's a visible submenu, remove / hide it
             if (menu.SubViews.FirstOrDefault (v => v is MenuItemv2 { SubMenu.Visible: true }) is MenuItemv2 visiblePeer)
             {
@@ -449,30 +478,75 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
     private void MenuOnAccepting (object? sender, CommandEventArgs e)
     {
         var senderView = sender as View;
-        Logging.Trace ($"Sender: {senderView?.GetType ().Name}, {e.Context?.Source?.Title}");
+        Logging.Debug ($"{Title} ({e.Context?.Source?.Title}) Command: {e.Context?.Command} - Sender: {senderView?.GetType ().Name}");
 
         if (e.Context?.Command != Command.HotKey)
         {
+            Logging.Debug ($"{Title} - Setting Visible = false");
             Visible = false;
         }
 
-        // This supports the case when a hotkey of a menuitem with a submenu is pressed
-        //e.Cancel = true;
+        if (e.Context is CommandContext<KeyBinding> keyCommandContext)
+        {
+            if (keyCommandContext.Binding.Key is { } && keyCommandContext.Binding.Key == Application.QuitKey && SuperView is { Visible: true })
+            {
+                Logging.Debug ($"{Title} - Setting e.Cancel = true - Application.QuitKey/Command = Command.Quit");
+                e.Cancel = true;
+            }
+        }
     }
 
     private void MenuAccepted (object? sender, CommandEventArgs e)
     {
-        //Logging.Trace ($"{e.Context?.Source?.Title}");
+        Logging.Debug ($"{Title} ({e.Context?.Source?.Title}) Command: {e.Context?.Command}");
 
         if (e.Context?.Source is MenuItemv2 { SubMenu: null })
         {
             HideAndRemoveSubMenu (_root);
-            RaiseAccepted (e.Context);
         }
         else if (e.Context?.Source is MenuItemv2 { SubMenu: { } } menuItemWithSubMenu)
         {
             ShowSubMenu (menuItemWithSubMenu);
         }
+
+        RaiseAccepted (e.Context);
+    }
+
+    /// <inheritdoc/>
+    protected override bool OnAccepting (CommandEventArgs args)
+    {
+        Logging.Debug ($"{Title} ({args.Context?.Source?.Title}) Command: {args.Context?.Command}");
+
+        // If we're not visible, ignore any keys that are not hotkeys
+        CommandContext<KeyBinding>? keyCommandContext = args.Context as CommandContext<KeyBinding>? ?? default (CommandContext<KeyBinding>);
+
+        if (!Visible && keyCommandContext is { Binding.Key: { } })
+        {
+            if (GetMenuItemsOfAllSubMenus ().All (i => i.Key != keyCommandContext.Value.Binding.Key))
+            {
+                Logging.Debug ($"{Title} ({args.Context?.Source?.Title}) Command: {args.Context?.Command} - ignore any keys that are not hotkeys");
+
+                return false;
+            }
+        }
+
+        Logging.Debug ($"{Title} - calling base.OnAccepting: {args.Context?.Command}");
+        bool? ret = base.OnAccepting (args);
+
+        if (ret is true || args.Cancel)
+        {
+            return args.Cancel = true;
+        }
+
+        // Only raise Accepted if the command came from one of our MenuItems
+        //if (GetMenuItemsOfAllSubMenus ().Contains (args.Context?.Source))
+        {
+            Logging.Debug ($"{Title} - Calling RaiseAccepted {args.Context?.Command}");
+            RaiseAccepted (args.Context);
+        }
+
+        // Always return false to enable accepting to continue propagating
+        return false;
     }
 
     /// <summary>
@@ -481,15 +555,13 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
     /// </summary>
     /// <param name="ctx"></param>
     /// <returns></returns>
-    protected bool? RaiseAccepted (ICommandContext? ctx)
+    protected void RaiseAccepted (ICommandContext? ctx)
     {
-        //Logging.Trace ($"RaiseAccepted: {ctx}");
+        Logging.Debug ($"{Title} - RaiseAccepted: {ctx}");
         CommandEventArgs args = new () { Context = ctx };
 
         OnAccepted (args);
         Accepted?.Invoke (this, args);
-
-        return true;
     }
 
     /// <summary>
@@ -514,7 +586,7 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
 
     private void MenuOnSelectedMenuItemChanged (object? sender, MenuItemv2? e)
     {
-        Logging.Trace ($"e: {e?.Title}");
+        Logging.Debug ($"{Title} - e.Title: {e?.Title}");
         ShowSubMenu (e);
     }
 
@@ -551,18 +623,30 @@ public class PopoverMenu : PopoverBaseImpl, IDesignable
     }
 
     /// <inheritdoc/>
-    public bool EnableForDesign<TContext> (ref readonly TContext context) where TContext : notnull
+    public bool EnableForDesign<TContext> (ref TContext context) where TContext : notnull
     {
+        // Note: This menu is used by unit tests. If you modify it, you'll likely have to update
+        // unit tests.
+
         Root = new (
                     [
-                        new MenuItemv2 (this, Command.Cut),
-                        new MenuItemv2 (this, Command.Copy),
-                        new MenuItemv2 (this, Command.Paste),
+                        new MenuItemv2 (context as View, Command.Cut),
+                        new MenuItemv2 (context as View, Command.Copy),
+                        new MenuItemv2 (context as View, Command.Paste),
                         new Line (),
-                        new MenuItemv2 (this, Command.SelectAll)
-                    ]);
-
-        Visible = true;
+                        new MenuItemv2 (context as View, Command.SelectAll),
+                        new Line (),
+                        new MenuItemv2 (context as View, Command.Quit)
+                    ])
+        {
+            Title = "Popover Demo Root"
+        };
+
+        // NOTE: This is a workaround for the fact that the PopoverMenu is not visible in the designer
+        // NOTE: without being activated via Application.Popover. But we want it to be visible.
+        // NOTE: If you use PopoverView.EnableForDesign for real Popover scenarios, change back to false
+        // NOTE: after calling EnableForDesign.
+        //Visible = true;
 
         return true;
     }

Terminal.Gui/Views/Menuv1/Menu.cs

@@ -2,6 +2,8 @@
 
 namespace Terminal.Gui;
 
+#pragma warning disable CS0618 // Type or member is obsolete
+
 /// <summary>
 ///     An internal class used to represent a menu pop-up menu. Created and managed by <see cref="MenuBar"/>.
 /// </summary>

Terminal.Gui/Views/Menuv1/MenuBar.cs

@@ -35,6 +35,7 @@ namespace Terminal.Gui;
 ///         duplicates a shortcut (e.g. _File and Alt-F), the hot key wins.
 ///     </para>
 /// </remarks>
+[Obsolete ("Use MenuBarv2 instead.", false)]
 public class MenuBar : View, IDesignable
 {
     // Spaces before the Title
@@ -1680,7 +1681,7 @@ public class MenuBar : View, IDesignable
 
 
     /// <inheritdoc />
-    public bool EnableForDesign<TContext> (ref readonly TContext context) where TContext : notnull
+    public bool EnableForDesign<TContext> (ref TContext context) where TContext : notnull
     {
         if (context is not Func<string, bool> actionFn)
         {

Terminal.Gui/Views/Menuv1/MenuBarItem.cs

@@ -6,6 +6,7 @@ namespace Terminal.Gui;
 ///     <see cref="MenuBarItem"/> is a menu item on  <see cref="MenuBar"/>. MenuBarItems do not support
 ///     <see cref="MenuItem.ShortcutKey"/>.
 /// </summary>
+[Obsolete ("Use MenuBarItemv2 instead.", false)]
 public class MenuBarItem : MenuItem
 {
     /// <summary>Initializes a new <see cref="MenuBarItem"/> as a <see cref="MenuItem"/>.</summary>

Terminal.Gui/Views/Menuv1/MenuClosingEventArgs.cs

@@ -1,5 +1,7 @@
 namespace Terminal.Gui;
 
+#pragma warning disable CS0618 // Type or member is obsolete
+
 /// <summary>An <see cref="EventArgs"/> which allows passing a cancelable menu closing event.</summary>
 public class MenuClosingEventArgs : EventArgs
 {

Terminal.Gui/Views/Menuv1/MenuItem.cs

@@ -6,6 +6,8 @@ namespace Terminal.Gui;
 ///     A <see cref="MenuItem"/> has title, an associated help text, and an action to execute on activation. MenuItems
 ///     can also have a checked indicator (see <see cref="Checked"/>).
 /// </summary>
+[Obsolete ("Use MenuItemv2 instead.", false)]
+
 public class MenuItem
 {
     internal MenuBar _menuBar;

Terminal.Gui/Views/Menuv1/MenuOpenedEventArgs.cs

@@ -1,4 +1,5 @@
 namespace Terminal.Gui;
+#pragma warning disable CS0618 // Type or member is obsolete
 
 /// <summary>Defines arguments for the <see cref="MenuBar.MenuOpened"/> event</summary>
 public class MenuOpenedEventArgs : EventArgs

Terminal.Gui/Views/Menuv1/MenuOpeningEventArgs.cs

@@ -1,5 +1,7 @@
 namespace Terminal.Gui;
 
+#pragma warning disable CS0618 // Type or member is obsolete
+
 /// <summary>
 ///     An <see cref="EventArgs"/> which allows passing a cancelable menu opening event or replacing with a new
 ///     <see cref="MenuBarItem"/>.

Terminal.Gui/Views/OptionSelector.cs

@@ -0,0 +1,318 @@
+#nullable enable
+namespace Terminal.Gui;
+
+/// <summary>
+///     Provides a user interface for displaying and selecting a single item from a list of options.
+///     Each option is represented by a checkbox, but only one can be selected at a time.
+/// </summary>
+public class OptionSelector : View, IOrientation, IDesignable
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="OptionSelector"/> class.
+    /// </summary>
+    public OptionSelector ()
+    {
+        CanFocus = true;
+
+        Width = Dim.Auto (DimAutoStyle.Content);
+        Height = Dim.Auto (DimAutoStyle.Content);
+
+        _orientationHelper = new (this);
+        _orientationHelper.Orientation = Orientation.Vertical;
+
+        // Accept (Enter key or DoubleClick) - Raise Accept event - DO NOT advance state
+        AddCommand (Command.Accept, HandleAcceptCommand);
+
+        CreateCheckBoxes ();
+    }
+
+    private bool? HandleAcceptCommand (ICommandContext? ctx) { return RaiseAccepting (ctx); }
+
+    private int? _selectedItem;
+
+    /// <summary>
+    /// Gets or sets the index of the selected item.
+    /// </summary>
+    public int? SelectedItem
+    {
+        get => _selectedItem;
+        set
+        {
+            if (_selectedItem == value)
+            {
+                return;
+            }
+
+            int? previousSelectedItem = _selectedItem;
+            _selectedItem = value;
+
+            UpdateChecked ();
+
+            RaiseSelectedItemChanged (previousSelectedItem);
+        }
+    }
+
+    private void RaiseSelectedItemChanged (int? previousSelectedItem)
+    {
+        OnSelectedItemChanged (SelectedItem, previousSelectedItem);
+        if (SelectedItem.HasValue)
+        {
+            SelectedItemChanged?.Invoke (this, new (SelectedItem, previousSelectedItem));
+        }
+    }
+
+    /// <summary>
+    ///     Called when <see cref="SelectedItem"/> has changed.
+    /// </summary>
+    protected virtual void OnSelectedItemChanged (int? selectedItem, int? previousSelectedItem) { }
+
+    /// <summary>
+    ///     Raised when <see cref="SelectedItem"/> has changed.
+    /// </summary>
+    public event EventHandler<SelectedItemChangedArgs>? SelectedItemChanged;
+
+    private IReadOnlyList<string>? _options;
+
+    /// <summary>
+    ///     Gets or sets the list of options.
+    /// </summary>
+    public IReadOnlyList<string>? Options
+    {
+        get => _options;
+        set
+        {
+            _options = value;
+            CreateCheckBoxes ();
+        }
+    }
+
+    private bool _assignHotKeysToCheckBoxes;
+
+    /// <summary>
+    ///     If <see langword="true"/> the CheckBoxes will each be automatically assigned a hotkey.
+    ///     <see cref="UsedHotKeys"/> will be used to ensure unique keys are assigned. Set <see cref="UsedHotKeys"/>
+    ///     before setting <see cref="Options"/> with any hotkeys that may conflict with other Views.
+    /// </summary>
+    public bool AssignHotKeysToCheckBoxes
+    {
+        get => _assignHotKeysToCheckBoxes;
+        set
+        {
+            if (_assignHotKeysToCheckBoxes == value)
+            {
+                return;
+            }
+            _assignHotKeysToCheckBoxes = value;
+            CreateCheckBoxes ();
+            UpdateChecked ();
+        }
+    }
+
+    /// <summary>
+    ///     Gets the list of hotkeys already used by the CheckBoxes or that should not be used if
+    ///     <see cref="AssignHotKeysToCheckBoxes"/>
+    ///     is enabled.
+    /// </summary>
+    public List<Key> UsedHotKeys { get; } = new ();
+
+    private void CreateCheckBoxes ()
+    {
+        if (Options is null)
+        {
+            return;
+        }
+
+        foreach (CheckBox cb in RemoveAll<CheckBox> ())
+        {
+            cb.Dispose ();
+        }
+
+        for (var index = 0; index < Options.Count; index++)
+        {
+            Add (CreateCheckBox (Options [index], index));
+        }
+
+        SetLayout ();
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="name"></param>
+    /// <param name="index"></param>
+    /// <returns></returns>
+    protected virtual CheckBox CreateCheckBox (string name, int index)
+    {
+        string nameWithHotKey = name;
+        if (AssignHotKeysToCheckBoxes)
+        {
+            // Find the first char in label that is [a-z], [A-Z], or [0-9]
+            for (var i = 0; i < name.Length; i++)
+            {
+                char c = char.ToLowerInvariant (name [i]);
+                if (UsedHotKeys.Contains (new (c)) || !char.IsAsciiLetterOrDigit (c))
+                {
+                    continue;
+                }
+
+                if (char.IsAsciiLetterOrDigit (c))
+                {
+                    char? hotChar = c;
+                    nameWithHotKey = name.Insert (i, HotKeySpecifier.ToString ());
+                    UsedHotKeys.Add (new (hotChar));
+
+                    break;
+                }
+            }
+        }
+
+        var checkbox = new CheckBox
+        {
+            CanFocus = true,
+            Title = nameWithHotKey,
+            Id = name,
+            Data = index,
+            HighlightStyle = HighlightStyle.Hover,
+            RadioStyle = true
+        };
+
+        checkbox.GettingNormalColor += (_, e) =>
+        {
+            if (SuperView is { HasFocus: true })
+            {
+                e.Cancel = true;
+
+                if (!HasFocus)
+                {
+                    e.NewValue = GetFocusColor ();
+                }
+                else
+                {
+                    // If _colorScheme was set, it's because of Hover
+                    if (checkbox._colorScheme is { })
+                    {
+                        e.NewValue = checkbox._colorScheme.Normal;
+                    }
+                    else
+                    {
+                        e.NewValue = GetNormalColor ();
+                    }
+                }
+            }
+        };
+
+        checkbox.GettingHotNormalColor += (_, e) =>
+        {
+            if (SuperView is { HasFocus: true })
+            {
+                e.Cancel = true;
+                if (!HasFocus)
+                {
+                    e.NewValue = GetHotFocusColor ();
+                }
+                else
+                {
+                    // If _colorScheme was set, it's because of Hover
+                    if (checkbox._colorScheme is { })
+                    {
+                        e.NewValue = checkbox._colorScheme.Normal;
+                    }
+                    else
+                    {
+                        e.NewValue = GetNormalColor ();
+                    }
+                }
+            }
+        };
+        checkbox.Selecting += (sender, args) =>
+        {
+            if (RaiseSelecting (args.Context) is true)
+            {
+                args.Cancel = true;
+
+                return;
+            }
+            ;
+
+            if (RaiseAccepting (args.Context) is true)
+            {
+                args.Cancel = true;
+            }
+        };
+
+        checkbox.CheckedStateChanged += (sender, args) =>
+        {
+            if (checkbox.CheckedState == CheckState.Checked)
+            {
+                SelectedItem = index;
+            }
+        };
+
+        return checkbox;
+    }
+
+    private void SetLayout ()
+    {
+        foreach (View sv in SubViews)
+        {
+            if (Orientation == Orientation.Vertical)
+            {
+                sv.X = 0;
+                sv.Y = Pos.Align (Alignment.Start);
+            }
+            else
+            {
+                sv.X = Pos.Align (Alignment.Start);
+                sv.Y = 0;
+                sv.Margin!.Thickness = new (0, 0, 1, 0);
+            }
+        }
+    }
+
+    private void UpdateChecked ()
+    {
+        foreach (CheckBox cb in SubViews.OfType<CheckBox> ())
+        {
+            var index = (int)(cb.Data ?? throw new InvalidOperationException ("CheckBox.Data must be set"));
+
+            cb.CheckedState = index == SelectedItem ? CheckState.Checked : CheckState.UnChecked;
+        }
+    }
+
+    #region IOrientation
+
+    /// <summary>
+    ///     Gets or sets the <see cref="Orientation"/> for this <see cref="OptionSelector"/>. The default is
+    ///     <see cref="Orientation.Vertical"/>.
+    /// </summary>
+    public Orientation Orientation
+    {
+        get => _orientationHelper.Orientation;
+        set => _orientationHelper.Orientation = value;
+    }
+
+    private readonly OrientationHelper _orientationHelper;
+
+#pragma warning disable CS0067 // The event is never used
+    /// <inheritdoc/>
+    public event EventHandler<CancelEventArgs<Orientation>>? OrientationChanging;
+
+    /// <inheritdoc/>
+    public event EventHandler<EventArgs<Orientation>>? OrientationChanged;
+#pragma warning restore CS0067 // The event is never used
+
+    /// <summary>Called when <see cref="Orientation"/> has changed.</summary>
+    /// <param name="newOrientation"></param>
+    public void OnOrientationChanged (Orientation newOrientation) { SetLayout (); }
+
+    #endregion IOrientation
+
+    /// <inheritdoc/>
+    public bool EnableForDesign ()
+    {
+        AssignHotKeysToCheckBoxes = true;
+        Options = new [] { "Option 1", "Option 2", "Option 3" };
+
+        return true;
+    }
+}

Terminal.Gui/Views/RadioGroup.cs

@@ -41,8 +41,6 @@ public class RadioGroup : View, IDesignable, IOrientation
         MouseBindings.Add (MouseFlags.Button1DoubleClicked, Command.Accept);
 
         SubViewLayout += RadioGroup_LayoutStarted;
-
-        HighlightStyle = HighlightStyle.PressedOutside | HighlightStyle.Pressed;
     }
 
     private bool? HandleHotKeyCommand (ICommandContext? ctx)
@@ -281,23 +279,24 @@ public class RadioGroup : View, IDesignable, IOrientation
             // Pick a unique hotkey for each radio label
             for (var labelIndex = 0; labelIndex < value.Length; labelIndex++)
             {
-                string label = value [labelIndex];
-                string? newLabel = label;
+                string name = value [labelIndex];
+                string? nameWithHotKey = name;
 
                 if (AssignHotKeysToRadioLabels)
                 {
                     // Find the first char in label that is [a-z], [A-Z], or [0-9]
-                    for (var i = 0; i < label.Length; i++)
+                    for (var i = 0; i < name.Length; i++)
                     {
-                        if (UsedHotKeys.Contains (new (label [i])) || !char.IsAsciiLetterOrDigit (label [i]))
+                        char c = char.ToLowerInvariant (name [i]);
+                        if (UsedHotKeys.Contains (new (c)) || !char.IsAsciiLetterOrDigit (c))
                         {
                             continue;
                         }
 
-                        if (char.IsAsciiLetterOrDigit (label [i]))
+                        if (char.IsAsciiLetterOrDigit (c))
                         {
-                            char? hotChar = label [i];
-                            newLabel = label.Insert (i, HotKeySpecifier.ToString ());
+                            char? hotChar = c;
+                            nameWithHotKey = name.Insert (i, HotKeySpecifier.ToString ());
                             UsedHotKeys.Add (new (hotChar));
 
                             break;
@@ -305,9 +304,9 @@ public class RadioGroup : View, IDesignable, IOrientation
                     }
                 }
 
-                _radioLabels.Add (newLabel);
+                _radioLabels.Add (nameWithHotKey);
 
-                if (TextFormatter.FindHotKey (newLabel, HotKeySpecifier, out _, out Key hotKey))
+                if (TextFormatter.FindHotKey (nameWithHotKey, HotKeySpecifier, out _, out Key hotKey))
                 {
                     AddKeyBindingsForHotKey (Key.Empty, hotKey, labelIndex);
                 }

Terminal.Gui/Views/SelectedItemChangedArgs.cs

@@ -1,4 +1,5 @@
-namespace Terminal.Gui;
+#nullable enable
+namespace Terminal.Gui;
 
 /// <summary>Event arguments for the SelectedItemChanged event.</summary>
 public class SelectedItemChangedArgs : EventArgs
@@ -6,15 +7,15 @@ public class SelectedItemChangedArgs : EventArgs
     /// <summary>Initializes a new <see cref="SelectedItemChangedArgs"/> class.</summary>
     /// <param name="selectedItem"></param>
     /// <param name="previousSelectedItem"></param>
-    public SelectedItemChangedArgs (int selectedItem, int previousSelectedItem)
+    public SelectedItemChangedArgs (int? selectedItem, int? previousSelectedItem)
     {
         PreviousSelectedItem = previousSelectedItem;
         SelectedItem = selectedItem;
     }
 
-    /// <summary>Gets the index of the item that was previously selected. -1 if there was no previous selection.</summary>
-    public int PreviousSelectedItem { get; }
+    /// <summary>Gets the index of the item that was previously selected. null if there was no previous selection.</summary>
+    public int? PreviousSelectedItem { get; }
 
-    /// <summary>Gets the index of the item that is now selected. -1 if there is no selection.</summary>
-    public int SelectedItem { get; }
+    /// <summary>Gets the index of the item that is now selected. null if there is no selection.</summary>
+    public int? SelectedItem { get; }
 }

Terminal.Gui/Views/Shortcut.cs

@@ -60,8 +60,6 @@ public class Shortcut : View, IOrientation, IDesignable
     /// <param name="helpText">The help text to display.</param>
     public Shortcut (Key key, string? commandText, Action? action, string? helpText = null)
     {
-        Id = $"shortcut:{commandText}";
-
         HighlightStyle = HighlightStyle.None;
         CanFocus = true;
 
@@ -90,11 +88,11 @@ public class Shortcut : View, IOrientation, IDesignable
         Title = commandText ?? string.Empty;
 
         HelpView.Id = "_helpView";
-        HelpView.CanFocus = false;
+        //HelpView.CanFocus = false;
         HelpView.Text = helpText ?? string.Empty;
 
         KeyView.Id = "_keyView";
-        KeyView.CanFocus = false;
+        //KeyView.CanFocus = false;
         key ??= Key.Empty;
         Key = key;
 
@@ -119,18 +117,6 @@ public class Shortcut : View, IOrientation, IDesignable
     // Once Frame.Width gets below this value, LayoutStarted makes HelpView an KeyView smaller.
     private int? _minimumNaturalWidth;
 
-    /// <inheritdoc/>
-    protected override bool OnHighlight (CancelEventArgs<HighlightStyle> args)
-    {
-        if (args.NewValue.HasFlag (HighlightStyle.Hover))
-        {
-            SetFocus ();
-            return true;
-        }
-
-        return false;
-    }
-
     /// <summary>
     ///     Gets or sets the <see cref="AlignmentModes"/> for this <see cref="Shortcut"/>.
     /// </summary>
@@ -176,9 +162,6 @@ public class Shortcut : View, IOrientation, IDesignable
             Add (KeyView);
             SetKeyViewDefaultLayout ();
         }
-
-        // BUGBUG: Causes ever other layout to lose focus colors
-        //SetColors ();
     }
 
     // Force Width to DimAuto to calculate natural width and then set it back
@@ -260,44 +243,54 @@ public class Shortcut : View, IOrientation, IDesignable
     }
 
     /// <summary>
-    ///     Called when a Command has been invoked on this Shortcut.
+    ///     Dispatches the Command in the <paramref name="commandContext"/> (Raises Selected, then Accepting, then invoke the Action, if any).
+    ///     Called when Command.Select, Accept, or HotKey has been invoked on this Shortcut.
     /// </summary>
     /// <param name="commandContext"></param>
-    /// <returns></returns>
+    /// <returns>
+    ///     <see langword="null"/> if no event was raised; input processing should continue.
+    ///     <see langword="false"/> if the event was raised and was not handled (or cancelled); input processing should continue.
+    ///     <see langword="true"/> if the event was raised and handled (or cancelled); input processing should stop.
+    /// </returns>
     internal virtual bool? DispatchCommand (ICommandContext? commandContext)
     {
-        Logging.Trace($"{commandContext?.Source?.Title}");
         CommandContext<KeyBinding>? keyCommandContext = commandContext as CommandContext<KeyBinding>? ?? default (CommandContext<KeyBinding>);
 
+        Logging.Debug ($"{Title} ({commandContext?.Source?.Title}) Command: {commandContext?.Command}");
+
         if (keyCommandContext?.Binding.Data != this)
         {
+            // TODO: Optimize this to only do this if CommandView is custom (non View)
             // Invoke Select on the CommandView to cause it to change state if it wants to
             // If this causes CommandView to raise Accept, we eat it
             keyCommandContext = keyCommandContext!.Value with { Binding = keyCommandContext.Value.Binding with { Data = this } };
 
-            Logging.Trace ($"Invoking Select on CommandView.");
+            Logging.Debug ($"{Title} ({commandContext?.Source?.Title}) - Invoking Select on CommandView ({CommandView.GetType ().Name}).");
 
             CommandView.InvokeCommand (Command.Select, keyCommandContext);
         }
 
-        // BUGBUG: Why does this use keyCommandContext and not commandContext?
-        Logging.Trace ($"RaiseSelecting ...");
-        if (RaiseSelecting (keyCommandContext) is true)
+        Logging.Debug ($"{Title} ({commandContext?.Source?.Title}) - RaiseSelecting ...");
+
+        if (RaiseSelecting (commandContext) is true)
         {
             return true;
         }
 
-        // The default HotKey handler sets Focus
-        Logging.Trace ($"SetFocus...");
-        SetFocus ();
+        if (CanFocus && SuperView is { CanFocus: true })
+        {
+            // The default HotKey handler sets Focus
+            Logging.Debug ($"{Title} ({commandContext?.Source?.Title}) - SetFocus...");
+            SetFocus ();
+        }
 
         var cancel = false;
 
-        if (commandContext is { })
+        if (commandContext is { Source: null })
         {
             commandContext.Source = this;
         }
-        Logging.Trace ($"RaiseAccepting...");
+        Logging.Debug ($"{Title} ({commandContext?.Source?.Title}) - Calling RaiseAccepting...");
         cancel = RaiseAccepting (commandContext) is true;
 
         if (cancel)
@@ -305,21 +298,15 @@ public class Shortcut : View, IOrientation, IDesignable
             return true;
         }
 
-        if (commandContext?.Command != Command.Accept)
-        {
-            // return false;
-        }
-
         if (Action is { })
         {
-            Logging.Trace ($"Invoke Action...");
+            Logging.Debug ($"{Title} ({commandContext?.Source?.Title}) - Invoke Action...");
             Action.Invoke ();
 
             // Assume if there's a subscriber to Action, it's handled.
             cancel = true;
         }
 
-
         return cancel;
     }
 
@@ -437,7 +424,7 @@ public class Shortcut : View, IOrientation, IDesignable
 
             // The default behavior is for CommandView to not get focus. I
             // If you want it to get focus, you need to set it.
-            _commandView.CanFocus = false;
+            // _commandView.CanFocus = false;
 
             _commandView.HotKeyChanged += (s, e) =>
                                           {
@@ -492,9 +479,31 @@ public class Shortcut : View, IOrientation, IDesignable
         CommandView.VerticalTextAlignment = Alignment.Center;
         CommandView.TextAlignment = Alignment.Start;
         CommandView.TextFormatter.WordWrap = false;
-        CommandView.HighlightStyle = HighlightStyle.None;
+        //CommandView.HighlightStyle = HighlightStyle.None;
+        CommandView.GettingNormalColor += CommandViewOnGettingNormalColor;
+        CommandView.GettingHotNormalColor += CommandViewOnGettingHotNormalColor;
+
     }
 
+    private void CommandViewOnGettingNormalColor (object? sender, CancelEventArgs<Attribute> e)
+    {
+        if (HasFocus)
+        {
+            e.Cancel = true;
+            e.NewValue = GetFocusColor ();
+        }
+    }
+
+    private void CommandViewOnGettingHotNormalColor (object? sender, CancelEventArgs<Attribute> e)
+    {
+        if (HasFocus && e is { })
+        {
+            e.Cancel = true;
+            e.NewValue = GetHotFocusColor ();
+        }
+    }
+
+
     private void Shortcut_TitleChanged (object? sender, EventArgs<string> e)
     {
         // If the Title changes, update the CommandView text.
@@ -533,6 +542,9 @@ public class Shortcut : View, IOrientation, IDesignable
         HelpView.TextAlignment = Alignment.Start;
         HelpView.TextFormatter.WordWrap = false;
         HelpView.HighlightStyle = HighlightStyle.None;
+
+        HelpView.GettingNormalColor += CommandViewOnGettingNormalColor;
+        HelpView.GettingHotNormalColor += CommandViewOnGettingHotNormalColor;
     }
 
     /// <summary>
@@ -619,10 +631,10 @@ public class Shortcut : View, IOrientation, IDesignable
     }
 
     /// <summary>
-    ///     Gets the subview that displays the key. Internal for unit testing.
+    ///     Gets the subview that displays the key. Is drawn with Normal and HotNormal colors reversed.
     /// </summary>
 
-    public View KeyView { get; } = new ();
+    public ShortcutKeyView KeyView { get; } = new ();
 
     private int _minimumKeyTextSize;
 
@@ -698,17 +710,6 @@ public class Shortcut : View, IOrientation, IDesignable
 
     #region Focus
 
-    /// <inheritdoc/>
-    public override ColorScheme? ColorScheme
-    {
-        get => base.ColorScheme;
-        set
-        {
-            base.ColorScheme = _nonFocusColorScheme = value;
-            SetColors ();
-        }
-    }
-
     private bool _forceFocusColors;
 
     /// <summary>
@@ -720,78 +721,31 @@ public class Shortcut : View, IOrientation, IDesignable
         set
         {
             _forceFocusColors = value;
-            SetColors (value);
-            //SetNeedsDraw();
+            SetNeedsDraw ();
         }
     }
 
-    private ColorScheme? _nonFocusColorScheme;
-
-    /// <summary>
-    /// </summary>
-    internal void SetColors (bool highlight = false)
+    /// <inheritdoc />
+    public override Attribute GetNormalColor ()
     {
-        if (HasFocus || highlight || ForceFocusColors)
+        if (HasFocus)
         {
-            if (_nonFocusColorScheme is null)
-            {
-                _nonFocusColorScheme = base.ColorScheme;
-            }
-
-            base.ColorScheme ??= new (Attribute.Default);
-
-            // When we have focus, we invert the colors
-            base.ColorScheme = new (base.ColorScheme)
-            {
-                Normal = GetFocusColor (),
-                HotNormal = GetHotFocusColor (),
-                HotFocus = GetHotNormalColor (),
-                Focus = GetNormalColor (),
-            };
-        }
-        else
-        {
-            if (_nonFocusColorScheme is { })
-            {
-                base.ColorScheme = _nonFocusColorScheme;
-                //_nonFocusColorScheme = null;
-            }
-            else
-            {
-                base.ColorScheme = SuperView?.ColorScheme ?? base.ColorScheme;
-            }
+            return base.GetFocusColor ();
         }
 
-        // Set KeyView's colors to show "hot"
-        if (IsInitialized && base.ColorScheme is { })
-        {
-            var cs = new ColorScheme (base.ColorScheme)
-            {
-                Normal = GetHotNormalColor (),
-                HotNormal = GetNormalColor ()
-            };
-            KeyView.ColorScheme = cs;
-        }
+        return base.GetNormalColor ();
+    }
 
-        if (CommandView.Margin is { })
-        {
-            CommandView.Margin.ColorScheme = base.ColorScheme;
-        }
-        if (HelpView.Margin is { })
-        {
-            HelpView.Margin.ColorScheme = base.ColorScheme;
-        }
+    /// <inheritdoc />
+    public override Attribute GetHotNormalColor ()
+    {
+        if (HasFocus)
 
-        if (KeyView.Margin is { })
         {
-            KeyView.Margin.ColorScheme = base.ColorScheme;
+            return base.GetHotFocusColor ();
         }
-    }
 
-    /// <inheritdoc/>
-    protected override void OnHasFocusChanged (bool newHasFocus, View? previousFocusedView, View? view)
-    {
-        SetColors ();
+        return base.GetHotNormalColor ();
     }
 
     #endregion Focus
@@ -832,3 +786,21 @@ public class Shortcut : View, IOrientation, IDesignable
         base.Dispose (disposing);
     }
 }
+
+/// <summary>
+///     A helper class used by <see cref="Shortcut"/> to display the key. Reverses the Normal and HotNormal colors.
+/// </summary>
+public class ShortcutKeyView : View
+{
+    /// <inheritdoc />
+    public override Attribute GetNormalColor ()
+    {
+        if (SuperView is { HasFocus: true })
+
+        {
+            return base.GetHotFocusColor ();
+        }
+
+        return base.GetHotNormalColor ();
+    }
+}

Terminal.Gui/Views/StatusBar.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Reflection;
+#nullable enable
 
 namespace Terminal.Gui;
 
@@ -23,16 +22,45 @@ public class StatusBar : Bar, IDesignable
         Y = Pos.AnchorEnd ();
         Width = Dim.Fill ();
         Height = Dim.Auto (DimAutoStyle.Content, 1);
-        BorderStyle = LineStyle.Dashed;
-        ColorScheme = Colors.ColorSchemes ["Menu"];
 
-        SubViewLayout += StatusBar_LayoutStarted;
+        if (Border is { })
+        {
+            Border.LineStyle = DefaultSeparatorLineStyle;
+        }
+
+        base.ColorScheme = Colors.ColorSchemes ["Menu"];
+
+        Applied += OnConfigurationManagerApplied;
+        SuperViewChanged += OnSuperViewChanged;
     }
 
-    // StatusBar arranges the items horizontally.
-    // The first item has no left border, the last item has no right border.
-    // The Shortcuts are configured with the command, help, and key views aligned in reverse order (EndToStart).
-    private void StatusBar_LayoutStarted (object sender, LayoutEventArgs e)
+    private void OnSuperViewChanged (object? sender, SuperViewChangedEventArgs e)
+    {
+        if (SuperView is null)
+        {
+            // BUGBUG: This is a hack for avoiding a race condition in ConfigurationManager.Apply
+            // BUGBUG: For some reason in some unit tests, when Top is disposed, MenuBar.Dispose does not get called.
+            // BUGBUG: Yet, the MenuBar does get Removed from Top (and it's SuperView set to null).
+            // BUGBUG: Related: https://github.com/gui-cs/Terminal.Gui/issues/4021
+            Applied -= OnConfigurationManagerApplied;
+        }
+    }
+    private void OnConfigurationManagerApplied (object? sender, ConfigurationManagerEventArgs e)
+    {
+        if (Border is { })
+        {
+            Border.LineStyle = DefaultSeparatorLineStyle;
+        }
+    }
+
+    /// <summary>
+    ///     Gets or sets the default Line Style for the separators between the shortcuts of the StatusBar.
+    /// </summary>
+    [SerializableConfigurationProperty (Scope = typeof (ThemeScope))]
+    public static LineStyle DefaultSeparatorLineStyle { get; set; } = LineStyle.Dashed;
+
+    /// <inheritdoc />
+    protected override void OnSubViewLayout (LayoutEventArgs args)
     {
         for (int index = 0; index < SubViews.Count; index++)
         {
@@ -40,13 +68,9 @@ public class StatusBar : Bar, IDesignable
 
             barItem.BorderStyle = BorderStyle;
 
-            if (index == SubViews.Count - 1)
-            {
-                barItem.Border.Thickness = new Thickness (0, 0, 0, 0);
-            }
-            else
+            if (barItem.Border is { })
             {
-                barItem.Border.Thickness = new Thickness (0, 0, 1, 0);
+                barItem.Border.Thickness = index == SubViews.Count - 1 ? new Thickness (0, 0, 0, 0) : new Thickness (0, 0, 1, 0);
             }
 
             if (barItem is Shortcut shortcut)
@@ -54,6 +78,7 @@ public class StatusBar : Bar, IDesignable
                 shortcut.Orientation = Orientation.Horizontal;
             }
         }
+        base.OnSubViewLayout (args);
     }
 
     /// <inheritdoc/>
@@ -108,7 +133,7 @@ public class StatusBar : Bar, IDesignable
             Text = "I'll Hide",
             // Visible = false
         };
-        button1.Accepting += Button_Clicked;
+        button1.Accepting += OnButtonClicked;
         Add (button1);
 
         shortcut.Accepting += (s, e) =>
@@ -135,7 +160,15 @@ public class StatusBar : Bar, IDesignable
 
         return true;
 
-        void Button_Clicked (object sender, EventArgs e) { MessageBox.Query ("Hi", $"You clicked {sender}"); }
+        void OnButtonClicked (object? sender, EventArgs? e) { MessageBox.Query ("Hi", $"You clicked {sender}"); }
     }
 
+    /// <inheritdoc />
+    protected override void Dispose (bool disposing)
+    {
+        base.Dispose (disposing);
+
+        SuperViewChanged -= OnSuperViewChanged;
+        Applied -= OnConfigurationManagerApplied;
+    }
 }

Terminal.Gui/Views/Wizard/WizardStep.cs

@@ -163,10 +163,12 @@ public class WizardStep : View
 
     /// <summary>Removes all <see cref="View"/>s from the <see cref="WizardStep"/>.</summary>
     /// <remarks></remarks>
-    public override void RemoveAll ()
+    public override IReadOnlyCollection<View> RemoveAll ()
     {
-        _contentView.RemoveAll ();
+        IReadOnlyCollection<View> removed = _contentView.RemoveAll ();
         ShowHide ();
+
+        return removed;
     }
 
     /// <summary>Does the work to show and hide the contentView and helpView as appropriate</summary>

TerminalGuiFluentTesting/FakeInput.cs

@@ -23,12 +23,12 @@ internal class FakeInput<T> : IConsoleInput<T>
     /// <inheritdoc/>
     public void Initialize (ConcurrentQueue<T> inputBuffer) { InputBuffer = inputBuffer; }
 
-    public ConcurrentQueue<T> InputBuffer { get; set; }
+    public ConcurrentQueue<T>? InputBuffer { get; set; }
 
     /// <inheritdoc/>
     public void Run (CancellationToken token)
     {
         // Blocks until either the token or the hardStopToken is cancelled.
-        WaitHandle.WaitAny (new [] { token.WaitHandle, _hardStopToken.WaitHandle, _timeoutCts.Token.WaitHandle });
+        WaitHandle.WaitAny ([token.WaitHandle, _hardStopToken.WaitHandle, _timeoutCts.Token.WaitHandle]);
     }
 }

TerminalGuiFluentTesting/GuiTestContext.cs

@@ -3,13 +3,12 @@ using System.Text;
 using Microsoft.Extensions.Logging;
 using Terminal.Gui;
 using Terminal.Gui.ConsoleDrivers;
-using static Unix.Terminal.Curses;
 
 namespace TerminalGuiFluentTesting;
 
 /// <summary>
-/// Fluent API context for testing a Terminal.Gui application. Create
-/// an instance using <see cref="With"/> static class.
+///     Fluent API context for testing a Terminal.Gui application. Create
+///     an instance using <see cref="With"/> static class.
 /// </summary>
 public class GuiTestContext : IDisposable
 {
@@ -23,7 +22,7 @@ public class GuiTestContext : IDisposable
     private View? _lastView;
     private readonly StringBuilder _logsSb;
     private readonly V2TestDriver _driver;
-    private bool _finished=false;
+    private bool _finished;
 
     internal GuiTestContext (Func<Toplevel> topLevelBuilder, int width, int height, V2TestDriver driver)
     {
@@ -68,6 +67,7 @@ public class GuiTestContext : IDisposable
                                      t.Closed += (s, e) => { _finished = true; };
                                      Application.Run (t); // This will block, but it's on a background thread now
 
+                                     t.Dispose ();
                                      Application.Shutdown ();
                                  }
                                  catch (OperationCanceledException)
@@ -97,12 +97,12 @@ public class GuiTestContext : IDisposable
     private string GetDriverName ()
     {
         return _driver switch
-        {
-            V2TestDriver.V2Win => "v2win",
-            V2TestDriver.V2Net => "v2net",
-            _ =>
-                throw new ArgumentOutOfRangeException ()
-        };
+               {
+                   V2TestDriver.V2Win => "v2win",
+                   V2TestDriver.V2Net => "v2net",
+                   _ =>
+                       throw new ArgumentOutOfRangeException ()
+               };
     }
 
     /// <summary>
@@ -115,7 +115,7 @@ public class GuiTestContext : IDisposable
             return this;
         }
 
-        Application.Invoke (() => {Application.RequestStop ();});
+        Application.Invoke (() => { Application.RequestStop (); });
 
         // Wait for the application to stop, but give it a 1-second timeout
         if (!_runTask.Wait (TimeSpan.FromMilliseconds (1000)))
@@ -148,7 +148,7 @@ public class GuiTestContext : IDisposable
     }
 
     /// <summary>
-    /// Cleanup to avoid state bleed between tests
+    ///     Cleanup to avoid state bleed between tests
     /// </summary>
     public void Dispose ()
     {
@@ -184,7 +184,7 @@ public class GuiTestContext : IDisposable
     }
 
     /// <summary>
-    /// Simulates changing the console size e.g. by resizing window in your operating system
+    ///     Simulates changing the console size e.g. by resizing window in your operating system
     /// </summary>
     /// <param name="width">new Width for the console.</param>
     /// <param name="height">new Height for the console.</param>
@@ -203,11 +203,11 @@ public class GuiTestContext : IDisposable
 
         writer.WriteLine (text);
 
-        return WaitIteration ();
+        return this; //WaitIteration();
     }
 
     /// <summary>
-    /// Writes all Terminal.Gui engine logs collected so far to the <paramref name="writer"/>
+    ///     Writes all Terminal.Gui engine logs collected so far to the <paramref name="writer"/>
     /// </summary>
     /// <param name="writer"></param>
     /// <returns></returns>
@@ -215,12 +215,12 @@ public class GuiTestContext : IDisposable
     {
         writer.WriteLine (_logsSb.ToString ());
 
-        return WaitIteration ();
+        return this; //WaitIteration();
     }
 
     /// <summary>
-    /// Waits until the end of the current iteration of the main loop. Optionally
-    /// running a given <paramref name="a"/> action on the UI thread at that time.
+    ///     Waits until the end of the current iteration of the main loop. Optionally
+    ///     running a given <paramref name="a"/> action on the UI thread at that time.
     /// </summary>
     /// <param name="a"></param>
     /// <returns></returns>
@@ -255,8 +255,8 @@ public class GuiTestContext : IDisposable
     }
 
     /// <summary>
-    /// Performs the supplied <paramref name="doAction"/> immediately.
-    /// Enables running commands without breaking the Fluent API calls.
+    ///     Performs the supplied <paramref name="doAction"/> immediately.
+    ///     Enables running commands without breaking the Fluent API calls.
     /// </summary>
     /// <param name="doAction"></param>
     /// <returns></returns>
@@ -266,22 +266,20 @@ public class GuiTestContext : IDisposable
         {
             doAction ();
         }
-        catch(Exception)
+        catch (Exception)
         {
             HardStop ();
 
             throw;
-
         }
 
         return this;
     }
 
-
     /// <summary>
-    /// Simulates a right click at the given screen coordinates on the current driver.
-    /// This is a raw input event that goes through entire processing pipeline as though
-    /// user had pressed the mouse button physically.
+    ///     Simulates a right click at the given screen coordinates on the current driver.
+    ///     This is a raw input event that goes through entire processing pipeline as though
+    ///     user had pressed the mouse button physically.
     /// </summary>
     /// <param name="screenX">0 indexed screen coordinates</param>
     /// <param name="screenY">0 indexed screen coordinates</param>
@@ -289,29 +287,25 @@ public class GuiTestContext : IDisposable
     public GuiTestContext RightClick (int screenX, int screenY) { return Click (WindowsConsole.ButtonState.Button3Pressed, screenX, screenY); }
 
     /// <summary>
-    /// Simulates a left click at the given screen coordinates on the current driver.
-    /// This is a raw input event that goes through entire processing pipeline as though
-    /// user had pressed the mouse button physically.
+    ///     Simulates a left click at the given screen coordinates on the current driver.
+    ///     This is a raw input event that goes through entire processing pipeline as though
+    ///     user had pressed the mouse button physically.
     /// </summary>
     /// <param name="screenX">0 indexed screen coordinates</param>
     /// <param name="screenY">0 indexed screen coordinates</param>
     /// <returns></returns>
-    public GuiTestContext LeftClick (int screenX, int screenY)
-    {
-        return Click (WindowsConsole.ButtonState.Button1Pressed, screenX, screenY);
-    }
+    public GuiTestContext LeftClick (int screenX, int screenY) { return Click (WindowsConsole.ButtonState.Button1Pressed, screenX, screenY); }
 
-    public GuiTestContext LeftClick<T> (Func<T,bool> evaluator) where T : View
-    {
-        return Click (WindowsConsole.ButtonState.Button1Pressed,evaluator);
-    }
+    public GuiTestContext LeftClick<T> (Func<T, bool> evaluator) where T : View { return Click (WindowsConsole.ButtonState.Button1Pressed, evaluator); }
 
-    private GuiTestContext Click<T> (WindowsConsole.ButtonState btn, Func<T, bool> evaluator) where T:View
+    private GuiTestContext Click<T> (WindowsConsole.ButtonState btn, Func<T, bool> evaluator) where T : View
     {
-        var v = Find (evaluator);
-        var screen = v.ViewportToScreen (new Point (0, 0));
+        T v = Find (evaluator);
+        Point screen = v.ViewportToScreen (new Point (0, 0));
+
         return Click (btn, screen.X, screen.Y);
     }
+
     private GuiTestContext Click (WindowsConsole.ButtonState btn, int screenX, int screenY)
     {
         switch (_driver)
@@ -339,29 +333,32 @@ public class GuiTestContext : IDisposable
                                                        MousePosition = new ((short)screenX, (short)screenY)
                                                    }
                                                });
+
                 break;
             case V2TestDriver.V2Net:
 
                 int netButton = btn switch
-                {
-                    WindowsConsole.ButtonState.Button1Pressed => 0,
-                    WindowsConsole.ButtonState.Button2Pressed => 1,
-                    WindowsConsole.ButtonState.Button3Pressed => 2,
-                    WindowsConsole.ButtonState.RightmostButtonPressed => 2,
-                    _ => throw new ArgumentOutOfRangeException (nameof (btn))
-                };
-                foreach (var k in NetSequences.Click (netButton, screenX, screenY))
+                                {
+                                    WindowsConsole.ButtonState.Button1Pressed => 0,
+                                    WindowsConsole.ButtonState.Button2Pressed => 1,
+                                    WindowsConsole.ButtonState.Button3Pressed => 2,
+                                    WindowsConsole.ButtonState.RightmostButtonPressed => 2,
+                                    _ => throw new ArgumentOutOfRangeException (nameof (btn))
+                                };
+
+                foreach (ConsoleKeyInfo k in NetSequences.Click (netButton, screenX, screenY))
                 {
                     SendNetKey (k);
                 }
+
                 break;
             default:
                 throw new ArgumentOutOfRangeException ();
         }
 
-        WaitIteration ();
+        return WaitIteration ();
 
-        return this;
+        ;
     }
 
     public GuiTestContext Down ()
@@ -370,24 +367,26 @@ public class GuiTestContext : IDisposable
         {
             case V2TestDriver.V2Win:
                 SendWindowsKey (ConsoleKeyMapping.VK.DOWN);
-                WaitIteration ();
+
                 break;
             case V2TestDriver.V2Net:
-                foreach (var k in NetSequences.Down)
+                foreach (ConsoleKeyInfo k in NetSequences.Down)
                 {
                     SendNetKey (k);
                 }
+
                 break;
             default:
                 throw new ArgumentOutOfRangeException ();
         }
 
+        return WaitIteration ();
 
-        return this;
+        ;
     }
 
     /// <summary>
-    /// Simulates the Right cursor key
+    ///     Simulates the Right cursor key
     /// </summary>
     /// <returns></returns>
     /// <exception cref="ArgumentOutOfRangeException"></exception>
@@ -397,24 +396,26 @@ public class GuiTestContext : IDisposable
         {
             case V2TestDriver.V2Win:
                 SendWindowsKey (ConsoleKeyMapping.VK.RIGHT);
-                WaitIteration ();
+
                 break;
             case V2TestDriver.V2Net:
-                foreach (var k in NetSequences.Right)
+                foreach (ConsoleKeyInfo k in NetSequences.Right)
                 {
                     SendNetKey (k);
                 }
+
                 WaitIteration ();
+
                 break;
             default:
                 throw new ArgumentOutOfRangeException ();
         }
 
-        return this;
+        return WaitIteration ();
     }
 
     /// <summary>
-    /// Simulates the Left cursor key
+    ///     Simulates the Left cursor key
     /// </summary>
     /// <returns></returns>
     /// <exception cref="ArgumentOutOfRangeException"></exception>
@@ -424,23 +425,24 @@ public class GuiTestContext : IDisposable
         {
             case V2TestDriver.V2Win:
                 SendWindowsKey (ConsoleKeyMapping.VK.LEFT);
-                WaitIteration ();
+
                 break;
             case V2TestDriver.V2Net:
-                foreach (var k in NetSequences.Left)
+                foreach (ConsoleKeyInfo k in NetSequences.Left)
                 {
                     SendNetKey (k);
                 }
+
                 break;
             default:
                 throw new ArgumentOutOfRangeException ();
         }
 
-        return this;
+        return WaitIteration ();
     }
 
     /// <summary>
-    /// Simulates the up cursor key
+    ///     Simulates the up cursor key
     /// </summary>
     /// <returns></returns>
     /// <exception cref="ArgumentOutOfRangeException"></exception>
@@ -450,23 +452,24 @@ public class GuiTestContext : IDisposable
         {
             case V2TestDriver.V2Win:
                 SendWindowsKey (ConsoleKeyMapping.VK.UP);
-                WaitIteration ();
+
                 break;
             case V2TestDriver.V2Net:
-                foreach (var k in NetSequences.Up)
+                foreach (ConsoleKeyInfo k in NetSequences.Up)
                 {
                     SendNetKey (k);
                 }
+
                 break;
             default:
                 throw new ArgumentOutOfRangeException ();
         }
 
-        return this;
+        return WaitIteration ();
     }
 
     /// <summary>
-    /// Simulates pressing the Return/Enter (newline) key.
+    ///     Simulates pressing the Return/Enter (newline) key.
     /// </summary>
     /// <returns></returns>
     /// <exception cref="ArgumentOutOfRangeException"></exception>
@@ -484,20 +487,21 @@ public class GuiTestContext : IDisposable
                                     wVirtualKeyCode = ConsoleKeyMapping.VK.RETURN,
                                     wVirtualScanCode = 28
                                 });
+
                 break;
             case V2TestDriver.V2Net:
                 SendNetKey (new ('\r', ConsoleKey.Enter, false, false, false));
+
                 break;
             default:
                 throw new ArgumentOutOfRangeException ();
         }
 
-        return this;
+        return WaitIteration ();
     }
 
-
     /// <summary>
-    /// Simulates pressing the Esc (Escape) key.
+    ///     Simulates pressing the Esc (Escape) key.
     /// </summary>
     /// <returns></returns>
     /// <exception cref="ArgumentOutOfRangeException"></exception>
@@ -515,12 +519,14 @@ public class GuiTestContext : IDisposable
                                     wVirtualKeyCode = ConsoleKeyMapping.VK.ESCAPE,
                                     wVirtualScanCode = 1
                                 });
+
                 break;
             case V2TestDriver.V2Net:
 
                 // Note that this accurately describes how Esc comes in. Typically, ConsoleKey is None
                 // even though you would think it would be Escape - it isn't
                 SendNetKey (new ('\u001b', ConsoleKey.None, false, false, false));
+
                 break;
             default:
                 throw new ArgumentOutOfRangeException ();
@@ -529,10 +535,8 @@ public class GuiTestContext : IDisposable
         return this;
     }
 
-
-
     /// <summary>
-    /// Simulates pressing the Tab key.
+    ///     Simulates pressing the Tab key.
     /// </summary>
     /// <returns></returns>
     /// <exception cref="ArgumentOutOfRangeException"></exception>
@@ -550,12 +554,14 @@ public class GuiTestContext : IDisposable
                                     wVirtualKeyCode = 0,
                                     wVirtualScanCode = 0
                                 });
+
                 break;
             case V2TestDriver.V2Net:
 
                 // Note that this accurately describes how Tab comes in. Typically, ConsoleKey is None
                 // even though you would think it would be Tab - it isn't
                 SendNetKey (new ('\t', ConsoleKey.None, false, false, false));
+
                 break;
             default:
                 throw new ArgumentOutOfRangeException ();
@@ -565,8 +571,8 @@ public class GuiTestContext : IDisposable
     }
 
     /// <summary>
-    /// Registers a right click handler on the <see cref="LastView"/> added view (or root view) that
-    /// will open the supplied <paramref name="contextMenu"/>.
+    ///     Registers a right click handler on the <see cref="LastView"/> added view (or root view) that
+    ///     will open the supplied <paramref name="contextMenu"/>.
     /// </summary>
     /// <param name="contextMenu"></param>
     /// <returns></returns>
@@ -587,7 +593,7 @@ public class GuiTestContext : IDisposable
     }
 
     /// <summary>
-    /// The last view added (e.g. with <see cref="Add"/>) or the root/current top.
+    ///     The last view added (e.g. with <see cref="Add"/>) or the root/current top.
     /// </summary>
     public View LastView => _lastView ?? Application.Top ?? throw new ("Could not determine which view to add to");
 
@@ -620,11 +626,7 @@ public class GuiTestContext : IDisposable
         WaitIteration ();
     }
 
-
-    private void SendNetKey (ConsoleKeyInfo consoleKeyInfo)
-    {
-        _netInput.InputBuffer.Enqueue (consoleKeyInfo);
-    }
+    private void SendNetKey (ConsoleKeyInfo consoleKeyInfo) { _netInput.InputBuffer.Enqueue (consoleKeyInfo); }
 
     /// <summary>
     ///     Sends a special key e.g. cursor key that does not map to a specific character
@@ -666,10 +668,23 @@ public class GuiTestContext : IDisposable
     }
 
     /// <summary>
-    /// Sets the input focus to the given <see cref="View"/>.
-    /// Throws <see cref="ArgumentException"/> if focus did not change due to system
-    /// constraints e.g. <paramref name="toFocus"/>
-    /// <see cref="View.CanFocus"/> is <see langword="false"/>
+    ///     Sends a key to the application. This goes directly to Application and does not go through
+    ///     a driver.
+    /// </summary>
+    /// <param name="key"></param>
+    /// <returns></returns>
+    public GuiTestContext RaiseKeyDownEvent (Key key)
+    {
+        Application.RaiseKeyDownEvent (key);
+
+        return this; //WaitIteration();
+    }
+
+    /// <summary>
+    ///     Sets the input focus to the given <see cref="View"/>.
+    ///     Throws <see cref="ArgumentException"/> if focus did not change due to system
+    ///     constraints e.g. <paramref name="toFocus"/>
+    ///     <see cref="View.CanFocus"/> is <see langword="false"/>
     /// </summary>
     /// <param name="toFocus"></param>
     /// <returns></returns>
@@ -687,27 +702,28 @@ public class GuiTestContext : IDisposable
     }
 
     /// <summary>
-    /// Tabs through the UI until a View matching the <paramref name="evaluator"/>
-    /// is found (of Type T) or all views are looped through (back to the beginning)
-    /// in which case triggers hard stop and Exception
+    ///     Tabs through the UI until a View matching the <paramref name="evaluator"/>
+    ///     is found (of Type T) or all views are looped through (back to the beginning)
+    ///     in which case triggers hard stop and Exception
     /// </summary>
     /// <returns></returns>
     /// <exception cref="ArgumentException"></exception>
-    public GuiTestContext Focus<T> (Func<T,bool> evaluator) where T:View
+    public GuiTestContext Focus<T> (Func<T, bool> evaluator) where T : View
     {
-        var t = Application.Top;
+        Toplevel? t = Application.Top;
 
         HashSet<View> seen = new ();
 
         if (t == null)
         {
             Fail ("Application.Top was null when trying to set focus");
+
             return this;
         }
 
         do
         {
-            var next = t.MostFocused;
+            View? next = t.MostFocused;
 
             // Is view found?
             if (next is T v && evaluator (v))
@@ -716,13 +732,14 @@ public class GuiTestContext : IDisposable
             }
 
             // No, try tab to the next (or first)
-            this.Tab ();
+            Tab ();
             WaitIteration ();
             next = t.MostFocused;
 
             if (next is null)
             {
                 Fail ("Failed to tab to a view which matched the Type and evaluator constraints of the test because MostFocused became or was always null");
+
                 return this;
             }
 
@@ -734,22 +751,20 @@ public class GuiTestContext : IDisposable
 
                 return this;
             }
-
         }
         while (true);
     }
 
-
-
     private T Find<T> (Func<T, bool> evaluator) where T : View
     {
-        var t = Application.Top;
+        Toplevel? t = Application.Top;
 
         if (t == null)
         {
             Fail ("Application.Top was null when attempting to find view");
         }
-        var f = FindRecursive(t!, evaluator);
+
+        T? f = FindRecursive (t!, evaluator);
 
         if (f == null)
         {
@@ -761,7 +776,7 @@ public class GuiTestContext : IDisposable
 
     private T? FindRecursive<T> (View current, Func<T, bool> evaluator) where T : View
     {
-        foreach (var subview in current.SubViews)
+        foreach (View subview in current.SubViews)
         {
             if (subview is T match && evaluator (match))
             {
@@ -769,7 +784,8 @@ public class GuiTestContext : IDisposable
             }
 
             // Recursive call
-            var result = FindRecursive (subview, evaluator);
+            T? result = FindRecursive (subview, evaluator);
+
             if (result != null)
             {
                 return result;
@@ -783,8 +799,7 @@ public class GuiTestContext : IDisposable
     {
         Stop ();
 
-        throw new Exception (reason);
-
+        throw new (reason);
     }
 
     public GuiTestContext Send (Key key)
@@ -798,6 +813,7 @@ public class GuiTestContext : IDisposable
         {
             Fail ("Expected Application.Driver to be IConsoleDriverFacade");
         }
+
         return this;
     }
 }

Tests/IntegrationTests/FluentTests/BasicFluentAssertionTests.cs

@@ -8,13 +8,47 @@ public class BasicFluentAssertionTests
 {
     private readonly TextWriter _out;
 
-    public BasicFluentAssertionTests (ITestOutputHelper outputHelper) { _out = new TestOutputWriter (outputHelper); }
+    public BasicFluentAssertionTests (ITestOutputHelper outputHelper)
+    {
+        _out = new TestOutputWriter (outputHelper);
+    }
+
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void GuiTestContext_NewInstance_Runs (V2TestDriver d)
+    {
+        using GuiTestContext context = With.A<Window> (40, 10, d);
+        Assert.True (Application.Top!.Running);
+
+        context.WriteOutLogs (_out);
+        context.Stop ();
+    }
+
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void GuiTestContext_QuitKey_Stops (V2TestDriver d)
+    {
+        using GuiTestContext context = With.A<Window> (40, 10, d);
+        Assert.True (Application.Top!.Running);
+
+        Toplevel top = Application.Top;
+        context.RaiseKeyDownEvent (Application.QuitKey);
+        Assert.False (top!.Running);
+
+        Application.Top?.Dispose ();
+        Application.Shutdown();
+
+        context.WriteOutLogs (_out);
+        context.Stop ();
+    }
 
     [Theory]
     [ClassData (typeof (V2TestDrivers))]
     public void GuiTestContext_StartsAndStopsWithoutError (V2TestDriver d)
     {
-        using GuiTestContext context = With.A<Window> (40, 10,d);
+        using GuiTestContext context = With.A<Window> (40, 10, d);
 
         // No actual assertions are needed — if no exceptions are thrown, it's working
         context.Stop ();
@@ -51,10 +85,10 @@ public class BasicFluentAssertionTests
     {
         var clicked = false;
 
-        MenuItemv2 [] menuItems =  [new ("_New File", string.Empty, () => { clicked = true; })];
+        MenuItemv2 [] menuItems = [new ("_New File", string.Empty, () => { clicked = true; })];
 
         using GuiTestContext c = With.A<Window> (40, 10, d)
-                                     .WithContextMenu (new PopoverMenu(menuItems))
+                                     .WithContextMenu (new PopoverMenu (menuItems))
                                      .ScreenShot ("Before open menu", _out)
 
                                      // Click in main area inside border
@@ -90,7 +124,7 @@ public class BasicFluentAssertionTests
                                       new  ("Six", "", null)
                                   ];
 
-        using GuiTestContext c = With.A<Window> (40, 10,d)
+        using GuiTestContext c = With.A<Window> (40, 10, d)
                                      .WithContextMenu (new PopoverMenu (menuItems))
                                      .ScreenShot ("Before open menu", _out)
 
@@ -100,7 +134,7 @@ public class BasicFluentAssertionTests
                                      .Down ()
                                      .Down ()
                                      .Down ()
-                                     .Right()
+                                     .Right ()
                                      .ScreenShot ("After open submenu", _out)
                                      .Down ()
                                      .Enter ()

Tests/IntegrationTests/FluentTests/FileDialogFluentTests.cs

@@ -11,7 +11,10 @@ public class FileDialogFluentTests
 {
     private readonly TextWriter _out;
 
-    public FileDialogFluentTests (ITestOutputHelper outputHelper) { _out = new TestOutputWriter (outputHelper); }
+    public FileDialogFluentTests (ITestOutputHelper outputHelper)
+    {
+        _out = new TestOutputWriter (outputHelper);
+    }
 
     private MockFileSystem CreateExampleFileSystem ()
     {
@@ -41,27 +44,25 @@ public class FileDialogFluentTests
     [ClassData (typeof (V2TestDrivers))]
     public void CancelFileDialog_UsingEscape (V2TestDriver d)
     {
-        var sd = new SaveDialog ( CreateExampleFileSystem ());
+        var sd = new SaveDialog (CreateExampleFileSystem ());
         using var c = With.A (sd, 100, 20, d)
-            .ScreenShot ("Save dialog",_out)
-            .Escape()
+            .ScreenShot ("Save dialog", _out)
+            .Escape ()
+            .Then (() => Assert.True (sd.Canceled))
             .Stop ();
-
-        Assert.True (sd.Canceled);
     }
 
     [Theory]
     [ClassData (typeof (V2TestDrivers))]
     public void CancelFileDialog_UsingCancelButton_TabThenEnter (V2TestDriver d)
     {
-        var sd = new SaveDialog (CreateExampleFileSystem ());
+        var sd = new SaveDialog (CreateExampleFileSystem ()) { Modal = false };
         using var c = With.A (sd, 100, 20, d)
                           .ScreenShot ("Save dialog", _out)
-                          .Focus <Button>(b=> b.Text == "_Cancel")
+                          .Focus<Button> (b => b.Text == "_Cancel")
+                          .Then (() => Assert.True (sd.Canceled))
                           .Enter ()
                           .Stop ();
-
-        Assert.True (sd.Canceled);
     }
 
     [Theory]
@@ -69,13 +70,13 @@ public class FileDialogFluentTests
     public void CancelFileDialog_UsingCancelButton_LeftClickButton (V2TestDriver d)
     {
         var sd = new SaveDialog (CreateExampleFileSystem ());
+
         using var c = With.A (sd, 100, 20, d)
                           .ScreenShot ("Save dialog", _out)
-                          .LeftClick <Button> (b => b.Text == "_Cancel")
-                          .Stop ()
-                          .WriteOutLogs (_out);
-
-        Assert.True (sd.Canceled);
+                          .LeftClick<Button> (b => b.Text == "_Cancel")
+                          .WriteOutLogs (_out)
+                          .Then (() => Assert.True (sd.Canceled))
+                          .Stop ();
     }
     [Theory]
     [ClassData (typeof (V2TestDrivers))]
@@ -86,9 +87,8 @@ public class FileDialogFluentTests
                           .ScreenShot ("Save dialog", _out)
                           .Send (Key.C.WithAlt)
                           .WriteOutLogs (_out)
+                          .Then (() => Assert.True (sd.Canceled))
                           .Stop ();
-
-        Assert.True (sd.Canceled);
     }
 
     [Theory]
@@ -101,10 +101,9 @@ public class FileDialogFluentTests
                           .ScreenShot ("Save dialog", _out)
                           .LeftClick<Button> (b => b.Text == "_Save")
                           .WriteOutLogs (_out)
+                          .Then (() => Assert.False (sd.Canceled))
+                          .Then (() => AssertIsFileSystemRoot (fs, sd))
                           .Stop ();
-
-        Assert.False (sd.Canceled);
-        AssertIsFileSystemRoot (fs, sd);
     }
 
     [Theory]
@@ -117,10 +116,10 @@ public class FileDialogFluentTests
                           .ScreenShot ("Save dialog", _out)
                           .Send (Key.S.WithAlt)
                           .WriteOutLogs (_out)
+                          .Then (() => Assert.False (sd.Canceled))
+                          .Then (() => AssertIsFileSystemRoot (fs, sd))
                           .Stop ();
 
-        Assert.False (sd.Canceled);
-        AssertIsFileSystemRoot (fs, sd);
     }
 
     [Theory]
@@ -128,16 +127,15 @@ public class FileDialogFluentTests
     public void SaveFileDialog_UsingOkButton_TabEnter (V2TestDriver d)
     {
         var fs = CreateExampleFileSystem ();
-        var sd = new SaveDialog (fs);
+        var sd = new SaveDialog (fs) { Modal = false };
         using var c = With.A (sd, 100, 20, d)
                           .ScreenShot ("Save dialog", _out)
-                          .Focus <Button> (b => b.Text == "_Save")
+                          .Focus<Button> (b => b.Text == "_Save")
                           .Enter ()
                           .WriteOutLogs (_out)
+                          .Then (() => Assert.False (sd.Canceled))
+                          .Then (() => AssertIsFileSystemRoot (fs, sd))
                           .Stop ();
-
-        Assert.False (sd.Canceled);
-        AssertIsFileSystemRoot (fs,sd);
     }
 
     private void AssertIsFileSystemRoot (IFileSystem fs, SaveDialog sd)
@@ -155,43 +153,40 @@ public class FileDialogFluentTests
     [ClassData (typeof (V2TestDrivers))]
     public void SaveFileDialog_PressingPopTree_ShouldNotChangeCancel (V2TestDriver d)
     {
-        var sd = new SaveDialog (CreateExampleFileSystem ()) { Modal = true };
+        var sd = new SaveDialog (CreateExampleFileSystem ()) { Modal = false };
         using var c = With.A (sd, 100, 20, d)
                           .ScreenShot ("Save dialog", _out)
-                          .AssertTrue (sd.Canceled)
+                          .Then (() => Assert.True (sd.Canceled))
                           .Focus<Button> (b => b.Text == "►►")
                           .Enter ()
                           .ScreenShot ("After pop tree", _out)
-                          .AssertTrue (sd.Canceled)
                           .WriteOutLogs (_out)
+                          .Then (() => Assert.True (sd.Canceled))
                           .Stop ();
 
-        Assert.True(sd.Canceled);
     }
 
     [Theory]
     [ClassData (typeof (V2TestDrivers))]
     public void SaveFileDialog_PopTree_AndNavigate (V2TestDriver d)
     {
-        var sd = new SaveDialog (CreateExampleFileSystem ()) { Modal = true };
+        var sd = new SaveDialog (CreateExampleFileSystem ()) { Modal = false };
 
         using var c = With.A (sd, 100, 20, d)
                           .ScreenShot ("Save dialog", _out)
-                          .AssertTrue (sd.Canceled)
-                          .LeftClick <Button> (b => b.Text == "►►")
+                          .Then (() => Assert.True (sd.Canceled))
+                          .LeftClick<Button> (b => b.Text == "►►")
                           .ScreenShot ("After pop tree", _out)
-                          .Focus <TreeView<IFileSystemInfo>> (_ => true)
+                          .Focus<TreeView<IFileSystemInfo>> (_ => true)
                           .Right ()
                           .ScreenShot ("After expand tree", _out)
                           .Down ()
                           .ScreenShot ("After navigate down in tree", _out)
                           .Enter ()
                           .WaitIteration ()
-                          .AssertFalse (sd.Canceled)
+                          .Then (() => Assert.False (sd.Canceled))
                           .AssertContains ("empty-dir", sd.FileName)
                           .WriteOutLogs (_out)
                           .Stop ();
-
-        Assert.False (sd.Canceled);
     }
 }

Tests/IntegrationTests/FluentTests/MenuBarv2Tests.cs

@@ -0,0 +1,509 @@
+using System.Reflection;
+using Terminal.Gui;
+using TerminalGuiFluentTesting;
+using Xunit.Abstractions;
+
+namespace IntegrationTests.FluentTests;
+
+/// <summary>
+///     Tests for the MenuBarv2 class
+/// </summary>
+public class MenuBarv2Tests
+{
+    private readonly TextWriter _out;
+
+    public MenuBarv2Tests (ITestOutputHelper outputHelper)
+    {
+        _out = new TestOutputWriter (outputHelper);
+    }
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void Initializes_WithNoItems (V2TestDriver d)
+    {
+        using GuiTestContext c = With.A<Window> (80, 25, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                // Create a menu bar with no items
+                                                var menuBar = new MenuBarv2 ();
+                                                Assert.Empty (menuBar.SubViews);
+                                                Assert.False (menuBar.CanFocus);
+                                                Assert.Equal (Orientation.Horizontal, menuBar.Orientation);
+                                                Assert.Equal (Key.F9, MenuBarv2.DefaultKey);
+                                            })
+                                     .WriteOutLogs (_out)
+                                     .Stop ();
+    }
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void Initializes_WithItems (V2TestDriver d)
+    {
+        MenuBarItemv2 [] menuItems = [];
+
+        using GuiTestContext c = With.A<Window> (80, 25, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                // Create items for the menu bar
+                                                menuItems =
+                                                [
+                                                    new (
+                                                         "_File",
+                                                         [
+                                                             new MenuItemv2 ("_Open", "Opens a file", () => { })
+                                                         ]),
+                                                    new (
+                                                         "_Edit",
+                                                         [
+                                                             new MenuItemv2 ("_Copy", "Copies selection", () => { })
+                                                         ])
+                                                ];
+
+                                                var menuBar = new MenuBarv2 (menuItems);
+                                                Assert.Equal (2, menuBar.SubViews.Count);
+
+                                                // First item should be the File menu
+                                                var fileMenu = menuBar.SubViews.ElementAt (0) as MenuBarItemv2;
+                                                Assert.NotNull (fileMenu);
+                                                Assert.Equal ("_File", fileMenu.Title);
+
+                                                // Second item should be the Edit menu
+                                                var editMenu = menuBar.SubViews.ElementAt (1) as MenuBarItemv2;
+                                                Assert.NotNull (editMenu);
+                                                Assert.Equal ("_Edit", editMenu.Title);
+                                            })
+                                     .WriteOutLogs (_out)
+                                     .Stop ();
+    }
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void AddsItems_WithMenusProperty (V2TestDriver d)
+    {
+        using GuiTestContext c = With.A<Window> (80, 25, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                var menuBar = new MenuBarv2 ();
+
+                                                // Set items through Menus property
+                                                menuBar.Menus =
+                                                [
+                                                    new ("_File"),
+                                                    new ("_Edit"),
+                                                    new ("_View")
+                                                ];
+
+                                                Assert.Equal (3, menuBar.SubViews.Count);
+                                            })
+                                     .WriteOutLogs (_out)
+                                     .Stop ();
+    }
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void ChangesKey_RaisesEvent (V2TestDriver d)
+    {
+        using GuiTestContext c = With.A<Window> (80, 25, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                var menuBar = new MenuBarv2 ();
+
+                                                var oldKeyValue = Key.Empty;
+                                                var newKeyValue = Key.Empty;
+                                                var eventRaised = false;
+
+                                                menuBar.KeyChanged += (_, args) =>
+                                                                      {
+                                                                          eventRaised = true;
+                                                                          oldKeyValue = args.OldKey;
+                                                                          newKeyValue = args.NewKey;
+                                                                      };
+
+                                                // Default key should be F9
+                                                Assert.Equal (Key.F9, menuBar.Key);
+
+                                                // Change key to F1
+                                                menuBar.Key = Key.F1;
+
+                                                // Verify event was raised
+                                                Assert.True (eventRaised);
+                                                Assert.Equal (Key.F9, oldKeyValue);
+                                                Assert.Equal (Key.F1, newKeyValue);
+
+                                                // Verify key was changed
+                                                Assert.Equal (Key.F1, menuBar.Key);
+                                            })
+                                     .WriteOutLogs (_out)
+                                     .Stop ();
+    }
+
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void DefaultKey_Activates (V2TestDriver d)
+    {
+        MenuBarv2? menuBar = null;
+
+        using GuiTestContext c = With.A<Window> (50, 20, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                menuBar = new MenuBarv2 ();
+                                                Toplevel top = Application.Top!;
+
+                                                top.Add (
+                                                         new View ()
+                                                         {
+                                                             CanFocus = true,
+                                                             Id = "focusableView",
+
+                                                         });
+                                                menuBar.EnableForDesign (ref top);
+                                                Application.Top!.Add (menuBar);
+                                            })
+                                     .WaitIteration ()
+                                     .Then (() => Assert.IsNotType<MenuItemv2> (Application.Navigation!.GetFocused ()))
+                                     .ScreenShot ("MenuBar initial state", _out)
+                                     .RaiseKeyDownEvent (MenuBarv2.DefaultKey)
+                                     .WaitIteration ()
+                                     .ScreenShot ($"After {MenuBarv2.DefaultKey}", _out)
+                                     .WriteOutLogs (_out)
+                                     .Then (() => Assert.Equal ("_New file", Application.Navigation!.GetFocused ()!.Title))
+                                     .Then (() => Assert.True (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .Then (() => Assert.True (menuBar?.IsOpen ()))
+                                     .WriteOutLogs (_out)
+                                     .Stop ();
+    }
+
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void DefaultKey_DeActivates (V2TestDriver d)
+    {
+        MenuBarv2? menuBar = null;
+
+        using GuiTestContext c = With.A<Window> (50, 20, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                menuBar = new MenuBarv2 ();
+                                                Toplevel top = Application.Top!;
+
+                                                top.Add (
+                                                         new View ()
+                                                         {
+                                                             CanFocus = true,
+                                                             Id = "focusableView",
+
+                                                         });
+                                                menuBar.EnableForDesign (ref top);
+                                                Application.Top!.Add (menuBar);
+                                            })
+                                     .WaitIteration ()
+                                     .Then (() => Assert.IsNotType<MenuItemv2>(Application.Navigation!.GetFocused()))
+                                     .ScreenShot ("MenuBar initial state", _out)
+                                     .RaiseKeyDownEvent (MenuBarv2.DefaultKey)
+                                     .ScreenShot ($"After {MenuBarv2.DefaultKey}", _out)
+                                     .Then (() => Assert.Equal ("_New file", Application.Navigation!.GetFocused ()!.Title))
+                                     .RaiseKeyDownEvent (MenuBarv2.DefaultKey)
+                                     .ScreenShot ($"After {MenuBarv2.DefaultKey}", _out)
+                                     .Then (() => Assert.IsNotType<MenuItemv2>(Application.Navigation!.GetFocused()))
+                                     .WriteOutLogs (_out)
+                                     .Stop ();
+    }
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void ShowHidePopovers (V2TestDriver d)
+    {
+        using GuiTestContext c = With.A<Window> (80, 25, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                // Create a menu bar with items that have submenus
+                                                var fileMenuItem = new MenuBarItemv2 (
+                                                                                      "_File",
+                                                                                      [
+                                                                                          new MenuItemv2 ("_Open", string.Empty, null),
+                                                                                          new MenuItemv2 ("_Save", string.Empty, null)
+                                                                                      ]);
+
+                                                var menuBar = new MenuBarv2 ([fileMenuItem]);
+
+                                                // Initially, no menu should be open
+                                                Assert.False (menuBar.IsOpen ());
+                                                Assert.False (menuBar.Active);
+
+                                                // Initialize the menu bar
+                                                menuBar.BeginInit ();
+                                                menuBar.EndInit ();
+
+                                                // Simulate showing a popover menu by manipulating the first menu item
+                                                MethodInfo? showPopoverMethod = typeof (MenuBarv2).GetMethod (
+                                                 "ShowPopover",
+                                                 BindingFlags.NonPublic | BindingFlags.Instance);
+
+                                                // Set menu bar to active state using reflection
+                                                FieldInfo? activeField = typeof (MenuBarv2).GetField (
+                                                                                                      "_active",
+                                                                                                      BindingFlags.NonPublic | BindingFlags.Instance);
+                                                activeField?.SetValue (menuBar, true);
+                                                menuBar.CanFocus = true;
+
+                                                // Show the popover menu
+                                                showPopoverMethod?.Invoke (menuBar, new object? [] { fileMenuItem });
+
+                                                // Should be active now
+                                                Assert.True (menuBar.Active);
+
+                                                // Test if we can hide the popover menu
+                                                fileMenuItem.PopoverMenu!.Visible = true;
+
+                                                Assert.True (menuBar.HideActiveItem ());
+
+                                                // Menu should no longer be open or active
+                                                Assert.False (menuBar.Active);
+                                                Assert.False (menuBar.IsOpen ());
+                                                Assert.False (menuBar.CanFocus);
+                                            })
+                                     .WriteOutLogs (_out)
+                                     .Stop ();
+    }
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void EnableForDesign_CreatesMenuItems (V2TestDriver d)
+    {
+        using GuiTestContext c = With.A<Window> (80, 25, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                var menuBar = new MenuBarv2 ();
+                                                Application.Top!.Add (menuBar);
+
+                                                // Call EnableForDesign
+                                                Toplevel top = Application.Top!;
+                                                bool result = menuBar.EnableForDesign (ref top);
+
+                                                // Should return true
+                                                Assert.True (result);
+
+                                                // Should have created menu items
+                                                Assert.True (menuBar.SubViews.Count > 0);
+
+                                                // Should have File, Edit and Help menus
+                                                View? fileMenu = menuBar.SubViews.FirstOrDefault (v => (v as MenuBarItemv2)?.Title == "_File");
+                                                View? editMenu = menuBar.SubViews.FirstOrDefault (v => (v as MenuBarItemv2)?.Title == "_Edit");
+                                                View? helpMenu = menuBar.SubViews.FirstOrDefault (v => (v as MenuBarItemv2)?.Title == "_Help");
+
+                                                Assert.NotNull (fileMenu);
+                                                Assert.NotNull (editMenu);
+                                                Assert.NotNull (helpMenu);
+                                            })
+                                     .ScreenShot ("MenuBarv2 EnableForDesign", _out)
+                                     .WriteOutLogs (_out)
+                                     .Stop ();
+    }
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void Navigation_Left_Right_Wraps (V2TestDriver d)
+    {
+        MenuBarv2? menuBar = null;
+
+        using GuiTestContext c = With.A<Window> (50, 20, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                menuBar = new MenuBarv2 ();
+                                                Toplevel top = Application.Top!;
+                                                menuBar.EnableForDesign (ref top);
+                                                Application.Top!.Add (menuBar);
+                                            })
+                                     .WaitIteration ()
+                                     .ScreenShot ("MenuBar initial state", _out)
+                                     .RaiseKeyDownEvent (MenuBarv2.DefaultKey)
+                                     .Then (() => Assert.True (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .Then (() => Assert.True (menuBar?.IsOpen ()))
+                                     .Then (() => Assert.Equal ("_New file", Application.Navigation?.GetFocused ()!.Title))
+                                     .ScreenShot ($"After {MenuBarv2.DefaultKey}", _out)
+                                     .Right ()
+                                     .Then (() => Assert.True (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .ScreenShot ("After right arrow", _out)
+                                     .Then (() => Assert.Equal ("Cu_t", Application.Navigation?.GetFocused ()!.Title))
+                                     .Right ()
+                                     .ScreenShot ("After second right arrow", _out)
+                                     .Then (() => Assert.Equal ("_Online Help...", Application.Navigation?.GetFocused ()!.Title))
+                                     .ScreenShot ("After third right arrow", _out)
+                                     .Right ()
+                                     .ScreenShot ("After fourth right arrow", _out)
+                                     .Then (() => Assert.Equal ("_New file", Application.Navigation?.GetFocused ()!.Title))
+                                     .Left ()
+                                     .ScreenShot ("After left arrow", _out)
+                                     .Then (() => Assert.Equal ("_Online Help...", Application.Navigation?.GetFocused ()!.Title))
+                                     .WriteOutLogs (_out)
+                                     .Stop ();
+    }
+
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void MenuBarItem_With_QuitKey_Open_QuitKey_Restores_Focus_Correctly (V2TestDriver d)
+    {
+        MenuBarv2? menuBar = null;
+
+        using GuiTestContext c = With.A<Window> (50, 20, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                menuBar = new MenuBarv2 ();
+                                                Toplevel top = Application.Top!;
+
+                                                top.Add (
+                                                         new View ()
+                                                         {
+                                                             CanFocus = true,
+                                                             Id = "focusableView",
+
+                                                         });
+                                                menuBar.EnableForDesign (ref top);
+                                                Application.Top!.Add (menuBar);
+                                            })
+                                     .WaitIteration ()
+                                     .Then (() => Assert.IsNotType<MenuItemv2>(Application.Navigation!.GetFocused()))
+                                     .ScreenShot ("MenuBar initial state", _out)
+                                     .RaiseKeyDownEvent (MenuBarv2.DefaultKey)
+                                     .Then (() => Assert.Equal ("_New file", Application.Navigation!.GetFocused ()!.Title))
+                                     .Then (() => Assert.True (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .Then (() => Assert.True (menuBar?.IsOpen ()))
+                                     .Then (() => Assert.Equal ("_New file", Application.Navigation?.GetFocused ()!.Title))
+                                     .ScreenShot ($"After {MenuBarv2.DefaultKey}", _out)
+                                     .RaiseKeyDownEvent (Application.QuitKey)
+                                     .Then (() => Assert.False (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .Then (() => Assert.IsNotType<MenuItemv2> (Application.Navigation!.GetFocused ()))
+                                     .WriteOutLogs (_out)
+                                     .Stop ();
+    }
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void MenuBarItem_Without_QuitKey_Open_QuitKey_Restores_Focus_Correctly (V2TestDriver d)
+    {
+        MenuBarv2? menuBar = null;
+
+        using GuiTestContext c = With.A<Window> (50, 20, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                menuBar = new MenuBarv2 ();
+                                                Toplevel top = Application.Top!;
+
+                                                top.Add (
+                                                         new View ()
+                                                         {
+                                                             CanFocus = true,
+                                                             Id = "focusableView",
+
+                                                         });
+                                                menuBar.EnableForDesign (ref top);
+                                                Application.Top!.Add (menuBar);
+                                            })
+                                     .WaitIteration ()
+                                     .Then (() => Assert.IsNotType<MenuItemv2> (Application.Navigation!.GetFocused ()))
+                                     .ScreenShot ("MenuBar initial state", _out)
+                                     .RaiseKeyDownEvent (MenuBarv2.DefaultKey)
+                                     .RaiseKeyDownEvent (Key.CursorRight)
+                                     .Then (() => Assert.Equal ("Cu_t", Application.Navigation!.GetFocused ()!.Title))
+                                     .Then (() => Assert.True (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .Then (() => Assert.True (menuBar?.IsOpen ()))
+                                     .Then (() => Assert.Equal ("Cu_t", Application.Navigation?.GetFocused ()!.Title))
+                                     .ScreenShot ($"After {MenuBarv2.DefaultKey}", _out)
+                                     .RaiseKeyDownEvent (Application.QuitKey)
+                                     .WriteOutLogs (_out)
+                                     .Then (() => Assert.False (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .Then (() => Assert.IsNotType<MenuItemv2> (Application.Navigation!.GetFocused ()))
+                                     .Stop ();
+    }
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void MenuBarItem_With_QuitKey_Open_QuitKey_Does_Not_Quit_App (V2TestDriver d)
+    {
+        MenuBarv2? menuBar = null;
+
+        using GuiTestContext c = With.A<Window> (50, 20, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                menuBar = new MenuBarv2 ();
+                                                Toplevel top = Application.Top!;
+
+                                                top.Add (
+                                                         new View ()
+                                                         {
+                                                             CanFocus = true,
+                                                             Id = "focusableView",
+
+                                                         });
+                                                menuBar.EnableForDesign (ref top);
+                                                Application.Top!.Add (menuBar);
+                                            })
+                                     .WaitIteration ()
+                                     .Then (() => Assert.IsNotType<MenuItemv2> (Application.Navigation!.GetFocused ()))
+                                     .ScreenShot ("MenuBar initial state", _out)
+                                     .RaiseKeyDownEvent (MenuBarv2.DefaultKey)
+                                     .Then (() => Assert.Equal ("_New file", Application.Navigation!.GetFocused ()!.Title))
+                                     .Then (() => Assert.True (Application.Top!.Running))
+                                     .ScreenShot ($"After {MenuBarv2.DefaultKey}", _out)
+                                     .RaiseKeyDownEvent (Application.QuitKey)
+                                     .Then (() => Assert.False (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .Then (() => Assert.True (Application.Top!.Running))
+                                     .WriteOutLogs (_out)
+                                     .Stop ();
+    }
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void MenuBarItem_Without_QuitKey_Open_QuitKey_Does_Not_Quit_MenuBar_SuperView (V2TestDriver d)
+    {
+        MenuBarv2? menuBar = null;
+
+        using GuiTestContext c = With.A<Window> (50, 20, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                menuBar = new MenuBarv2 ();
+                                                Toplevel top = Application.Top!;
+
+                                                top.Add (
+                                                         new View ()
+                                                         {
+                                                             CanFocus = true,
+                                                             Id = "focusableView",
+
+                                                         });
+                                                menuBar.EnableForDesign (ref top);
+                                                IEnumerable<MenuItemv2> items = menuBar.GetMenuItemsWithTitle ("_Quit");
+                                                foreach (MenuItemv2 item in items)
+                                                {
+                                                    item.Key = Key.Empty;
+                                                }
+                                                Application.Top!.Add (menuBar);
+                                            })
+                                     .WaitIteration ()
+                                     .Then (() => Assert.IsNotType<MenuItemv2> (Application.Navigation!.GetFocused ()))
+                                     .ScreenShot ("MenuBar initial state", _out)
+                                     .RaiseKeyDownEvent (MenuBarv2.DefaultKey)
+                                     .Then (() => Assert.Equal ("_New file", Application.Navigation!.GetFocused ()!.Title))
+                                     .ScreenShot ($"After {MenuBarv2.DefaultKey}", _out)
+                                     .RaiseKeyDownEvent (Application.QuitKey)
+                                     .Then (() => Assert.False (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .Then (() => Assert.True (Application.Top!.Running))
+                                     .WriteOutLogs (_out)
+                                     .Stop ();
+    }
+}

Tests/IntegrationTests/FluentTests/PopverMenuTests.cs

@@ -0,0 +1,243 @@
+using System.Reflection;
+using Terminal.Gui;
+using TerminalGuiFluentTesting;
+using Xunit.Abstractions;
+
+namespace IntegrationTests.FluentTests;
+
+/// <summary>
+///     Tests for the PopoverMenu class
+/// </summary>
+public class PopoverMenuTests (ITestOutputHelper outputHelper)
+{
+    private readonly TextWriter _out = new TestOutputWriter (outputHelper);
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void EnableForDesign_CreatesMenuItems (V2TestDriver d)
+    {
+        using GuiTestContext c = With.A<Window> (80, 25, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                var popoverMenu = new PopoverMenu ();
+                                                Application.Top!.Add (popoverMenu);
+
+                                                // Call EnableForDesign
+                                                Toplevel top = Application.Top;
+                                                bool result = popoverMenu.EnableForDesign (ref top);
+
+                                                // Should return true
+                                                Assert.True (result);
+
+                                                // Should have created menu items
+                                                Assert.NotNull (popoverMenu.Root);
+                                                Assert.Equal (7, popoverMenu.Root.SubViews.Count);
+
+                                                // Should have Cut menu item
+                                                View? cutMenuItem = popoverMenu.GetMenuItemsOfAllSubMenus ().FirstOrDefault (v => v?.Title == "Cu_t");
+
+                                                Assert.NotNull (cutMenuItem);
+                                            })
+                                     .Stop ();
+    }
+
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void Activate_Sets_Application_Navigation_Correctly (V2TestDriver d)
+    {
+        MenuBarv2? menuBar = null;
+
+        using GuiTestContext c = With.A<Window> (50, 20, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                var popoverMenu = new PopoverMenu ();
+
+                                                // Call EnableForDesign
+                                                Toplevel top = Application.Top!;
+                                                popoverMenu.EnableForDesign (ref top);
+
+                                                View? view = new View ()
+                                                {
+                                                    CanFocus = true,
+                                                    Height = Dim.Auto (),
+                                                    Width = Dim.Auto (),
+                                                    Id = "focusableView",
+                                                    Text = "View",
+                                                };
+                                                Application.Top!.Add (view);
+
+                                                // EnableForDesign sets to true; undo that
+                                                popoverMenu.Visible = false;
+
+                                                Application.Popover!.Register (popoverMenu);
+
+                                                view.SetFocus ();
+                                            })
+                                     .WaitIteration ()
+                                     .Then (() => Assert.False (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .Then (() => Assert.IsNotType<MenuItemv2> (Application.Navigation!.GetFocused ()))
+                                     .ScreenShot ("PopoverMenu initial state", _out)
+                                     .Then (() => Application.Popover!.Show (Application.Popover.Popovers.First ()))
+                                     .WaitIteration ()
+                                     .ScreenShot ($"After Show", _out)
+                                     .Then (() => Assert.True (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .Then (() => Assert.Equal ("Cu_t", Application.Navigation!.GetFocused ()!.Title))
+                                     .WriteOutLogs (_out)
+                                     .Stop ();
+    }
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void QuitKey_Hides (V2TestDriver d)
+    {
+        MenuBarv2? menuBar = null;
+
+        using GuiTestContext c = With.A<Window> (50, 20, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                var popoverMenu = new PopoverMenu ();
+
+                                                // Call EnableForDesign
+                                                Toplevel top = Application.Top!;
+                                                bool result = popoverMenu.EnableForDesign (ref top);
+
+                                                View? view = new View ()
+                                                {
+                                                    CanFocus = true,
+                                                    Height = Dim.Auto (),
+                                                    Width = Dim.Auto (),
+                                                    Id = "focusableView",
+                                                    Text = "View",
+                                                };
+                                                Application.Top!.Add (view);
+
+                                                // EnableForDesign sets to true; undo that
+                                                popoverMenu.Visible = false;
+
+                                                Application.Popover!.Register (popoverMenu);
+
+                                                view.SetFocus ();
+                                            })
+                                     .WaitIteration ()
+                                     .ScreenShot ("PopoverMenu initial state", _out)
+                                     .Then (() => Assert.False (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .Then (() => Application.Popover!.Show (Application.Popover.Popovers.First ()))
+                                     .WaitIteration ()
+                                     .ScreenShot ($"After Show", _out)
+                                     .Then (() => Assert.True (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .RaiseKeyDownEvent (Application.QuitKey)
+                                     .Then (() => Application.LayoutAndDraw (true))
+                                     .WaitIteration ()
+                                     .WriteOutLogs (_out)
+                                     .ScreenShot ($"After {Application.QuitKey}", _out)
+                                     .Then (() => Assert.False (Application.Popover!.Popovers.Cast<PopoverMenu> ().FirstOrDefault()!.Visible))
+                                     .Then (() => Assert.Null (Application.Popover!.GetActivePopover()))
+                                     .Then (() => Assert.True (Application.Top!.Running))
+                                     .WriteOutLogs (_out)
+                                     .Stop ();
+    }
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void QuitKey_Restores_Focus_Correctly (V2TestDriver d)
+    {
+        MenuBarv2? menuBar = null;
+
+        using GuiTestContext c = With.A<Window> (50, 20, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                var popoverMenu = new PopoverMenu ();
+
+                                                // Call EnableForDesign
+                                                Toplevel top = Application.Top!;
+                                                bool result = popoverMenu.EnableForDesign (ref top);
+
+                                                View? view = new View ()
+                                                {
+                                                    CanFocus = true,
+                                                    Height = Dim.Auto (),
+                                                    Width = Dim.Auto (),
+                                                    Id = "focusableView",
+                                                    Text = "View",
+                                                };
+                                                Application.Top!.Add (view);
+
+                                                // EnableForDesign sets to true; undo that
+                                                popoverMenu.Visible = false;
+
+                                                Application.Popover!.Register (popoverMenu);
+
+                                                view.SetFocus ();
+                                            })
+                                     .WaitIteration ()
+                                     .ScreenShot ("PopoverMenu initial state", _out)
+                                     .Then (() => Assert.False (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .Then (() => Assert.IsNotType<MenuItemv2>(Application.Navigation!.GetFocused()))
+                                     .Then (() => Application.Popover!.Show (Application.Popover.Popovers.First ()))
+                                     .WaitIteration ()
+                                     .ScreenShot ($"After Show", _out)
+                                     .Then (() => Assert.True (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .Then (() => Assert.IsType<MenuItemv2>(Application.Navigation!.GetFocused()))
+                                     .RaiseKeyDownEvent (Application.QuitKey)
+                                     .ScreenShot ($"After {Application.QuitKey}", _out)
+                                     .Then (() => Assert.False (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .Then (() => Assert.IsNotType<MenuItemv2>(Application.Navigation!.GetFocused()))
+                                     .WriteOutLogs (_out)
+                                     .Stop ();
+    }
+
+    [Theory]
+    [ClassData (typeof (V2TestDrivers))]
+    public void MenuBarItem_With_QuitKey_Open_QuitKey_Does_Not_Quit_App (V2TestDriver d)
+    {
+        MenuBarv2? menuBar = null;
+
+        using GuiTestContext c = With.A<Window> (50, 20, d)
+                                     .Then (
+                                            () =>
+                                            {
+                                                var popoverMenu = new PopoverMenu ();
+
+                                                // Call EnableForDesign
+                                                Toplevel top = Application.Top!;
+                                                bool result = popoverMenu.EnableForDesign (ref top);
+
+                                                View? view = new View ()
+                                                {
+                                                    CanFocus = true,
+                                                    Height = Dim.Auto (),
+                                                    Width = Dim.Auto (),
+                                                    Id = "focusableView",
+                                                    Text = "View",
+                                                };
+                                                Application.Top!.Add (view);
+
+                                                // EnableForDesign sets to true; undo that
+                                                popoverMenu.Visible = false;
+
+                                                Application.Popover!.Register (popoverMenu);
+
+                                                view.SetFocus ();
+                                            })
+                                     .WaitIteration ()
+                                     .Then (() => Assert.IsNotType<MenuItemv2>(Application.Navigation!.GetFocused()))
+                                     .ScreenShot ("PopoverMenu initial state", _out)
+                                     .Then (() => Application.Popover!.Show (Application.Popover.Popovers.First ()))
+                                     .WaitIteration ()
+                                     .ScreenShot ("PopoverMenu after Show", _out)
+                                     .Then (() => Assert.Equal ("Cu_t", Application.Navigation!.GetFocused ()!.Title))
+                                     .Then (() => Assert.True (Application.Top!.Running))
+                                     .RaiseKeyDownEvent (Application.QuitKey)
+                                     .Then (() => Application.LayoutAndDraw ())
+                                     .ScreenShot ($"After {Application.QuitKey}", _out)
+                                     .Then (() => Assert.False (Application.Popover?.GetActivePopover () is PopoverMenu))
+                                     .Then (() => Assert.True (Application.Top!.Running))
+                                     .WriteOutLogs (_out)
+                                     .Stop ();
+    }
+}

Tests/IntegrationTests/UICatalog/ScenarioTests.cs

@@ -13,7 +13,7 @@ public class ScenarioTests : TestsAllViews
     public ScenarioTests (ITestOutputHelper output)
     {
 #if DEBUG_IDISPOSABLE
-        View.DebugIDisposable = true;
+        View.EnableDebugIDisposableAsserts = true;
         View.Instances.Clear ();
 #endif
         _output = output;
@@ -44,11 +44,12 @@ public class ScenarioTests : TestsAllViews
         _output.WriteLine ($"Running Scenario '{scenarioType}'");
         var scenario = Activator.CreateInstance (scenarioType) as Scenario;
 
-        uint abortTime = 1500;
+        uint abortTime = 2000;
         object? timeout = null;
         var initialized = false;
-        var shutdown = false;
+        var shutdownGracefully = false;
         var iterationCount = 0;
+        Key quitKey = Application.QuitKey;
 
         Application.InitializedChanged += OnApplicationOnInitializedChanged;
 
@@ -69,7 +70,9 @@ public class ScenarioTests : TestsAllViews
         }
 
         Assert.True (initialized);
-        Assert.True (shutdown);
+
+
+        Assert.True (shutdownGracefully, $"Scenario Failed to Quit with {quitKey} after {abortTime}ms and {iterationCount} iterations. Force quit.");
 
 #if DEBUG_IDISPOSABLE
         Assert.Empty (View.Instances);
@@ -101,13 +104,13 @@ public class ScenarioTests : TestsAllViews
             else
             {
                 Application.Iteration -= OnApplicationOnIteration;
-                shutdown = true;
+                shutdownGracefully = true;
             }
 
-            _output.WriteLine ($"Initialized == {a.CurrentValue}");
+            _output.WriteLine ($"Initialized == {a.CurrentValue}; shutdownGracefully == {shutdownGracefully}.");
         }
 
-        // If the scenario doesn't close within 500ms, this will force it to quit
+        // If the scenario doesn't close within abortTime ms, this will force it to quit
         bool ForceCloseCallback ()
         {
             lock (_timeoutLock)
@@ -118,9 +121,6 @@ public class ScenarioTests : TestsAllViews
                 }
             }
 
-            Assert.Fail (
-                         $"Scenario Failed to Quit with {Application.QuitKey} after {abortTime}ms and {iterationCount} iterations. Force quit.");
-
             // Restore the configuration locations
             ConfigurationManager.Locations = savedConfigLocations;
             ConfigurationManager.Reset ();
@@ -137,8 +137,9 @@ public class ScenarioTests : TestsAllViews
             if (Application.Initialized)
             {
                 // Press QuitKey 
-                _output.WriteLine ($"Attempting to quit with {Application.QuitKey}");
-                Application.RaiseKeyDownEvent (Application.QuitKey);
+                quitKey = Application.QuitKey;
+                _output.WriteLine ($"Attempting to quit with {quitKey} after {iterationCount} iterations.");
+                Application.RaiseKeyDownEvent (quitKey);
             }
         }
     }
@@ -171,7 +172,7 @@ public class ScenarioTests : TestsAllViews
 
         var top = new Toplevel ();
 
-        Dictionary<string, Type> viewClasses = GetAllViewClasses().ToDictionary (t => t.Name);
+        Dictionary<string, Type> viewClasses = GetAllViewClasses ().ToDictionary (t => t.Name);
 
         Window leftPane = new ()
         {
@@ -277,7 +278,7 @@ public class ScenarioTests : TestsAllViews
         classListView.SelectedItemChanged += (s, args) =>
                                               {
                                                   // Remove existing class, if any
-                                                  if (curView is {})
+                                                  if (curView is { })
                                                   {
                                                       curView.SubViewsLaidOut -= LayoutCompleteHandler;
                                                       hostPane.Remove (curView);
@@ -357,10 +358,13 @@ public class ScenarioTests : TestsAllViews
                                      {
                                          classListView.MoveDown ();
 
-                                         Assert.Equal (
-                                                       curView!.GetType ().Name,
-                                                       viewClasses.Values.ToArray () [classListView.SelectedItem].Name
-                                                      );
+                                         if (curView is { })
+                                         {
+                                             Assert.Equal (
+                                                           curView.GetType ().Name,
+                                                           viewClasses.Values.ToArray () [classListView.SelectedItem].Name
+                                                          );
+                                         }
                                      }
                                      else
                                      {
@@ -507,12 +511,26 @@ public class ScenarioTests : TestsAllViews
                 // For each of the <T> arguments
                 List<Type> typeArguments = new ();
 
-                // use <object>
+                // use <object> or the original type if applicable
                 foreach (Type arg in type.GetGenericArguments ())
                 {
-                    typeArguments.Add (typeof (object));
+                    if (arg.IsValueType && Nullable.GetUnderlyingType (arg) == null)
+                    {
+                        typeArguments.Add (arg);
+                    }
+                    else
+                    {
+                        typeArguments.Add (typeof (object));
+                    }
                 }
 
+                // Ensure the type does not contain any generic parameters
+                if (type.ContainsGenericParameters)
+                {
+                    Logging.Warning ($"Cannot create an instance of {type} because it contains generic parameters.");
+                    //throw new ArgumentException ($"Cannot create an instance of {type} because it contains generic parameters.");
+                    return null;
+                }
                 // And change what type we are instantiating from MyClass<T> to MyClass<object>
                 type = type.MakeGenericType (typeArguments.ToArray ());
             }

Tests/StressTests/ScenariosStressTests.cs

@@ -11,7 +11,7 @@ public class ScenariosStressTests : TestsAllViews
     public ScenariosStressTests (ITestOutputHelper output)
     {
 #if DEBUG_IDISPOSABLE
-        View.DebugIDisposable = true;
+        View.EnableDebugIDisposableAsserts = true;
         View.Instances.Clear ();
 #endif
         _output = output;

Tests/UnitTests/Application/ApplicationPopoverTests.cs

@@ -1,11 +1,9 @@
-using static System.Net.Mime.MediaTypeNames;
-
-namespace Terminal.Gui.ApplicationTests;
+namespace Terminal.Gui.ApplicationTests;
 
 public class ApplicationPopoverTests
 {
     [Fact]
-    public void ApplicationInit_Initializes_PopoverManager ()
+    public void Application_Init_Initializes_PopoverManager ()
     {
         // Arrange
         Assert.Null (Application.Popover);
@@ -18,7 +16,7 @@ public class ApplicationPopoverTests
     }
 
     [Fact]
-    public void Application_Shutdown_CleansUp_PopoverManager ()
+    public void Application_Shutdown_Resets_PopoverManager ()
     {
         // Arrange
         Assert.Null (Application.Popover);
@@ -34,7 +32,7 @@ public class ApplicationPopoverTests
     }
 
     [Fact]
-    public void Application_End_Does_Not_CleanedUp ()
+    public void Application_End_Does_Not_Reset_PopoverManager ()
     {
         // Arrange
         Assert.Null (Application.Popover);
@@ -79,8 +77,8 @@ public class ApplicationPopoverTests
         Assert.False (popover.Visible);
         Assert.NotNull (Application.Popover);
 
-        popover.Dispose ();
         Application.Shutdown ();
+        Assert.Equal (1, popover.DisposedCount);
     }
 
     [Fact]
@@ -97,7 +95,7 @@ public class ApplicationPopoverTests
         Application.Shutdown ();
 
         // Test
-        Assert.Equal(1, popover.DisposedCount);
+        Assert.Equal (1, popover.DisposedCount);
     }
 
     [Fact]
@@ -119,6 +117,7 @@ public class ApplicationPopoverTests
         Assert.Equal (0, popover.DisposedCount);
 
         popover.Dispose ();
+        Assert.Equal (1, popover.DisposedCount);
     }
 
     [Fact]
@@ -131,6 +130,7 @@ public class ApplicationPopoverTests
         PopoverTestClass popover = new ();
 
         Application.Popover?.Show (popover);
+        Application.Popover?.DeRegister (popover);
 
         // Act
         Application.Shutdown ();
@@ -139,9 +139,10 @@ public class ApplicationPopoverTests
         Assert.Equal (0, popover.DisposedCount);
 
         popover.Dispose ();
+        Assert.Equal (1, popover.DisposedCount);
     }
 
-    public class PopoverTestClass : View, IPopover
+    public class PopoverTestClass : PopoverBaseImpl
     {
         public List<Key> HandledKeys { get; } = [];
         public int NewCommandInvokeCount { get; private set; }
@@ -168,15 +169,15 @@ public class ApplicationPopoverTests
         protected override bool OnKeyDown (Key key)
         {
             HandledKeys.Add (key);
+
             return false;
         }
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         protected override void Dispose (bool disposing)
         {
             base.Dispose (disposing);
             DisposedCount++;
         }
     }
-
 }

Tests/UnitTests/Application/ApplicationTests.cs

@@ -16,7 +16,7 @@ public class ApplicationTests
         Locations = ConfigLocations.Default;
 
 #if DEBUG_IDISPOSABLE
-        View.DebugIDisposable = true;
+        View.EnableDebugIDisposableAsserts = true;
         View.Instances.Clear ();
         RunState.Instances.Clear ();
 #endif
@@ -166,24 +166,27 @@ public class ApplicationTests
         Assert.Null (Application.Top);
         Toplevel top = new ();
         Application.Begin (top);
-        Assert.Equal (new (0, 0, 80, 25), Application.Top.Frame);
+        Assert.Equal (new (0, 0, 80, 25), Application.Top!.Frame);
         ((FakeDriver)Application.Driver!).SetBufferSize (5, 5);
-        Assert.Equal (new (0, 0, 5, 5), Application.Top.Frame);
+        Assert.Equal (new (0, 0, 5, 5), Application.Top!.Frame);
         top.Dispose ();
     }
 
     [Fact]
     public void End_And_Shutdown_Should_Not_Dispose_ApplicationTop ()
     {
+        Assert.Null (Application.Top);
+
         Init ();
 
         RunState rs = Application.Begin (new ());
+        Application.Top!.Title = "End_And_Shutdown_Should_Not_Dispose_ApplicationTop";
         Assert.Equal (rs.Toplevel, Application.Top);
         Application.End (rs);
 
 #if DEBUG_IDISPOSABLE
         Assert.True (rs.WasDisposed);
-        Assert.False (Application.Top.WasDisposed); // Is true because the rs.Toplevel is the same as Application.Top
+        Assert.False (Application.Top!.WasDisposed); // Is true because the rs.Toplevel is the same as Application.Top
 #endif
 
         Assert.Null (rs.Toplevel);
@@ -337,6 +340,9 @@ public class ApplicationTests
             // Navigation
             Assert.Null (Application.Navigation);
 
+            // Popover
+            Assert.Null (Application.Popover);
+
             // Events - Can't check
             //Assert.Null (Application.NotifyNewRunState);
             //Assert.Null (Application.NotifyNewRunState);
@@ -582,7 +588,7 @@ public class ApplicationTests
         Assert.Equal (Application.Top, rs.Toplevel);
         Assert.Null (Application.MouseGrabView); // public
         Assert.Null (Application.WantContinuousButtonPressedView); // public
-        Application.Top.Dispose ();
+        Application.Top!.Dispose ();
     }
 
     // Invoke Tests
@@ -683,7 +689,7 @@ public class ApplicationTests
         Application.Run<Window> ();
         Assert.True (Application.Top is Window);
 
-        Application.Top.Dispose ();
+        Application.Top!.Dispose ();
         Shutdown ();
 
         Assert.Null (Application.Top);
@@ -704,13 +710,13 @@ public class ApplicationTests
         Application.Run<Window> (null, new FakeDriver ());
         Assert.True (Application.Top is Window);
 
-        Application.Top.Dispose ();
+        Application.Top!.Dispose ();
 
         // Run<Toplevel> when already initialized or not with a Driver will not throw (because Dialog is derived from Toplevel)
         Application.Run<Dialog> (null, new FakeDriver ());
         Assert.True (Application.Top is Dialog);
 
-        Application.Top.Dispose ();
+        Application.Top!.Dispose ();
         Shutdown ();
 
         Assert.Null (Application.Top);
@@ -744,7 +750,7 @@ public class ApplicationTests
         initTop.Dispose ();
         Assert.True (initTop.WasDisposed);
 #endif
-        Application.Top.Dispose ();
+        Application.Top!.Dispose ();
         Shutdown ();
 
         Assert.Null (Application.Top);
@@ -764,7 +770,7 @@ public class ApplicationTests
         // Init has been called and we're passing no driver to Run<TestTopLevel>. This is ok.
         Application.Run<Toplevel> ();
 
-        Application.Top.Dispose ();
+        Application.Top!.Dispose ();
         Shutdown ();
 
         Assert.Null (Application.Top);
@@ -786,7 +792,7 @@ public class ApplicationTests
         // Init has been called, selecting FakeDriver; we're passing no driver to Run<TestTopLevel>. Should be fine.
         Application.Run<Toplevel> ();
 
-        Application.Top.Dispose ();
+        Application.Top!.Dispose ();
         Shutdown ();
 
         Assert.Null (Application.Top);
@@ -823,7 +829,7 @@ public class ApplicationTests
         Application.Run<Toplevel> ();
         Assert.Equal (typeof (FakeDriver), Application.Driver?.GetType ());
 
-        Application.Top.Dispose ();
+        Application.Top!.Dispose ();
         Shutdown ();
 
         Assert.Null (Application.Top);
@@ -840,7 +846,7 @@ public class ApplicationTests
         // Init has NOT been called and we're passing a valid driver to Run<TestTopLevel>. This is ok.
         Application.Run<Toplevel> (null, new FakeDriver ());
 
-        Application.Top.Dispose ();
+        Application.Top!.Dispose ();
         Shutdown ();
 
         Assert.Null (Application.Top);
@@ -870,6 +876,31 @@ public class ApplicationTests
         Assert.Null (Application.Driver);
     }
 
+    [Fact]
+    public void Run_Sets_Running_True ()
+    {
+        // Setup Mock driver
+        Init ();
+
+        var top = new Toplevel ();
+        RunState rs = Application.Begin (top);
+        Assert.NotNull (rs);
+
+        Application.Iteration += (s, a) =>
+                                 {
+                                     Assert.True (top.Running);
+                                     top.Running = false;
+                                 };
+
+        Application.Run (top);
+
+        top.Dispose ();
+        Application.Shutdown ();
+        Assert.Null (Application.Top);
+        Assert.Null (Application.MainLoop);
+        Assert.Null (Application.Driver);
+    }
+
     [Fact]
     [TestRespondersDisposed]
     public void Run_RunningFalse_Stops ()
@@ -976,10 +1007,11 @@ public class ApplicationTests
         //                                                     w)); // Invalid - w has been disposed. Run it in debug mode will throw, otherwise the user may want to run it again
         //Assert.NotNull (exception);
 
-        exception = Record.Exception (() => Assert.Equal (string.Empty, w.Title)); // Invalid - w has been disposed and cannot be accessed
-        Assert.NotNull (exception);
-        exception = Record.Exception (() => w.Title = "NewTitle"); // Invalid - w has been disposed and cannot be accessed
-        Assert.NotNull (exception);
+        // TODO: Re-enable this when we are done debug logging of ctx.Source.Title in RaiseSelecting
+        //exception = Record.Exception (() => Assert.Equal (string.Empty, w.Title)); // Invalid - w has been disposed and cannot be accessed
+        //Assert.NotNull (exception);
+        //exception = Record.Exception (() => w.Title = "NewTitle"); // Invalid - w has been disposed and cannot be accessed
+        //Assert.NotNull (exception);
 #endif
         Application.Shutdown ();
         Assert.NotNull (w);
@@ -1034,14 +1066,14 @@ public class ApplicationTests
                                  };
         Application.Run<Toplevel> (null, driver);
 #if DEBUG_IDISPOSABLE
-        Assert.False (Application.Top.WasDisposed);
+        Assert.False (Application.Top!.WasDisposed);
         Exception exception = Record.Exception (Application.Shutdown);
         Assert.NotNull (exception);
-        Assert.False (Application.Top.WasDisposed);
+        Assert.False (Application.Top!.WasDisposed);
 
         // It's up to caller to dispose it
-        Application.Top.Dispose ();
-        Assert.True (Application.Top.WasDisposed);
+        Application.Top!.Dispose ();
+        Assert.True (Application.Top!.WasDisposed);
 #endif
         Assert.NotNull (Application.Top);
 
@@ -1074,14 +1106,14 @@ public class ApplicationTests
                                  };
         Application.Run (new Toplevel ());
 #if DEBUG_IDISPOSABLE
-        Assert.False (Application.Top.WasDisposed);
+        Assert.False (Application.Top!.WasDisposed);
         Exception exception = Record.Exception (Application.Shutdown);
         Assert.NotNull (exception);
-        Assert.False (Application.Top.WasDisposed);
+        Assert.False (Application.Top!.WasDisposed);
 
         // It's up to caller to dispose it
-        Application.Top.Dispose ();
-        Assert.True (Application.Top.WasDisposed);
+        Application.Top!.Dispose ();
+        Assert.True (Application.Top!.WasDisposed);
 #endif
         Assert.NotNull (Application.Top);
 

Tests/UnitTests/Application/KeyboardTests.cs

@@ -119,99 +119,6 @@ public class KeyboardTests
         top.Dispose ();
     }
 
-    [Fact]
-    public void KeyUp_Event ()
-    {
-        Application.Init (new FakeDriver ());
-
-        // Setup some fake keypresses (This)
-        var input = "Tests";
-
-        Key originalQuitKey = Application.QuitKey;
-        Application.QuitKey = Key.Q.WithCtrl;
-
-        // Put a control-q in at the end
-        FakeConsole.MockKeyPresses.Push (new ('Q', ConsoleKey.Q, false, false, true));
-
-        foreach (char c in input.Reverse ())
-        {
-            if (char.IsLetter (c))
-            {
-                FakeConsole.MockKeyPresses.Push (
-                                                 new (
-                                                      c,
-                                                      (ConsoleKey)char.ToUpper (c),
-                                                      char.IsUpper (c),
-                                                      false,
-                                                      false
-                                                     )
-                                                );
-            }
-            else
-            {
-                FakeConsole.MockKeyPresses.Push (
-                                                 new (
-                                                      c,
-                                                      (ConsoleKey)c,
-                                                      false,
-                                                      false,
-                                                      false
-                                                     )
-                                                );
-            }
-        }
-
-        int stackSize = FakeConsole.MockKeyPresses.Count;
-
-        var iterations = 0;
-
-        Application.Iteration += (s, a) =>
-                                 {
-                                     iterations++;
-
-                                     // Stop if we run out of control...
-                                     if (iterations > 10)
-                                     {
-                                         Application.RequestStop ();
-                                     }
-                                 };
-
-        var keyUps = 0;
-        var output = string.Empty;
-        var top = new Toplevel ();
-
-        top.KeyUp += (sender, args) =>
-                     {
-                         if (args.KeyCode != (KeyCode.CtrlMask | KeyCode.Q))
-                         {
-                             output += args.AsRune;
-                         }
-
-                         keyUps++;
-                     };
-
-        Application.Run (top);
-        Application.QuitKey = originalQuitKey;
-
-        // Input string should match output
-        Assert.Equal (input, output);
-
-        // # of key up events should match stack size
-        //Assert.Equal (stackSize, keyUps);
-        // We can't use numbers variables on the left side of an Assert.Equal/NotEqual,
-        // it must be literal (Linux only).
-        Assert.Equal (6, keyUps);
-
-        // # of key up events should match # of iterations
-        Assert.Equal (stackSize, iterations);
-
-        top.Dispose ();
-        Application.Shutdown ();
-        Assert.Null (Application.Top);
-        Assert.Null (Application.MainLoop);
-        Assert.Null (Application.Driver);
-    }
-
     [Fact]
     public void NextTabGroupKey_Moves_Focus_To_TabStop_In_Next_TabGroup ()
     {

Tests/UnitTests/Application/RunStateTests.cs

@@ -8,7 +8,7 @@ public class RunStateTests
     public RunStateTests ()
     {
 #if DEBUG_IDISPOSABLE
-        View.DebugIDisposable = true;
+        View.EnableDebugIDisposableAsserts = true;
 
         View.Instances.Clear ();
         RunState.Instances.Clear ();

Tests/UnitTests/AutoInitShutdownAttribute.cs

@@ -120,7 +120,7 @@ public class AutoInitShutdownAttribute : BeforeAfterTestAttribute
         if (AutoInit)
         {
 #if DEBUG_IDISPOSABLE
-            View.DebugIDisposable = true;
+            View.EnableDebugIDisposableAsserts = true;
 
             // Clear out any lingering Responder instances from previous tests
             if (View.Instances.Count == 0)

Tests/UnitTests/Configuration/SettingsScopeTests.cs

@@ -95,7 +95,7 @@ public class SettingsScopeTests
         Locations = ConfigLocations.Default;
         Reset ();
 
-        Assert.Equal (5, ((Dictionary<string, ThemeScope>)Settings ["Themes"].PropertyValue).Count);
+        Assert.Equal (6, ((Dictionary<string, ThemeScope>)Settings ["Themes"].PropertyValue).Count);
 
         GetHardCodedDefaults ();
         Assert.NotEmpty (Themes);

Tests/UnitTests/ConsoleDrivers/V2/ApplicationV2Tests.cs

@@ -1,12 +1,13 @@
 #nullable enable
 using System.Collections.Concurrent;
+using System.Runtime.CompilerServices;
 using Microsoft.Extensions.Logging;
 using Moq;
 
 namespace UnitTests.ConsoleDrivers.V2;
 public class ApplicationV2Tests
 {
-    
+
     private ApplicationV2 NewApplicationV2 ()
     {
         var netInput = new Mock<INetInput> ();
@@ -15,20 +16,20 @@ public class ApplicationV2Tests
         SetupRunInputMockMethodToBlock (winInput);
 
         return new (
-                    ()=>netInput.Object,
+                    () => netInput.Object,
                     Mock.Of<IConsoleOutput>,
                     () => winInput.Object,
                     Mock.Of<IConsoleOutput>);
     }
 
     [Fact]
-    public void TestInit_CreatesKeybindings ()
+    public void Init_CreatesKeybindings ()
     {
-        var v2 = NewApplicationV2();
+        var v2 = NewApplicationV2 ();
 
-        Application.KeyBindings.Clear();
+        Application.KeyBindings.Clear ();
 
-        Assert.Empty(Application.KeyBindings.GetBindings ());
+        Assert.Empty (Application.KeyBindings.GetBindings ());
 
         v2.Init ();
 
@@ -38,16 +39,16 @@ public class ApplicationV2Tests
     }
 
     [Fact]
-    public void TestInit_DriverIsFacade ()
+    public void Init_DriverIsFacade ()
     {
-        var v2 = NewApplicationV2();
+        var v2 = NewApplicationV2 ();
 
         Assert.Null (Application.Driver);
         v2.Init ();
         Assert.NotNull (Application.Driver);
 
         var type = Application.Driver.GetType ();
-        Assert.True(type.IsGenericType); 
+        Assert.True (type.IsGenericType);
         Assert.True (type.GetGenericTypeDefinition () == typeof (ConsoleDriverFacade<>));
         v2.Shutdown ();
 
@@ -55,29 +56,30 @@ public class ApplicationV2Tests
     }
 
     [Fact]
-    public void TestInit_ExplicitlyRequestWin ()
+    public void Init_ExplicitlyRequestWin ()
     {
+        Assert.Null (Application.Driver);
         var netInput = new Mock<INetInput> (MockBehavior.Strict);
         var netOutput = new Mock<IConsoleOutput> (MockBehavior.Strict);
         var winInput = new Mock<IWindowsInput> (MockBehavior.Strict);
         var winOutput = new Mock<IConsoleOutput> (MockBehavior.Strict);
 
         winInput.Setup (i => i.Initialize (It.IsAny<ConcurrentQueue<WindowsConsole.InputRecord>> ()))
-                .Verifiable(Times.Once);
+                .Verifiable (Times.Once);
         SetupRunInputMockMethodToBlock (winInput);
-        winInput.Setup (i=>i.Dispose ())
-                .Verifiable(Times.Once);
+        winInput.Setup (i => i.Dispose ())
+                .Verifiable (Times.Once);
         winOutput.Setup (i => i.Dispose ())
                  .Verifiable (Times.Once);
 
         var v2 = new ApplicationV2 (
-                                    ()=> netInput.Object,
+                                    () => netInput.Object,
                                     () => netOutput.Object,
                                     () => winInput.Object,
                                     () => winOutput.Object);
 
         Assert.Null (Application.Driver);
-        v2.Init (null,"v2win");
+        v2.Init (null, "v2win");
         Assert.NotNull (Application.Driver);
 
         var type = Application.Driver.GetType ();
@@ -87,11 +89,11 @@ public class ApplicationV2Tests
 
         Assert.Null (Application.Driver);
 
-        winInput.VerifyAll();
+        winInput.VerifyAll ();
     }
 
     [Fact]
-    public void TestInit_ExplicitlyRequestNet ()
+    public void Init_ExplicitlyRequestNet ()
     {
         var netInput = new Mock<INetInput> (MockBehavior.Strict);
         var netOutput = new Mock<IConsoleOutput> (MockBehavior.Strict);
@@ -155,20 +157,22 @@ public class ApplicationV2Tests
     }
 
     [Fact]
-    public void Test_NoInitThrowOnRun ()
+    public void NoInitThrowOnRun ()
     {
-        var app = NewApplicationV2();
+        Assert.Null (Application.Driver);
+        var app = NewApplicationV2 ();
 
         var ex = Assert.Throws<NotInitializedException> (() => app.Run (new Window ()));
         Assert.Equal ("Run cannot be accessed before Initialization", ex.Message);
+        app.Shutdown();
     }
 
     [Fact]
-    public void Test_InitRunShutdown ()
+    public void InitRunShutdown_Top_Set_To_Null_After_Shutdown ()
     {
         var orig = ApplicationImpl.Instance;
 
-        var v2 = NewApplicationV2();
+        var v2 = NewApplicationV2 ();
         ApplicationImpl.ChangeInstance (v2);
 
         v2.Init ();
@@ -191,17 +195,173 @@ public class ApplicationV2Tests
 
         v2.Run (new Window ());
 
-        Assert.True(v2.RemoveTimeout (timeoutToken));
+        Assert.True (v2.RemoveTimeout (timeoutToken));
 
+        Assert.NotNull (Application.Top);
+        Application.Top?.Dispose ();
+        v2.Shutdown ();
         Assert.Null (Application.Top);
+
+        ApplicationImpl.ChangeInstance (orig);
+    }
+
+    [Fact]
+    public void InitRunShutdown_Running_Set_To_False ()
+    {
+        var orig = ApplicationImpl.Instance;
+
+        var v2 = NewApplicationV2 ();
+        ApplicationImpl.ChangeInstance (v2);
+
+        v2.Init ();
+
+        Toplevel top = new Window ()
+        {
+            Title = "InitRunShutdown_Running_Set_To_False"
+        };
+        var timeoutToken = v2.AddTimeout (TimeSpan.FromMilliseconds (150),
+                                          () =>
+                                          {
+                                              Assert.True (top!.Running);
+                                              if (Application.Top != null)
+                                              {
+                                                  Application.RequestStop ();
+                                                  return true;
+                                              }
+
+                                              return true;
+                                          }
+                                         );
+
+        Assert.False (top!.Running);
+
+        // Blocks until the timeout call is hit
+        v2.Run (top);
+
+        Assert.True (v2.RemoveTimeout (timeoutToken));
+
+        Assert.False (top!.Running);
+
+        // BUGBUG: Shutdown sets Top to null, not End.
+        //Assert.Null (Application.Top);
+        Application.Top?.Dispose ();
         v2.Shutdown ();
 
         ApplicationImpl.ChangeInstance (orig);
     }
 
+    [Fact]
+    public void InitRunShutdown_End_Is_Called ()
+    {
+        var orig = ApplicationImpl.Instance;
+
+        var v2 = NewApplicationV2 ();
+        ApplicationImpl.ChangeInstance (v2);
+
+        Assert.Null (Application.Top);
+        Assert.Null (Application.Driver);
+
+        v2.Init ();
+
+        Toplevel top = new Window ();
+
+        // BUGBUG: Both Closed and Unloaded are called from End; what's the difference?
+        int closedCount = 0;
+        top.Closed
+            += (_, a) =>
+               {
+                   closedCount++;
+               };
+
+        int unloadedCount = 0;
+        top.Unloaded
+            += (_, a) =>
+               {
+                   unloadedCount++;
+               };
+
+        var timeoutToken = v2.AddTimeout (TimeSpan.FromMilliseconds (150),
+                                          () =>
+                                          {
+                                              Assert.True (top!.Running);
+                                              if (Application.Top != null)
+                                              {
+                                                  Application.RequestStop ();
+                                                  return true;
+                                              }
+
+                                              return true;
+                                          }
+                                         );
+
+        Assert.Equal (0, closedCount);
+        Assert.Equal (0, unloadedCount);
+
+        // Blocks until the timeout call is hit
+        v2.Run (top);
+
+        Assert.Equal (1, closedCount);
+        Assert.Equal (1, unloadedCount);
+
+        Assert.True (v2.RemoveTimeout (timeoutToken));
+
+        Application.Top?.Dispose ();
+        v2.Shutdown ();
+        Assert.Equal (1, closedCount);
+        Assert.Equal (1, unloadedCount);
+
+        ApplicationImpl.ChangeInstance (orig);
+    }
+
+
+    [Fact]
+    public void InitRunShutdown_QuitKey_Quits ()
+    {
+        var orig = ApplicationImpl.Instance;
+
+        var v2 = NewApplicationV2 ();
+        ApplicationImpl.ChangeInstance (v2);
+
+        v2.Init ();
+
+        Toplevel top = new Window ()
+        {
+            Title = "InitRunShutdown_QuitKey_Quits"
+        };
+        var timeoutToken = v2.AddTimeout (TimeSpan.FromMilliseconds (150),
+                                          () =>
+                                          {
+                                              Assert.True (top!.Running);
+                                              if (Application.Top != null)
+                                              {
+                                                  Application.RaiseKeyDownEvent (Application.QuitKey);
+                                                  return true;
+                                              }
+
+                                              return true;
+                                          }
+                                         );
+
+        Assert.False (top!.Running);
+
+        // Blocks until the timeout call is hit
+        v2.Run (top);
+
+        Assert.True (v2.RemoveTimeout (timeoutToken));
+
+        Assert.False (top!.Running);
+
+        Assert.NotNull (Application.Top);
+        top.Dispose ();
+        v2.Shutdown ();
+        Assert.Null (Application.Top);
+
+        ApplicationImpl.ChangeInstance (orig);
+    }
+
 
     [Fact]
-    public void Test_InitRunShutdown_Generic_IdleForExit ()
+    public void InitRunShutdown_Generic_IdleForExit ()
     {
         var orig = ApplicationImpl.Instance;
 
@@ -217,14 +377,16 @@ public class ApplicationV2Tests
 
         v2.Run<Window> ();
 
-        Assert.Null (Application.Top);
+        Assert.NotNull (Application.Top);
+        Application.Top?.Dispose ();
         v2.Shutdown ();
+        Assert.Null (Application.Top);
 
         ApplicationImpl.ChangeInstance (orig);
     }
 
     [Fact]
-    public void Test_V2_ClosingRaised ()
+    public void Shutdown_Closing_Closed_Raised ()
     {
         var orig = ApplicationImpl.Instance;
 
@@ -233,19 +395,19 @@ public class ApplicationV2Tests
 
         v2.Init ();
 
-        int closing=0;
+        int closing = 0;
         int closed = 0;
-        var t=new Toplevel ();
+        var t = new Toplevel ();
         t.Closing
             += (_, a) =>
                {
                    // Cancel the first time
-                   if (closing==0)
+                   if (closing == 0)
                    {
                        a.Cancel = true;
                    }
                    closing++;
-                   Assert.Same(t,a.RequestingTop);
+                   Assert.Same (t, a.RequestingTop);
                };
 
         t.Closed
@@ -261,14 +423,15 @@ public class ApplicationV2Tests
 
         v2.Run (t);
 
-        Assert.Null (Application.Top);
+        Application.Top?.Dispose ();
         v2.Shutdown ();
 
         ApplicationImpl.ChangeInstance (orig);
 
-        Assert.Equal (2,closing);
+        Assert.Equal (2, closing);
         Assert.Equal (1, closed);
     }
+
     private bool IdleExit ()
     {
         if (Application.Top != null)
@@ -281,28 +444,28 @@ public class ApplicationV2Tests
     }
 
     [Fact]
-    public void TestRepeatedShutdownCalls_DoNotDuplicateDisposeOutput ()
+    public void Shutdown_Called_Repeatedly_DoNotDuplicateDisposeOutput ()
     {
         var netInput = new Mock<INetInput> ();
         SetupRunInputMockMethodToBlock (netInput);
         Mock<IConsoleOutput>? outputMock = null;
 
 
-        var v2 = new ApplicationV2(
+        var v2 = new ApplicationV2 (
                                    () => netInput.Object,
-                                   ()=> (outputMock = new Mock<IConsoleOutput>()).Object,
+                                   () => (outputMock = new Mock<IConsoleOutput> ()).Object,
                                    Mock.Of<IWindowsInput>,
                                    Mock.Of<IConsoleOutput>);
 
-        v2.Init (null,"v2net");
+        v2.Init (null, "v2net");
 
 
         v2.Shutdown ();
         v2.Shutdown ();
-        outputMock!.Verify(o=>o.Dispose (),Times.Once);
+        outputMock!.Verify (o => o.Dispose (), Times.Once);
     }
     [Fact]
-    public void TestRepeatedInitCalls_WarnsAndIgnores ()
+    public void Init_Called_Repeatedly_WarnsAndIgnores ()
     {
         var v2 = NewApplicationV2 ();
 
@@ -318,13 +481,13 @@ public class ApplicationV2Tests
         v2.Init ();
         v2.Init ();
 
-        mockLogger.Verify(
-                          l=>l.Log (LogLevel.Error,
+        mockLogger.Verify (
+                          l => l.Log (LogLevel.Error,
                                     It.IsAny<EventId> (),
                                     It.Is<It.IsAnyType> ((v, t) => v.ToString () == "Init called multiple times without shutdown, ignoring."),
                                     It.IsAny<Exception> (),
                                     It.IsAny<Func<It.IsAnyType, Exception, string>> ()!)
-                          ,Times.Exactly (2));
+                          , Times.Exactly (2));
 
         v2.Shutdown ();
 
@@ -332,8 +495,10 @@ public class ApplicationV2Tests
         Logging.Logger = beforeLogger;
     }
 
+
+    // QUESTION: What does this test really test? It's poorly named.
     [Fact]
-    public void Test_Open_CallsContinueWithOnUIThread ()
+    public void Open_CallsContinueWithOnUIThread ()
     {
         var orig = ApplicationImpl.Instance;
 
@@ -346,7 +511,7 @@ public class ApplicationV2Tests
         bool result = false;
 
         b.Accepting +=
-            (_,_) =>
+            (_, _) =>
             {
 
                 Task.Run (() =>
@@ -366,7 +531,7 @@ public class ApplicationV2Tests
             };
 
         v2.AddTimeout (TimeSpan.FromMilliseconds (150),
-                                          ()=>
+                                          () =>
                                           {
                                               // Run asynchronous logic inside Task.Run
                                               if (Application.Top != null)
@@ -382,14 +547,19 @@ public class ApplicationV2Tests
 
         Assert.Null (Application.Top);
 
-        var w = new Window ();
+        var w = new Window ()
+        {
+            Title = "Open_CallsContinueWithOnUIThread"
+        };
         w.Add (b);
 
         // Blocks until the timeout call is hit
         v2.Run (w);
 
-        Assert.Null (Application.Top);
+        Assert.NotNull (Application.Top);
+        Application.Top?.Dispose ();
         v2.Shutdown ();
+        Assert.Null (Application.Top);
 
         ApplicationImpl.ChangeInstance (orig);
 

Tests/UnitTests/Dialogs/DialogTests.cs

@@ -10,9 +10,6 @@ public class DialogTests
 
     public DialogTests (ITestOutputHelper output)
     {
-#if DEBUG_IDISPOSABLE
-        View.DebugIDisposable = true;
-#endif
         _output = output;
     }
 

Tests/UnitTests/Dialogs/MessageBoxTests.cs

@@ -462,7 +462,7 @@ public class MessageBoxTests
                                      {
                                          MessageBox.Query (
                                                            "",
-                                                           UICatalog.UICatalogTopLevel.GetAboutBoxMessage (),
+                                                           UICatalog.UICatalogTop.GetAboutBoxMessage (),
                                                            wrapMessage: false,
                                                            buttons: "_Ok"
                                                           );

Tests/UnitTests/TestRespondersDisposedAttribute.cs

@@ -23,8 +23,7 @@ public class TestRespondersDisposedAttribute : BeforeAfterTestAttribute
         base.After (methodUnderTest);
 
 #if DEBUG_IDISPOSABLE
-        View.DebugIDisposable = true;
-
+        Assert.True (View.EnableDebugIDisposableAsserts);
         Assert.Empty (View.Instances);
 #endif
     }
@@ -35,7 +34,7 @@ public class TestRespondersDisposedAttribute : BeforeAfterTestAttribute
 
         base.Before (methodUnderTest);
 #if DEBUG_IDISPOSABLE
-        View.DebugIDisposable = true;
+        View.EnableDebugIDisposableAsserts = true;
         // Clear out any lingering Responder instances from previous tests
         View.Instances.Clear ();
         Assert.Empty (View.Instances);

Tests/UnitTests/TestsAllViews.cs

@@ -63,14 +63,30 @@ public class TestsAllViews
 
         if (type is { IsGenericType: true, IsTypeDefinition: true })
         {
-            List<Type> gTypes = new ();
+            List<Type> typeArguments = new ();
 
-            foreach (Type args in type.GetGenericArguments ())
+            // use <object> or the original type if applicable
+            foreach (Type arg in type.GetGenericArguments ())
             {
-                gTypes.Add (typeof (object));
+                if (arg.IsValueType && Nullable.GetUnderlyingType (arg) == null)
+                {
+                    typeArguments.Add (arg);
+                }
+                else
+                {
+                    typeArguments.Add (typeof (object));
+                }
             }
 
-            type = type.MakeGenericType (gTypes.ToArray ());
+            type = type.MakeGenericType (typeArguments.ToArray ());
+
+            // Ensure the type does not contain any generic parameters
+            if (type.ContainsGenericParameters)
+            {
+                Logging.Warning ($"Cannot create an instance of {type} because it contains generic parameters.");
+                //throw new ArgumentException ($"Cannot create an instance of {type} because it contains generic parameters.");
+                return null;
+            }
 
             Assert.IsType (type, (View)Activator.CreateInstance (type)!);
         }

Tests/UnitTests/Text/TextFormatterTests.cs

@@ -4146,7 +4146,7 @@ Nice       Work")]
     {
         TextFormatter tf = new ()
         {
-            Text = UICatalog.UICatalogTopLevel.GetAboutBoxMessage (),
+            Text = UICatalog.UICatalogTop.GetAboutBoxMessage (),
             Alignment = Alignment.Center,
             VerticalAlignment = Alignment.Start,
             WordWrap = false,

Tests/UnitTests/View/Keyboard/KeyBindingsTests.cs

@@ -1,4 +1,5 @@
-using UnitTests;
+using System.Text;
+using UnitTests;
 using Xunit.Abstractions;
 
 namespace Terminal.Gui.ViewTests;
@@ -151,6 +152,48 @@ public class KeyBindingsTests ()
         Assert.False (view.HotKeyCommand);
         top.Dispose ();
     }
+
+
+    [Fact]
+    public void HotKey_Raises_HotKeyCommand ()
+    {
+        var hotKeyRaised = false;
+        var acceptRaised = false;
+        var selectRaised = false;
+        Application.Top = new Toplevel ();
+        var view = new View
+        {
+            CanFocus = true,
+            HotKeySpecifier = new Rune ('_'),
+            Title = "_Test"
+        };
+        Application.Top.Add (view);
+        view.HandlingHotKey += (s, e) => hotKeyRaised = true;
+        view.Accepting += (s, e) => acceptRaised = true;
+        view.Selecting += (s, e) => selectRaised = true;
+
+        Assert.Equal (KeyCode.T, view.HotKey);
+        Assert.True (Application.RaiseKeyDownEvent (Key.T));
+        Assert.True (hotKeyRaised);
+        Assert.False (acceptRaised);
+        Assert.False (selectRaised);
+
+        hotKeyRaised = false;
+        Assert.True (Application.RaiseKeyDownEvent (Key.T.WithAlt));
+        Assert.True (hotKeyRaised);
+        Assert.False (acceptRaised);
+        Assert.False (selectRaised);
+
+        hotKeyRaised = false;
+        view.HotKey = KeyCode.E;
+        Assert.True (Application.RaiseKeyDownEvent (Key.E.WithAlt));
+        Assert.True (hotKeyRaised);
+        Assert.False (acceptRaised);
+        Assert.False (selectRaised);
+
+        Application.Top.Dispose ();
+        Application.ResetState (true);
+    }
     // tests that test KeyBindingScope.Focus and KeyBindingScope.HotKey (tests for KeyBindingScope.Application are in Application/KeyboardTests.cs)
 
     public class ScopedKeyBindingView : View

Tests/UnitTests/View/Layout/Dim.Tests.cs

@@ -127,30 +127,16 @@ public class DimTests
                        Assert.Equal (49, f2.Frame.Width); // 50-1=49
                        Assert.Equal (5, f2.Frame.Height);
 
-#if DEBUG
-                       Assert.Equal ($"Combine(View(Width,FrameView(f1){f1.Border.Frame})-Absolute(2))", v1.Width.ToString ());
-#else
                        Assert.Equal ($"Combine(View(Width,FrameView(){f1.Border.Frame})-Absolute(2))", v1.Width.ToString ());
-#endif
                        Assert.Equal ("Combine(Fill(Absolute(0))-Absolute(2))", v1.Height.ToString ());
                        Assert.Equal (47, v1.Frame.Width); // 49-2=47
                        Assert.Equal (89, v1.Frame.Height); // 98-5-2-2=89
 
-#if DEBUG
-                       Assert.Equal (
-                                     $"Combine(View(Width,FrameView(f2){f2.Frame})-Absolute(2))",
-                                     v2.Width.ToString ()
-#else
                        Assert.Equal (
                                      $"Combine(View(Width,FrameView(){f2.Frame})-Absolute(2))",
                                      v2.Width.ToString ()
-#endif
                                     );
-#if DEBUG
-                       Assert.Equal ("Combine(Fill(Absolute(0))-Absolute(2))", v2.Height.ToString ());
-#else
                        Assert.Equal ("Combine(Fill(Absolute(0))-Absolute(2))", v2.Height.ToString ());
-#endif
                        Assert.Equal (47, v2.Frame.Width); // 49-2=47
                        Assert.Equal (89, v2.Frame.Height); // 98-5-2-2=89
 
@@ -161,11 +147,7 @@ public class DimTests
                        Assert.Equal ("Absolute(50)", v4.Height.ToString ());
                        Assert.Equal (50, v4.Frame.Width);
                        Assert.Equal (50, v4.Frame.Height);
-#if DEBUG
-                       Assert.Equal ($"Combine(View(Width,Button(v1){v1.Frame})-View(Width,Button(v3){v3.Viewport}))", v5.Width.ToString ());
-#else
                        Assert.Equal ($"Combine(View(Height,Button(){v1.Frame})-View(Height,Button(){v3.Viewport}))", v5.Height.ToString ( ));
-#endif
                        Assert.Equal (38, v5.Frame.Width); // 47-9=38
                        Assert.Equal (80, v5.Frame.Height); // 89-9=80
 
@@ -193,22 +175,14 @@ public class DimTests
                        Assert.Equal (5, f2.Frame.Height);
 
                        v1.Text = "Button1";
-#if DEBUG
-                       Assert.Equal ($"Combine(View(Width,FrameView(f1){f1.Frame})-Absolute(2))", v1.Width.ToString ());
-#else
                        Assert.Equal ($"Combine(View(Width,FrameView(){f1.Frame})-Absolute(2))", v1.Width.ToString ());
-#endif
                        Assert.Equal ("Combine(Fill(Absolute(0))-Absolute(2))", v1.Height.ToString ());
                        Assert.Equal (97, v1.Frame.Width); // 99-2=97
                        Assert.Equal (189, v1.Frame.Height); // 198-2-7=189
 
                        v2.Text = "Button2";
 
-#if DEBUG
-                       Assert.Equal ($"Combine(View(Width,FrameView(f2){f2.Frame})-Absolute(2))", v2.Width.ToString ());
-#else
                        Assert.Equal ($"Combine(View(Width,FrameView(){f2.Frame})-Absolute(2))", v2.Width.ToString ());
-#endif
                        Assert.Equal ("Combine(Fill(Absolute(0))-Absolute(2))", v2.Height.ToString ());
                        Assert.Equal (97, v2.Frame.Width); // 99-2=97
                        Assert.Equal (189, v2.Frame.Height); // 198-2-7=189
@@ -232,13 +206,8 @@ public class DimTests
 
                        v5.Text = "Button5";
 
-#if DEBUG
-                       Assert.Equal ($"Combine(View(Width,Button(v1){v1.Frame})-View(Width,Button(v3){v3.Frame}))", v5.Width.ToString ());
-                       Assert.Equal ($"Combine(View(Height,Button(v1){v1.Frame})-View(Height,Button(v3){v3.Frame}))", v5.Height.ToString ());
-#else
                        Assert.Equal ($"Combine(View(Width,Button(){v1.Frame})-View(Width,Button(){v3.Frame}))", v5.Width.ToString ());
                        Assert.Equal ($"Combine(View(Height,Button(){v1.Frame})-View(Height,Button(){v3.Frame}))", v5.Height.ToString ());
-#endif
 
                        Assert.Equal (78, v5.Frame.Width); // 97-9=78
                        Assert.Equal (170, v5.Frame.Height); // 189-19=170

Tests/UnitTests/View/ViewTests.cs

@@ -10,9 +10,6 @@ public class ViewTests
     public ViewTests (ITestOutputHelper output)
     {
         _output = output;
-#if DEBUG_IDISPOSABLE
-        View.DebugIDisposable = true;
-#endif
     }
 
     // Generic lifetime (IDisposable) tests
@@ -295,11 +292,7 @@ public class ViewTests
         Assert.Null (r.Focused);
         Assert.Null (r.ColorScheme);
         Assert.False (r.IsCurrentTop);
-#if DEBUG
-        Assert.Equal ("Vertical View", r.Id);
-#else
         Assert.Equal (string.Empty, r.Id);
-#endif
         Assert.Empty (r.SubViews);
         Assert.False (r.WantContinuousButtonPressed);
         Assert.False (r.WantMousePositionReports);

Tests/UnitTests/Views/AllViewsTests.cs

@@ -45,6 +45,8 @@ public class AllViewsTests (ITestOutputHelper output) : TestsAllViews
         frame.BeginInit ();
         frame.EndInit ();
         frame.LayoutSubViews ();
+        frame.Dispose ();
+        Application.Shutdown ();
 
         // What's the natural width/height?
         int expectedX = (frame.Frame.Width - view.Frame.Width) / 2;
@@ -59,7 +61,6 @@ public class AllViewsTests (ITestOutputHelper output) : TestsAllViews
                      view.Frame.Top == expectedY,
                      $"{view} did not center vertically. Expected: {expectedY}. Actual: {view.Frame.Top}"
                     );
-        Application.Shutdown ();
     }
 
 }

Tests/UnitTests/Views/CheckBoxTests.cs

@@ -169,6 +169,8 @@ public class CheckBoxTests (ITestOutputHelper output)
 
         checkBox.AllowCheckStateNone = false;
         Assert.Equal (CheckState.UnChecked, checkBox.CheckedState);
+
+        Application.ResetState();
     }
 
     [Fact]

Tests/UnitTests/Views/ColorPickerTests.cs

@@ -4,13 +4,6 @@ namespace Terminal.Gui.ViewsTests;
 
 public class ColorPickerTests
 {
-    public ColorPickerTests ()
-    {
-#if DEBUG_IDISPOSABLE
-        View.DebugIDisposable = true;
-#endif
-    }
-
     [Fact]
     [SetupFakeDriver]
     public void ColorPicker_ChangedEvent_Fires ()
@@ -102,6 +95,7 @@ public class ColorPickerTests
         Assert.Equal ("#800000", hex.Text);
 
         Application.Top?.Dispose ();
+        Application.ResetState();
     }
 
     [Fact]
@@ -136,6 +130,8 @@ public class ColorPickerTests
         Assert.Equal ("#FF0000", hex.Text);
 
         Application.Top?.Dispose ();
+        Application.ResetState ();
+
     }
 
     [Fact]
@@ -170,6 +166,8 @@ public class ColorPickerTests
         Assert.Equal ("#FF0000", hex.Text);
 
         Application.Top?.Dispose ();
+        Application.ResetState ();
+
     }
 
     [Fact]
@@ -223,6 +221,8 @@ public class ColorPickerTests
         Assert.IsAssignableFrom<BBar> (cp.Focused);
 
         Application.Top?.Dispose ();
+        Application.ResetState ();
+
     }
 
     [Fact]
@@ -447,6 +447,8 @@ public class ColorPickerTests
         Assert.Equal ("#000000", hex.Text);
 
         Application.Top?.Dispose ();
+        Application.ResetState (true);
+
     }
 
     [Fact]
@@ -504,6 +506,8 @@ public class ColorPickerTests
         Assert.Equal ("#FF0000", hex.Text);
 
         Application.Top.Dispose ();
+        Application.ResetState (true);
+
     }
 
     [Fact]
@@ -557,6 +561,8 @@ public class ColorPickerTests
         Assert.Equal ("#1E0000", hex.Text);
 
         Application.Top?.Dispose ();
+        Application.ResetState (true);
+
     }
 
     [Theory]
@@ -592,6 +598,8 @@ public class ColorPickerTests
         Assert.Equal (expectedHex, hex.Text);
 
         Application.Top.Dispose ();
+        Application.ResetState (true);
+
     }
 
     [Theory]
@@ -636,6 +644,8 @@ public class ColorPickerTests
         Assert.Equal (expectedHex, hex.Text);
 
         Application.Top?.Dispose ();
+        Application.ResetState (true);
+
     }
 
     [Fact]
@@ -681,6 +691,8 @@ public class ColorPickerTests
         Assert.Equal ("#FF0000", hex.Text);
 
         Application.Top!.Dispose ();
+        Application.ResetState (true);
+
     }
 
     [Fact]
@@ -717,6 +729,8 @@ public class ColorPickerTests
         Assert.Equal ("#800000", hex.Text);
 
         Application.Top?.Dispose ();
+        Application.ResetState (true);
+
     }
 
     [Fact]

Tests/UnitTests/Views/ListViewTests.cs

@@ -1157,4 +1157,34 @@ Item 6",
             }
         }
     }
+
+    [Fact]
+    public void CollectionNavigatorMatcher_KeybindingsOverrideNavigator ()
+    {
+        Application.Top = new ();
+
+        ObservableCollection<string> source = new () { "apricot", "arm", "bat", "batman", "bates hotel", "candle" };
+        ListView lv = new ListView { Source = new ListWrapper<string> (source) };
+
+        Application.Top.Add (lv);
+        lv.SetFocus ();
+
+        lv.KeyBindings.Add (Key.B, Command.Down);
+
+        Assert.Equal (-1, lv.SelectedItem);
+
+        // Keys should be consumed to move down the navigation i.e. to apricot
+        Assert.True (Application.RaiseKeyDownEvent (Key.B));
+        Assert.Equal (0, lv.SelectedItem);
+
+        Assert.True (Application.RaiseKeyDownEvent (Key.B));
+        Assert.Equal (1, lv.SelectedItem);
+
+        // There is no keybinding for Key.C so it hits collection navigator i.e. we jump to candle
+        Assert.True (Application.RaiseKeyDownEvent (Key.C));
+        Assert.Equal (5, lv.SelectedItem);
+
+        Application.Top.Dispose ();
+        Application.ResetState ();
+    }
 }

Tests/UnitTests/Views/MenuBarTests.cs

@@ -7,7 +7,7 @@ public class MenuBarTests ()
 {
     [Fact]
     [AutoInitShutdown]
-    public void DefaultKey_Activates ()
+    public void DefaultKey_Activates_And_Opens ()
     {
         // Arrange
         var menuItem = new MenuItemv2 { Id = "menuItem", Title = "_Item" };
@@ -23,11 +23,11 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
 
         // Act
         Application.RaiseKeyDownEvent (MenuBarv2.DefaultKey);
-        Assert.True (menuBar.IsActive ());
+        Assert.True (menuBar.Active);
         Assert.True (menuBar.IsOpen ());
         Assert.True (menuBar.HasFocus);
         Assert.True (menuBar.CanFocus);
@@ -56,7 +56,7 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
 
         // Act
         Application.RaiseKeyDownEvent (MenuBarv2.DefaultKey);
@@ -64,7 +64,7 @@ public class MenuBarTests ()
         Assert.True (menuBarItem.PopoverMenu.Visible);
 
         Application.RaiseKeyDownEvent (MenuBarv2.DefaultKey);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
         Assert.False (menuBar.IsOpen ());
         Assert.False (menuBar.HasFocus);
         Assert.False (menuBar.CanFocus);
@@ -77,12 +77,12 @@ public class MenuBarTests ()
 
     [Fact]
     [AutoInitShutdown]
-    public void QuitKey_DeActivates ()
+    public void QuitKey_Deactivates ()
     {
         // Arrange
-        var menuItem = new MenuItemv2 { Id = "menuItem", Title = "_Item" };
+        var menuItem = new MenuItemv2 { Id = "menuItem", Title = "Menu_Item" };
         var menu = new Menuv2 ([menuItem]) { Id = "menu" };
-        var menuBarItem = new MenuBarItemv2 { Id = "menuBarItem", Title = "_New" };
+        var menuBarItem = new MenuBarItemv2 { Id = "menuBarItem", Title = "_MenuBarItem" };
         var menuBarItemPopover = new PopoverMenu ();
         menuBarItem.PopoverMenu = menuBarItemPopover;
         menuBarItemPopover.Root = menu;
@@ -93,16 +93,16 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
 
-        // Act
         Application.RaiseKeyDownEvent (MenuBarv2.DefaultKey);
-        Assert.True (menuBar.IsActive ());
+        Assert.True (menuBar.Active);
         Assert.True (menuBar.IsOpen ());
         Assert.True (menuBarItem.PopoverMenu.Visible);
 
+        // Act
+
         Application.RaiseKeyDownEvent (Application.QuitKey);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
         Assert.False (menuBar.IsOpen ());
         Assert.False (menuBar.HasFocus);
         Assert.False (menuBar.CanFocus);
@@ -115,7 +115,7 @@ public class MenuBarTests ()
 
     [Fact]
     [AutoInitShutdown]
-    public void MenuBarItem_HotKey_Activates ()
+    public void MenuBarItem_HotKey_Activates_And_Opens ()
     {
         // Arrange
         var menuItem = new MenuItemv2 { Id = "menuItem", Title = "_Item" };
@@ -131,10 +131,11 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
 
         // Act
         Application.RaiseKeyDownEvent (Key.N.WithAlt);
+        Assert.True (menuBar.Active);
         Assert.True (menuBar.IsOpen ());
         Assert.True (menuBar.HasFocus);
         Assert.True (menuBarItem.PopoverMenu.Visible);
@@ -162,16 +163,16 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
 
         // Act
         Application.RaiseKeyDownEvent (Key.N.WithAlt);
-        Assert.True (menuBar.IsActive ());
+        Assert.True (menuBar.Active);
         Assert.True (menuBar.IsOpen ());
         Assert.True (menuBarItem.PopoverMenu.Visible);
 
         Application.RaiseKeyDownEvent (Key.N.WithAlt);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
         Assert.False (menuBar.IsOpen ());
         Assert.False (menuBar.HasFocus);
         Assert.False (menuBar.CanFocus);
@@ -182,16 +183,15 @@ public class MenuBarTests ()
         top.Dispose ();
     }
 
-
     [Fact]
     [AutoInitShutdown]
-    public void MenuItem_HotKey_Deactivates ()
+    public void MenuItems_HotKey_RaisesAction ()
     {
         // Arrange
         int action = 0;
-        var menuItem = new MenuItemv2 { Id = "menuItem", Title = "_Item", Action = () => action++ };
+        var menuItem = new MenuItemv2 { Id = "menuItem", Title = "Menu_Item", Action = () => action++ };
         var menu = new Menuv2 ([menuItem]) { Id = "menu" };
-        var menuBarItem = new MenuBarItemv2 { Id = "menuBarItem", Title = "_New" };
+        var menuBarItem = new MenuBarItemv2 { Id = "menuBarItem", Title = "_MenuBarItem" };
         var menuBarItemPopover = new PopoverMenu ();
         menuBarItem.PopoverMenu = menuBarItemPopover;
         menuBarItemPopover.Root = menu;
@@ -202,16 +202,48 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
 
-        // Act
-        Application.RaiseKeyDownEvent (Key.N.WithAlt);
-        Assert.True (menuBar.IsActive ());
+        Application.RaiseKeyDownEvent (Key.M.WithAlt);
+        Assert.True (menuBar.Active);
+        Assert.True (menuBar.CanFocus);
         Assert.True (menuBarItem.PopoverMenu.Visible);
 
+        // Act
         Application.RaiseKeyDownEvent (Key.I);
         Assert.Equal (1, action);
-        Assert.False (menuBar.IsActive ());
+
+        Application.End (rs);
+        top.Dispose ();
+    }
+
+    [Fact]
+    [AutoInitShutdown]
+    public void MenuItems_HotKey_Deactivates ()
+    {
+        // Arrange
+        var menuItem = new MenuItemv2 { Id = "menuItem", Title = "Menu_Item" };
+        var menu = new Menuv2 ([menuItem]) { Id = "menu" };
+        var menuBarItem = new MenuBarItemv2 { Id = "menuBarItem", Title = "_MenuBarItem" };
+        var menuBarItemPopover = new PopoverMenu ();
+        menuBarItem.PopoverMenu = menuBarItemPopover;
+        menuBarItemPopover.Root = menu;
+        var menuBar = new MenuBarv2 () { Id = "menuBar" };
+        menuBar.Add (menuBarItem);
+        Assert.Single (menuBar.SubViews);
+        Assert.Single (menuBarItem.SubViews);
+        var top = new Toplevel ();
+        top.Add (menuBar);
+        RunState rs = Application.Begin (top);
+        Assert.False (menuBar.Active);
+
+        Application.RaiseKeyDownEvent (Key.M.WithAlt);
+        Assert.True (menuBar.Active);
+        Assert.True (menuBarItem.PopoverMenu.Visible);
+
+        // Act
+        Application.RaiseKeyDownEvent (Key.I);
+        Assert.False (menuBar.Active);
         Assert.False (menuBar.IsOpen ());
         Assert.False (menuBar.HasFocus);
         Assert.False (menuBar.CanFocus);
@@ -224,7 +256,7 @@ public class MenuBarTests ()
 
     [Fact]
     [AutoInitShutdown]
-    public void HotKey_Activates_Only_Once ()
+    public void HotKey_Makes_PopoverMenu_Visible_Only_Once ()
     {
         // Arrange
         var menuItem = new MenuItemv2 { Id = "menuItem", Title = "_Item" };
@@ -240,7 +272,7 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
 
         int visibleChangeCount = 0;
         menuBarItemPopover.VisibleChanged += (sender, args) =>
@@ -261,7 +293,7 @@ public class MenuBarTests ()
 
     [Fact]
     [AutoInitShutdown]
-    public void WhenActive_Other_MenuBarItem_HotKey_Activates ()
+    public void WhenOpen_Other_MenuBarItem_HotKey_Activates_And_Opens ()
     {
         // Arrange
         var menuItem = new MenuItemv2 { Id = "menuItem", Title = "_Item" };
@@ -285,17 +317,17 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
-
+        Assert.False (menuBar.Active);
+        Assert.False (menuBar.IsOpen ());
 
         // Act
         Application.RaiseKeyDownEvent (Key.N.WithAlt);
-        Assert.True (menuBar.IsActive ());
+        Assert.True (menuBar.Active);
         Assert.True (menuBar.IsOpen ());
         Assert.True (menuBarItem.PopoverMenu.Visible);
 
         Application.RaiseKeyDownEvent (Key.E.WithAlt);
-        Assert.True (menuBar.IsActive ());
+        Assert.True (menuBar.Active);
         Assert.True (menuBar.IsOpen ());
         Assert.True (menuBarItem2.PopoverMenu.Visible);
         Assert.False (menuBarItem.PopoverMenu.Visible);
@@ -306,7 +338,7 @@ public class MenuBarTests ()
 
     [Fact]
     [AutoInitShutdown]
-    public void Mouse_Enter_Sets_Can_Focus_But_Does_Not_Activate ()
+    public void Mouse_Enter_Activates_But_Does_Not_Open ()
     {
         // Arrange
         var menuItem = new MenuItemv2 { Id = "menuItem", Title = "_Item" };
@@ -322,14 +354,14 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
 
         // Act
         Application.RaiseMouseEvent (new ()
         {
             Flags = MouseFlags.ReportMousePosition
         });
-        Assert.False (menuBar.IsActive ());
+        Assert.True (menuBar.Active);
         Assert.False (menuBar.IsOpen ());
         Assert.True (menuBar.HasFocus);
         Assert.True (menuBar.CanFocus);
@@ -342,7 +374,7 @@ public class MenuBarTests ()
 
     [Fact]
     [AutoInitShutdown]
-    public void Mouse_Click_Activates ()
+    public void Mouse_Click_Activates_And_Opens ()
     {
         // Arrange
         var menuItem = new MenuItemv2 { Id = "menuItem", Title = "_Item" };
@@ -358,14 +390,14 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
 
         // Act
         Application.RaiseMouseEvent (new ()
         {
             Flags = MouseFlags.Button1Clicked
         });
-        Assert.True (menuBar.IsActive ());
+        Assert.True (menuBar.Active);
         Assert.True (menuBar.IsOpen ());
         Assert.True (menuBar.HasFocus);
         Assert.True (menuBar.CanFocus);
@@ -399,7 +431,7 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
 
         Application.RaiseMouseEvent (new ()
         {
@@ -416,7 +448,7 @@ public class MenuBarTests ()
         {
             Flags = MouseFlags.Button1Clicked
         });
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
         Assert.False (menuBar.IsOpen ());
         Assert.False (menuBar.HasFocus);
         Assert.False (menuBar.CanFocus);
@@ -447,21 +479,21 @@ public class MenuBarTests ()
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
 
-        Assert.False (menuBar.IsActive());
+        Assert.False (menuBar.Active);
         Application.RaiseKeyDownEvent (Key.N.WithAlt);
         Assert.Equal (0, action);
 
         Assert.Equal(Key.I, menuItem.HotKey);
         Application.RaiseKeyDownEvent (Key.I);
         Assert.Equal (1, action);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
 
         menuItem.Title = "_Foo";
         Application.RaiseKeyDownEvent (Key.N.WithAlt);
-        Assert.True (menuBar.IsActive ());
+        Assert.True (menuBar.Active);
         Application.RaiseKeyDownEvent (Key.I);
         Assert.Equal (1, action);
-        Assert.True (menuBar.IsActive ());
+        Assert.True (menuBar.Active);
 
         Application.RaiseKeyDownEvent (Key.F);
         Assert.Equal (2, action);
@@ -488,12 +520,12 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
 
         // Act
         menuBar.Enabled = false;
         Application.RaiseKeyDownEvent (Key.N.WithAlt);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
         Assert.False (menuBar.IsOpen ());
         Assert.False (menuBarItem.PopoverMenu.Visible);
 
@@ -503,7 +535,7 @@ public class MenuBarTests ()
 
     [Fact]
     [AutoInitShutdown (configLocation: ConfigLocations.Default)]
-    public void Disabled_MenuBarItem_Is_Not_Activated ()
+    public void MenuBarItem_Disabled_MenuBarItem_HotKey_No_Activate_Or_Open ()
     {
         // Arrange
         var menuItem = new MenuItemv2 { Id = "menuItem", Title = "_Item" };
@@ -519,12 +551,12 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
 
         // Act
         menuBarItem.Enabled = false;
         Application.RaiseKeyDownEvent (Key.N.WithAlt);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
         Assert.False (menuBar.IsOpen ());
         Assert.False (menuBarItem.PopoverMenu.Visible);
 
@@ -535,7 +567,7 @@ public class MenuBarTests ()
 
     [Fact]
     [AutoInitShutdown (configLocation: ConfigLocations.Default)]
-    public void Disabled_MenuBarItem_Popover_Is_Activated ()
+    public void MenuBarItem_Disabled_Popover_Is_Activated ()
     {
         // Arrange
         var menuItem = new MenuItemv2 { Id = "menuItem", Title = "_Item" };
@@ -551,12 +583,12 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
 
         // Act
         menuBarItem.PopoverMenu.Enabled = false;
         Application.RaiseKeyDownEvent (Key.N.WithAlt);
-        Assert.True (menuBar.IsActive ());
+        Assert.True (menuBar.Active);
         Assert.True (menuBar.IsOpen ());
         Assert.True (menuBarItem.PopoverMenu.Visible);
 
@@ -589,7 +621,7 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
 
         Application.RaiseKeyDownEvent (Key.N.WithAlt);
         Assert.True (menuBar.IsOpen ());
@@ -609,7 +641,7 @@ public class MenuBarTests ()
 
         // use new key
         Application.RaiseKeyDownEvent (Key.E.WithAlt);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
         Assert.False (menuBar.IsOpen ());
         Assert.False (menuBar.HasFocus);
         Assert.False (menuBar.CanFocus);
@@ -638,12 +670,12 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
 
         // Act
         menuBar.Visible = false;
         Application.RaiseKeyDownEvent (Key.N.WithAlt);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
         Assert.False (menuBar.IsOpen ());
         Assert.False (menuBar.HasFocus);
         Assert.False (menuBar.CanFocus);
@@ -679,7 +711,7 @@ public class MenuBarTests ()
         var top = new Toplevel ();
         top.Add (menuBar);
         RunState rs = Application.Begin (top);
-        Assert.False (menuBar.IsActive ());
+        Assert.False (menuBar.Active);
 
         // Act
         menuBar.Visible = false;

Tests/UnitTests/Views/Menuv1/MenuBarv1Tests.cs

@@ -3,6 +3,7 @@ using Xunit.Abstractions;
 
 namespace Terminal.Gui.ViewsTests;
 
+#pragma warning disable CS0618 // Type or member is obsolete
 public class MenuBarv1Tests (ITestOutputHelper output)
 {
     [Fact]
@@ -3884,3 +3885,4 @@ Edit
         }
     }
 }
+#pragma warning restore CS0618 // Type or member is obsolete

Tests/UnitTests/Views/Menuv1/Menuv1Tests.cs

@@ -4,6 +4,7 @@
 
 namespace Terminal.Gui.ViewsTests;
 
+#pragma warning disable CS0618 // Type or member is obsolete
 public class Menuv1Tests
 {
     private readonly ITestOutputHelper _output;

Tests/UnitTests/Views/RadioGroupTests.cs

@@ -600,8 +600,8 @@ public class RadioGroupTests (ITestOutputHelper output)
     [Fact]
     public void SelectedItemChanged_Event ()
     {
-        int previousSelectedItem = -1;
-        int selectedItem = -1;
+        int? previousSelectedItem = -1;
+        int? selectedItem = -1;
         var rg = new RadioGroup { RadioLabels = ["Test", "New Test"] };
 
         rg.SelectedItemChanged += (s, e) =>

Tests/UnitTests/Views/ShortcutTests.cs

@@ -466,7 +466,7 @@ public class ShortcutTests
 
         shortcut.HasFocus = true;
 
-        Assert.NotNull (shortcut.ColorScheme);
+        Assert.Null (shortcut.ColorScheme);
 
         Application.Top.Dispose ();
         Application.ResetState ();

Tests/UnitTests/Views/ToplevelTests.cs

@@ -4,13 +4,6 @@ namespace Terminal.Gui.ViewsTests;
 
 public class ToplevelTests
 {
-    public ToplevelTests ()
-    {
-#if DEBUG_IDISPOSABLE
-        View.DebugIDisposable = true;
-#endif
-    }
-
     [Fact]
     public void Constructor_Default ()
     {

Tests/UnitTests/Views/WindowTests.cs

@@ -161,9 +161,6 @@ public class WindowTests (ITestOutputHelper output)
         Assert.Equal (0, windowWithFrameRectEmpty.Width);
         Assert.Equal (0, windowWithFrameRectEmpty.Height);
         Assert.False (windowWithFrameRectEmpty.IsCurrentTop);
-#if DEBUG
-        Assert.Equal (windowWithFrameRectEmpty.Title, windowWithFrameRectEmpty.Id);
-#endif
         Assert.False (windowWithFrameRectEmpty.WantContinuousButtonPressed);
         Assert.False (windowWithFrameRectEmpty.WantMousePositionReports);
         Assert.Null (windowWithFrameRectEmpty.SuperView);
@@ -176,11 +173,7 @@ public class WindowTests (ITestOutputHelper output)
         windowWithFrame1234.Title = "title";
         Assert.Equal ("title", windowWithFrame1234.Title);
         Assert.NotNull (windowWithFrame1234);
-#if DEBUG
-        Assert.Equal ($"Window(title){windowWithFrame1234.Frame}", windowWithFrame1234.ToString ());
-#else
         Assert.Equal ($"Window(){windowWithFrame1234.Frame}", windowWithFrame1234.ToString ());
-#endif
         Assert.True (windowWithFrame1234.CanFocus);
         Assert.False (windowWithFrame1234.HasFocus);
         Assert.Equal (new (0, 0, 1, 2), windowWithFrame1234.Viewport);
@@ -192,9 +185,6 @@ public class WindowTests (ITestOutputHelper output)
         Assert.Equal (3, windowWithFrame1234.Width);
         Assert.Equal (4, windowWithFrame1234.Height);
         Assert.False (windowWithFrame1234.IsCurrentTop);
-#if DEBUG
-        Assert.Equal (windowWithFrame1234.Title, windowWithFrame1234.Id);
-#endif
         Assert.False (windowWithFrame1234.WantContinuousButtonPressed);
         Assert.False (windowWithFrame1234.WantMousePositionReports);
         Assert.Null (windowWithFrame1234.SuperView);

Tests/UnitTestsParallelizable/Drawing/Region/RegionTests.cs

@@ -783,7 +783,7 @@ public class RegionTests
         Assert.True (region1.Contains (40, 40));
     }
 
-    [Fact (Skip = "Union is broken")]
+    [Fact]
     public void Union_Third_Rect_Covering_Two_Disjoint_Merges ()
     {
         var origRegion = new Region ();
@@ -791,19 +791,19 @@ public class RegionTests
         var region1 = new Region (new (0, 0, 1, 1));
         var region2 = new Region (new (1, 0, 1, 1));
 
-        origRegion.Union(region1);
-        origRegion.Union(region2);
+        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)));
+        origRegion.Union (new Region (new (0, 0, 4, 1)));
 
-        Assert.Equal (new Rectangle (0, 1, 4, 1), origRegion.GetBounds ());
-        Assert.Single (origRegion.GetRectangles ());
+        Assert.Equal (new Rectangle (0, 0, 4, 1), origRegion.GetBounds ());
+        Assert.Equal (3, origRegion.GetRectangles ().Length);
     }
 
-    [Fact (Skip = "MinimalUnion is broken")]
+    [Fact]
     public void MinimalUnion_Third_Rect_Covering_Two_Disjoint_Merges ()
     {
         var origRegion = new Region ();
@@ -819,7 +819,7 @@ public class RegionTests
 
         origRegion.MinimalUnion (new Region (new (0, 0, 4, 1)));
 
-        Assert.Equal (new Rectangle (0, 1, 4, 1), origRegion.GetBounds ());
+        Assert.Equal (new Rectangle (0, 0, 4, 1), origRegion.GetBounds ());
         Assert.Single (origRegion.GetRectangles ());
     }
 
@@ -928,6 +928,180 @@ public class RegionTests
         Assert.Contains (new (2, 0, 0, 1), result);
     }
 
+    [Fact]
+    public void MergeRectangles_Sort_Handles_Coincident_Events_Without_Crashing ()
+    {
+        // Arrange: Create rectangles designed to produce coincident start/end events
+        // Rect1 ends at x=10. Rect2 and Rect3 start at x=10.
+        // Rect4 ends at x=15. Rect5 starts at x=15.
+        var rect1 = new Rectangle (0, 0, 10, 10); // Ends at x=10
+        var rect2 = new Rectangle (10, 0, 10, 5); // Starts at x=10
+        var rect3 = new Rectangle (10, 5, 10, 5); // Starts at x=10, adjacent to rect2 vertically
+        var rect4 = new Rectangle (5, 10, 10, 5); // Ends at x=15
+        var rect5 = new Rectangle (15, 10, 5, 5); // Starts at x=15
+
+        var combinedList = new List<Rectangle> { rect1, rect2, rect3, rect4, rect5 };
+
+        // Act & Assert:
+        // The core assertion is that calling MergeRectangles with this list
+        // does *not* throw the ArgumentException related to sorting.
+        var exception = Record.Exception (() => Region.MergeRectangles (combinedList, false));
+
+        // Assert
+        Assert.Null (exception);
+
+        // Optional secondary assertion: Check if the merge produced a reasonable number of rectangles
+        // This isn't strictly necessary for proving the sort fix, but can be useful.
+        // var merged = Region.MergeRectangles(combinedList, false);
+        // Assert.True(merged.Count > 0 && merged.Count <= combinedList.Count);
+    }
+
+    [Fact]
+    public void MergeRectangles_Sort_Handles_Multiple_Coincident_Starts ()
+    {
+        // Arrange: Multiple rectangles starting at the same X
+        var rect1 = new Rectangle (5, 0, 10, 5);
+        var rect2 = new Rectangle (5, 5, 10, 5);
+        var rect3 = new Rectangle (5, 10, 10, 5);
+        var combinedList = new List<Rectangle> { rect1, rect2, rect3 };
+
+        // Act & Assert: Ensure no sorting exception
+        var exception = Record.Exception (() => Region.MergeRectangles (combinedList, false));
+        Assert.Null (exception);
+    }
+
+    [Fact]
+    public void MergeRectangles_Sort_Handles_Multiple_Coincident_Ends ()
+    {
+        // Arrange: Multiple rectangles ending at the same X
+        var rect1 = new Rectangle (0, 0, 10, 5);
+        var rect2 = new Rectangle (0, 5, 10, 5);
+        var rect3 = new Rectangle (0, 10, 10, 5);
+        var combinedList = new List<Rectangle> { rect1, rect2, rect3 };
+
+        // Act & Assert: Ensure no sorting exception
+        var exception = Record.Exception (() => Region.MergeRectangles (combinedList, false));
+        Assert.Null (exception);
+    }
 
+    [Fact]
+    public void MergeRectangles_Sort_Handles_Coincident_Mixed_Events_Without_Crashing ()
+    {
+        // Arrange: Create rectangles specifically designed to produce multiple
+        // Start AND End events at the same x-coordinate (e.g., x=10),
+        // mimicking the pattern observed in the crash log.
+        var rectA = new Rectangle (0, 0, 10, 5);  // Ends at x=10, y=[0, 5)
+        var rectB = new Rectangle (0, 10, 10, 5); // Ends at x=10, y=[10, 15)
+        var rectC = new Rectangle (10, 0, 10, 5); // Starts at x=10, y=[0, 5)
+        var rectD = new Rectangle (10, 10, 10, 5); // Starts at x=10, y=[10, 15)
+
+        // Add another set at a different X to increase complexity
+        var rectE = new Rectangle (5, 20, 10, 5); // Ends at x=15, y=[20, 25)
+        var rectF = new Rectangle (5, 30, 10, 5); // Ends at x=15, y=[30, 35)
+        var rectG = new Rectangle (15, 20, 10, 5); // Starts at x=15, y=[20, 25)
+        var rectH = new Rectangle (15, 30, 10, 5); // Starts at x=15, y=[30, 35)
+
+        // Add some unrelated rectangles
+        var rectI = new Rectangle (0, 40, 5, 5);
+        var rectJ = new Rectangle (100, 100, 5, 5);
+
+
+        var combinedList = new List<Rectangle> {
+            rectA, rectB, rectC, rectD,
+            rectE, rectF, rectG, rectH,
+            rectI, rectJ
+        };
+
+        // Act & Assert:
+        // Call MergeRectangles with the current code.
+        // This test *should* fail by throwing ArgumentException due to unstable sort.
+        var exception = Record.Exception (() => Region.MergeRectangles (combinedList, false));
+
+        // Assert that no exception was thrown (this assertion will fail with the current code)
+        Assert.Null (exception);
+    }
+
+    [Fact]
+    public void MergeRectangles_Sort_Reproduces_UICatalog_Crash_Pattern_Directly ()
+    {
+        // Arrange: Rectangles derived *directly* from the events list that caused the crash at x=67
+        // This aims to replicate the exact problematic pattern.
+        var rect_End_67_7_30 = new Rectangle (60, 7, 7, 23);  // Ends at x=67, y=[7, 30) -> Event [33]
+        var rect_Start_67_2_30 = new Rectangle (67, 2, 10, 28); // Starts at x=67, y=[2, 30) -> Event [34]
+        var rect_Start_67_1_1 = new Rectangle (67, 1, 10, 0);  // Starts at x=67, y=[1, 1) -> Event [49] (Height 0)
+        var rect_End_67_1_1 = new Rectangle (60, 1, 7, 0);   // Ends at x=67, y=[1, 1) -> Event [64] (Height 0)
+
+        // Add rectangles for x=94/95 pattern
+        var rect_End_94_1_30 = new Rectangle (90, 1, 4, 29); // Ends at x=94, y=[1, 30) -> Event [55]
+        var rect_Start_94_1_1 = new Rectangle (94, 1, 10, 0); // Starts at x=94, y=[1, 1) -> Event [56]
+        var rect_Start_94_7_30 = new Rectangle (94, 7, 10, 23); // Starts at x=94, y=[7, 30) -> Event [58]
+
+        var rect_End_95_1_1 = new Rectangle (90, 1, 5, 0); // Ends at x=95, y=[1, 1) -> Event [57]
+        var rect_End_95_7_30 = new Rectangle (90, 7, 5, 23); // Ends at x=95, y=[7, 30) -> Event [59]
+        var rect_Start_95_0_30 = new Rectangle (95, 0, 10, 30); // Starts at x=95, y=[0, 30) -> Event [60]
+
+
+        var combinedList = new List<Rectangle> {
+            rect_End_67_7_30, rect_Start_67_2_30, rect_Start_67_1_1, rect_End_67_1_1,
+            rect_End_94_1_30, rect_Start_94_1_1, rect_Start_94_7_30,
+            rect_End_95_1_1, rect_End_95_7_30, rect_Start_95_0_30
+        };
+
+        // Act & Assert:
+        // Call MergeRectangles. This test is specifically designed to fail with the current code.
+        var exception = Record.Exception (() => Region.MergeRectangles (combinedList, false));
+
+        // Assert that no exception was thrown (this assertion *should* fail with the current code)
+        Assert.Null (exception);
+    }
+
+    [Fact]
+    public void MergeRectangles_Sort_Reproduces_UICatalog_Crash_From_Captured_Data ()
+    {
+        // Arrange: The exact list of rectangles captured during the UICatalog crash
+        var rectanglesFromCrash = new List<Rectangle> {
+            new Rectangle(38, 7, 1, 11),
+            new Rectangle(39, 7, 5, 23),
+            new Rectangle(44, 7, 1, 23),
+            new Rectangle(45, 7, 6, 23),
+            new Rectangle(51, 7, 1, 23),
+            new Rectangle(52, 7, 1, 23),
+            new Rectangle(53, 7, 1, 23),
+            new Rectangle(54, 7, 1, 23),
+            new Rectangle(55, 7, 1, 23),
+            new Rectangle(56, 7, 1, 23),
+            new Rectangle(57, 7, 1, 23),
+            new Rectangle(58, 7, 1, 23),
+            new Rectangle(59, 7, 1, 23),
+            new Rectangle(60, 7, 1, 23),
+            new Rectangle(61, 7, 3, 23),
+            new Rectangle(64, 7, 1, 23),
+            new Rectangle(65, 7, 2, 23),
+            new Rectangle(67, 2, 2, 28),
+            new Rectangle(69, 2, 3, 28),
+            new Rectangle(72, 2, 3, 28),
+            new Rectangle(75, 2, 1, 28),
+            new Rectangle(76, 2, 2, 28),
+            new Rectangle(78, 2, 2, 28),
+            new Rectangle(80, 7, 1, 23),
+            new Rectangle(81, 1, 7, 29),
+            new Rectangle(88, 1, 1, 29),
+            new Rectangle(89, 1, 2, 29),
+            new Rectangle(91, 1, 3, 29),
+            new Rectangle(94, 1, 1, 0),   // Note: Zero height
+            new Rectangle(94, 7, 1, 23),
+            new Rectangle(95, 0, 1, 30),
+            new Rectangle(96, 0, 23, 30),
+            new Rectangle(67, 1, 0, 0)    // Note: Zero width and height
+        };
+
+        // Act & Assert:
+        // Call MergeRectangles with the current code.
+        // This test *should* fail by throwing ArgumentException due to unstable sort.
+        var exception = Record.Exception (() => Region.MergeRectangles (rectanglesFromCrash, false));
+
+        // Assert that no exception was thrown (this assertion will fail with the current code)
+        Assert.Null (exception);
+    }
 
 }

Tests/UnitTestsParallelizable/ParallelizableBase.cs

@@ -0,0 +1,11 @@
+namespace UnitTests.Parallelizable;
+
+/// <summary>
+///     Base class for parallelizable tests. Ensures that tests can run in parallel without interference
+///     by setting various Terminal.Gui static properties to their default values. E.g. View.EnableDebugIDisposableAsserts.
+/// </summary>
+[Collection ("Global Test Setup")]
+public abstract class ParallelizableBase
+{
+    // Common setup or utilities for all tests can go here
+}

Tests/UnitTestsParallelizable/TestSetup.cs

@@ -0,0 +1,101 @@
+namespace UnitTests.Parallelizable;
+
+/// <summary>
+///     Ensures that tests can run in parallel without interference
+///     by setting various Terminal.Gui static properties to their default values. E.g. View.EnableDebugIDisposableAsserts.
+///     Annotate all test classes with [Collection("Global Test Setup")] or have it inherit from this class.
+/// </summary>
+public class GlobalTestSetup : IDisposable
+{
+    public GlobalTestSetup ()
+    {
+#if DEBUG_IDISPOSABLE
+        // Ensure EnableDebugIDisposableAsserts is false before tests run
+        View.EnableDebugIDisposableAsserts = false;
+#endif
+        CheckDefaultState ();
+    }
+
+    public void Dispose ()
+    {
+        // Optionally reset EnableDebugIDisposableAsserts after tests. Don't do this.
+        // View.EnableDebugIDisposableAsserts = true;
+
+        // Reset application state just in case a test changed something.
+        // TODO: Add an Assert to ensure none of the state of Application changed.
+        // TODO: Add an Assert to ensure none of the state of ConfigurationManager changed.
+        CheckDefaultState ();
+        Application.ResetState (true);
+    }
+
+    // IMPORTANT: Ensure this matches the code in Init_ResetState_Resets_Properties
+    // here: .\Tests\UnitTests\Application\ApplicationTests.cs
+    private void CheckDefaultState ()
+    {
+#if DEBUG_IDISPOSABLE
+        Assert.False (View.EnableDebugIDisposableAsserts, "View.EnableDebugIDisposableAsserts should be false for Parallelizable tests.");
+#endif
+
+        // Check that all Application fields and properties are set to their default values
+
+        // Public Properties
+        Assert.Null (Application.Top);
+        Assert.Null (Application.MouseGrabView);
+        Assert.Null (Application.WantContinuousButtonPressedView);
+
+        // Don't check Application.ForceDriver
+        // Assert.Empty (Application.ForceDriver);
+        // Don't check Application.Force16Colors
+        //Assert.False (Application.Force16Colors);
+        Assert.Null (Application.Driver);
+        Assert.Null (Application.MainLoop);
+        Assert.False (Application.EndAfterFirstIteration);
+        Assert.Equal (Key.Tab.WithShift, Application.PrevTabKey);
+        Assert.Equal (Key.Tab, Application.NextTabKey);
+        Assert.Equal (Key.F6.WithShift, Application.PrevTabGroupKey);
+        Assert.Equal (Key.F6, Application.NextTabGroupKey);
+        Assert.Equal (Key.Esc, Application.QuitKey);
+
+        // Internal properties
+        Assert.False (Application.Initialized);
+        Assert.Equal (Application.GetSupportedCultures (), Application.SupportedCultures);
+        Assert.Equal (Application.GetAvailableCulturesFromEmbeddedResources (), Application.SupportedCultures);
+        Assert.False (Application._forceFakeConsole);
+        Assert.Equal (-1, Application.MainThreadId);
+        Assert.Empty (Application.TopLevels);
+        Assert.Empty (Application._cachedViewsUnderMouse);
+
+        // Mouse
+        // Do not reset _lastMousePosition
+        //Assert.Null (Application._lastMousePosition);
+
+        // Navigation
+        Assert.Null (Application.Navigation);
+
+        // Popover
+        Assert.Null (Application.Popover);
+
+        // Events - Can't check
+        //Assert.Null (Application.NotifyNewRunState);
+        //Assert.Null (Application.NotifyNewRunState);
+        //Assert.Null (Application.Iteration);
+        //Assert.Null (Application.SizeChanging);
+        //Assert.Null (Application.GrabbedMouse);
+        //Assert.Null (Application.UnGrabbingMouse);
+        //Assert.Null (Application.GrabbedMouse);
+        //Assert.Null (Application.UnGrabbedMouse);
+        //Assert.Null (Application.MouseEvent);
+        //Assert.Null (Application.KeyDown);
+        //Assert.Null (Application.KeyUp);
+    }
+
+}
+
+// Define a collection for the global setup
+[CollectionDefinition ("Global Test Setup")]
+public class GlobalTestSetupCollection : ICollectionFixture<GlobalTestSetup>
+{
+    // This class has no code and is never instantiated.
+    // Its purpose is to apply the [CollectionDefinition] attribute
+    // and associate the GlobalTestSetup with the test collection.
+}

Tests/UnitTestsParallelizable/UnitTests.Parallelizable.csproj

@@ -22,7 +22,7 @@
 
     <PropertyGroup Condition="'$(Configuration)'=='Debug'">
         <DefineDebug>true</DefineDebug>
-        <DefineConstants>$(DefineConstants)</DefineConstants>
+        <DefineConstants>$(DefineConstants);DEBUG_IDISPOSABLE</DefineConstants>
     </PropertyGroup>
     <PropertyGroup Condition="'$(Configuration)'=='Release'">
         <Optimize>true</Optimize>

Tests/UnitTestsParallelizable/View/Adornment/AdornmentSubViewTests.cs

@@ -2,6 +2,7 @@
 
 namespace Terminal.Gui.ViewTests;
 
+[Collection ("Global Test Setup")]
 public class AdornmentSubViewTests ()
 {
     [Fact]

Tests/UnitTestsParallelizable/View/Adornment/AdornmentTests.cs

@@ -1,5 +1,6 @@
 namespace Terminal.Gui.ViewTests;
 
+[Collection ("Global Test Setup")]
 public class AdornmentTests
 {
     [Fact]

Tests/UnitTestsParallelizable/View/Adornment/ShadowStyletests.cs

@@ -1,5 +1,7 @@
 namespace Terminal.Gui.ViewTests;
 
+[Collection ("Global Test Setup")]
+
 public class ShadowStyleTests
 {
     [Fact]

Tests/UnitTestsParallelizable/View/Keyboard/HotKeyTests.cs

@@ -3,6 +3,7 @@ using Xunit.Abstractions;
 
 namespace Terminal.Gui.ViewTests;
 
+[Collection ("Global Test Setup")]
 public class HotKeyTests
 {
     [Theory]
@@ -372,46 +373,4 @@ public class HotKeyTests
         Assert.Equal ("", view.Title);
         Assert.Equal (KeyCode.Null, view.HotKey);
     }
-
-
-    [Fact]
-    public void HotKey_Raises_HotKeyCommand ()
-    {
-        var hotKeyRaised = false;
-        var acceptRaised = false;
-        var selectRaised = false;
-        Application.Top = new Toplevel ();
-        var view = new View
-        {
-            CanFocus = true,
-            HotKeySpecifier = new Rune ('_'),
-            Title = "_Test"
-        };
-        Application.Top.Add (view);
-        view.HandlingHotKey += (s, e) => hotKeyRaised = true;
-        view.Accepting += (s, e) => acceptRaised = true;
-        view.Selecting += (s, e) => selectRaised = true;
-
-        Assert.Equal (KeyCode.T, view.HotKey);
-        Assert.True (Application.RaiseKeyDownEvent (Key.T));
-        Assert.True (hotKeyRaised);
-        Assert.False (acceptRaised);
-        Assert.False (selectRaised);
-
-        hotKeyRaised = false;
-        Assert.True (Application.RaiseKeyDownEvent (Key.T.WithAlt));
-        Assert.True (hotKeyRaised);
-        Assert.False (acceptRaised);
-        Assert.False (selectRaised);
-
-        hotKeyRaised = false;
-        view.HotKey = KeyCode.E;
-        Assert.True (Application.RaiseKeyDownEvent (Key.E.WithAlt));
-        Assert.True (hotKeyRaised);
-        Assert.False (acceptRaised);
-        Assert.False (selectRaised);
-
-        Application.Top.Dispose ();
-        Application.ResetState (true);
-    }
 }

Tests/UnitTestsParallelizable/View/Keyboard/KeyboardEventTests.cs

@@ -5,6 +5,7 @@ using Xunit.Abstractions;
 
 namespace Terminal.Gui.ViewTests;
 
+[Collection ("Global Test Setup")]
 public class KeyboardEventTests (ITestOutputHelper output) : TestsAllViews
 {
     /// <summary>