Partial #2975 - Deprecate v1 Menu classes

Examples/UICatalog/Scenarios/Menus.cs

@@ -63,6 +63,18 @@ public override void Main ()
                                             eventLog.MoveDown ();
                                         };
 
+        menuHostView.Selecting += (o, args) =>
+                                  {
+                                      if (o is not View sender || args.Handled)
+                                      {
+                                          return;
+                                      }
+
+                                      Logging.Debug ($"{sender.Id} Selecting: {args?.Context?.Source?.Title}");
+                                      eventSource.Add ($"{sender.Id} Selecting: {args?.Context?.Source?.Title}: ");
+                                      eventLog.MoveDown ();
+                                  };
+
         menuHostView.Accepting += (o, args) =>
                                   {
                                       if (o is not View sender || args.Handled)
@@ -75,6 +87,18 @@ public override void Main ()
                                       eventLog.MoveDown ();
                                   };
 
+        menuHostView.ContextMenu!.Selecting += (o, args) =>
+                                               {
+                                                   if (o is not View sender || args.Handled)
+                                                   {
+                                                       return;
+                                                   }
+
+                                                   Logging.Debug ($"{sender.Id} Selecting: {args?.Context?.Source?.Title}");
+                                                   eventSource.Add ($"{sender.Id} Selecting: {args?.Context?.Source?.Title}: ");
+                                                   eventLog.MoveDown ();
+                                               };
+
         menuHostView.ContextMenu!.Accepted += (o, args) =>
                                               {
                                                   if (o is not View sender || args.Handled)
@@ -105,7 +129,6 @@ public MenuHost ()
         {
             CanFocus = true;
             BorderStyle = LineStyle.Dashed;
-
             AddCommand (
                         Command.Context,
                         ctx =>

Terminal.Gui/Application/PopoverBaseImpl.cs

@@ -28,9 +28,9 @@ protected PopoverBaseImpl ()
         ViewportSettings = ViewportSettings.Transparent | ViewportSettings.TransparentMouse;
 
         // TODO: Add a diagnostic setting for this?
-        //TextFormatter.VerticalAlignment = Alignment.End;
-        //TextFormatter.Alignment = Alignment.End;
-        //base.Text = "popover";
+        TextFormatter.VerticalAlignment = Alignment.End;
+        TextFormatter.Alignment = Alignment.End;
+        base.Text = "PopoverBaseImpl";
 
         AddCommand (Command.Quit, Quit);
         KeyBindings.Add (Application.QuitKey, Command.Quit);

Terminal.Gui/Resources/config.json

@@ -319,7 +319,7 @@
         "Glyphs.VLineHvDa3": "┇",
         "Glyphs.VLineHvDa4": "┋"
       }
-    },
+      },
     {
       "Dark": {
         "Dialog.DefaultButtonAlignment": "End",

Terminal.Gui/View/View.Command.cs

@@ -221,17 +221,24 @@ private void SetupCommands ()
         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.
-        if (OnSelecting (args) || args.Handled)
+        if (!args.Handled && Selecting is { })
         {
-            return true;
+            // If the event is not canceled by the virtual method, raise the event to notify any external subscribers.
+            Logging.Debug ($"{Title} ({ctx?.Source?.Title}) - Raising Selecting...");
+            Selecting?.Invoke (this, args);
         }
 
-        // If the event is not canceled by the virtual method, raise the event to notify any external subscribers.
-        Selecting?.Invoke (this, args);
+        //  - bubbled up the SuperView hierarchy.
+        if (!args.Handled)
+        {
+            if (SuperView is { })
+            {
+                Logging.Debug ($"{Title} ({ctx?.Source?.Title}) - Invoking Select on SuperView ({SuperView.Title}/{SuperView.Id})...");
+                return SuperView?.InvokeCommand (Command.Select, ctx);
+            }
+        }
 
-        return Selecting is null ? null : args.Handled;
+        return args.Handled;
     }
 
     /// <summary>

Terminal.Gui/View/View.cs

@@ -433,6 +433,13 @@ public string Title
     {
         get
         {
+// TODO: Re-enable this after Debug logging in RaiseSelecting is removed        
+//#if DEBUG_IDISPOSABLE
+//            if (EnableDebugIDisposableAsserts && WasDisposed)
+//            {
+//                throw new ObjectDisposedException (GetType ().FullName);
+//            }
+//#endif
             return _title;
         }
         set

Terminal.Gui/Views/Menu/MenuBarv2.cs

@@ -493,12 +493,12 @@
     }
 
     /// <inheritdoc/>
     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";
+        Id = "DemoBar";
 
         var bordersCb = new CheckBox
         {
@@ -695,7 +695,7 @@
 
             var editMode = new MenuItemv2
             {
-                Text = "App Binding to Command.Edit",
+                Text = "Command = Edit; TargetView = null",
                 Id = "EditMode",
                 Command = Command.Edit,
                 CommandView = new CheckBox

Terminal.Gui/Views/Menu/MenuItemv2.cs

@@ -111,26 +111,40 @@ public Command Command
 
         if (commandContext is CommandContext<KeyBinding> keyCommandContext)
         {
+            if (SubMenu is { Visible: true } && (keyCommandContext.Command == Command.Select || keyCommandContext.Command == Command.Accept))
+            {
+                // Our submenu is open; and user pressed enter or clicked, set focus to it
+                Logging.Debug ($"{Title} - SubMenu is Visible; Accept/Select - {keyCommandContext.Command}");
+                SubMenu.SetFocus ();
+                return true;
+            }
+
+            if (SubMenu is { Visible: true } && keyCommandContext.Command == Command.HotKey)
+            {
+                // Our submenu is open; let command processing flow to it
+                Logging.Debug ($"{Title} - SubMenu Visible; HotKey - {keyCommandContext.Command}");
+                return false;
+            }
+
             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 { })
             {
-                Logging.Debug ($"{Title} - InvokeCommand on TargetView ({TargetView.Title})...");
+                // Translate the incoming command to Command
+                if (Command != Command.NotBound && commandContext is { })
+                {
+                    commandContext.Command = Command;
+                }
+
+                Logging.Debug ($"{Title} - InvokeCommand on TargetView ({TargetView.Title}) - Command: {commandContext?.Command}...");
                 ret = TargetView.InvokeCommand (Command, commandContext);
             }
             else
@@ -143,35 +157,33 @@ public Command Command
 
         if (ret is not true)
         {
-            Logging.Debug ($"{Title} - calling base.DispatchCommand...");
+            Logging.Debug ($"{Title} - calling base.DispatchCommand. - Command: {commandContext?.Command}..");
             // Base will Raise Selected, then Accepting, then invoke the Action, if any
             ret = base.DispatchCommand (commandContext);
         }
 
         if (ret is true)
         {
-            Logging.Debug ($"{Title} - Calling RaiseAccepted");
+            Logging.Debug ($"{Title} - Calling RaiseAccepted - Command: {commandContext?.Command}");
             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;
-    //    }
+    /// <inheritdoc />
+    protected override bool OnAccepting (CommandEventArgs e)
+    {
+        Logging.Debug ($"{Title} - calling base.OnAccepting: {e.Context?.Command}");
+        bool? ret = base.OnAccepting (e);
 
-    //    //RaiseAccepted (e.Context);
+        if (ret is true || e.Handled)
+        {
+            return true;
+        }
 
-    //    return ret is true;
-    //}
+        return ret is true;
+    }
 
     private Menuv2? _subMenu;
 
@@ -195,6 +207,7 @@ public Menuv2? SubMenu
         }
     }
 
+
     /// <inheritdoc/>
     protected override bool OnMouseEnter (CancelEventArgs eventArgs)
     {
@@ -230,7 +243,10 @@ protected void RaiseAccepted (ICommandContext? ctx)
     /// <remarks>
     /// </remarks>
     /// <param name="args"></param>
-    protected virtual void OnAccepted (CommandEventArgs args) { }
+    protected virtual void OnAccepted (CommandEventArgs args)
+    {
+        Logging.Debug ($"{Title} ({args.Context?.Command})");
+    }
 
     /// <summary>
     ///     Raised when the user has accepted an item in this menu (or submenu). This is used to determine when to hide the