Revert changes to MoveMenuItemRightOperation

Test menu bar more

Author: tznind

Showcase/Menus.Designer.cs

@@ -7,7 +7,7 @@
 //      You can make changes to this file and they will not be overwritten when saving.
 //  </auto-generated>
 // -----------------------------------------------------------------------------
-namespace Showcase{
+namespace YourNamespace {
     using Terminal.Gui;
 
 

Showcase/Menus.cs

@@ -73,51 +73,39 @@ protected override bool DoImpl()
             return false;
         }
 
+        // When user hits shift right
         var children = this.Parent.GetMenuItems(out _);
         var currentItemIdx = children.IndexOf(this.OperateOn);
         var aboveIdx = currentItemIdx - 1;
 
+        // and there is an item above
         if (aboveIdx < 0)
         {
             return false;
         }
 
+        // Get or create a submenu on the item above
         var itemAbove = children[aboveIdx];
+        if (itemAbove.SubMenu == null)
+        {
+            itemAbove.SubMenu = new Menu();
+        }
 
-        // Remove us from current menu first
+        // Remove us from current menu
         this.Parent.RemoveMenuItem(this.OperateOn);
 
-        if (itemAbove is MenuBarItem existingMbi)
+        // Add us to the submenu of the item above
+        if (this.InsertionIndex != null)
         {
-            // Item above already has a sub-menu — add to it
-            if (this.InsertionIndex != null)
-            {
-                existingMbi.InsertMenuItem(this.InsertionIndex.Value, this.OperateOn);
-            }
-            else
-            {
-                var subItems = existingMbi.GetMenuItems(out _);
-                subItems.Add(this.OperateOn);
-                existingMbi.SetMenuItems(subItems);
-            }
+            itemAbove.InsertMenuItem(this.InsertionIndex.Value, this.OperateOn);
         }
         else
         {
-            // Convert plain MenuItem to MenuBarItem with OperateOn as first child.
-            // Re-read children since RemoveMenuItem may have shifted indexes.
-            children = this.Parent.GetMenuItems(out _);
-            var newAboveIdx = children.IndexOf(itemAbove);
-
-            var newMbi = new MenuBarItem(itemAbove.Title, new MenuItem[] { this.OperateOn });
-            newMbi.Data = itemAbove.Data;
-            newMbi.Key = itemAbove.Key;
-
-            children.RemoveAt(newAboveIdx);
-            children.Insert(newAboveIdx, newMbi);
-            this.Parent.SetMenuItems(children);
+            itemAbove.SubMenu.Add(this.OperateOn);
         }
 
         this.Bar?.SetNeedsDraw();
+
         return true;
     }
 

src/Operations/MenuOperations/MoveMenuItemRightOperation.cs

@@ -293,30 +293,28 @@ public void MoveMenuItemRight_CannotMoveElementZero( )
         Assert.That( impossibleMoveRightOpSucceeded, Is.False );
 
         // can move element 1
-        // This is a destructive action, so references will change.
         MoveMenuItemRightOperation validMoveRightOp = new( App, fileMenu.GetMenuItems(out _)[1] );
         Assert.That( validMoveRightOp.IsImpossible, Is.False );
         bool validMoveRightOpSucceeded = false;
         Assert.That( ( ) => validMoveRightOpSucceeded = validMoveRightOp.Do( ), Throws.Nothing );
         Assert.That( validMoveRightOpSucceeded );
 
-        // We will have changed from a MenuItem to a MenuBarItem
-        // so element 0 will not be us.  In Terminal.Gui there is
-        // a different class for a menu item and one with submenus.
-        Assert.That( fileMenu.GetMenuItems(out _)[0], Is.Not.Null.And.InstanceOf<MenuBarItem>( ) );
-        MenuBarItem miConvertedToMenuBarItem = (MenuBarItem)fileMenu.GetMenuItems(out _)[0];
+        // In Terminal.Gui v2, nested items with sub-menus remain plain MenuItem instances
+        // (with SubMenu set) rather than being converted to MenuBarItem.  MenuBarItem is
+        // exclusively for top-level MenuBar entries.  The same object reference (mi) is
+        // retained at index 0 — it is not replaced with a new object.
+        Assert.That( fileMenu.GetMenuItems(out _), Has.Exactly( 1 ).InstanceOf<MenuItem>( ) );
+        MenuItem miWithSubMenu = fileMenu.GetMenuItems(out _)[0];
 
-        // Check that the references are unequal but values are equal
         Assert.Multiple( ( ) =>
         {
-            Assert.That( miConvertedToMenuBarItem, Is.Not.SameAs( mi ) );
-            Assert.That( miConvertedToMenuBarItem.Title, Is.EqualTo( mi.Title ) );
-            Assert.That( miConvertedToMenuBarItem.Data, Is.EqualTo( mi.Data ) );
-            Assert.That( miConvertedToMenuBarItem.GetMenuItems(out _), Has.Exactly( 1 ).InstanceOf<MenuItem>( ) );
+            Assert.That( miWithSubMenu, Is.SameAs( mi ) );
+            Assert.That( miWithSubMenu.Title, Is.EqualTo( mi.Title ) );
+            Assert.That( miWithSubMenu.Data, Is.EqualTo( mi.Data ) );
+            Assert.That( miWithSubMenu.GetMenuItems(out _), Has.Exactly( 1 ).InstanceOf<MenuItem>( ) );
         } );
 
         // Now undo it.
-        // This is destructive as well.
         Assert.That( validMoveRightOp.Undo, Throws.Nothing );
 
         Assert.That( fileMenu.GetMenuItems(out _), Has.Exactly( 2 ).InstanceOf<MenuItem>( ) );
@@ -326,23 +324,16 @@ public void MoveMenuItemRight_CannotMoveElementZero( )
             Assert.That( fileMenu.GetMenuItems(out _)[1], Is.Not.Null.And.InstanceOf<MenuItem>( ) );
         } );
         MenuItem firstChildAfterUndo = fileMenu.GetMenuItems(out _)[0];
-        MenuItem secondChildAfterUndo = fileMenu.GetMenuItems(out _)[1];
 
         Assert.Multiple( ( ) =>
         {
-            // All the previous references are gone forever through this process.
-            // So, neither element should be mi.
-            Assert.That( firstChildAfterUndo, Is.Not.SameAs( mi ) );
-            Assert.That( secondChildAfterUndo, Is.Not.SameAs( mi ) );
-
-            // Neither element should be miConvertedToMenuBarItem either
-            Assert.That( firstChildAfterUndo, Is.Not.SameAs( miConvertedToMenuBarItem ) );
-            Assert.That( secondChildAfterUndo, Is.Not.SameAs( miConvertedToMenuBarItem ) );
+            // The same object reference is retained after undo.
+            Assert.That( firstChildAfterUndo, Is.SameAs( mi ) );
 
-            // And mi still should not be miConvertedToMenuBarItem
-            Assert.That( mi, Is.Not.SameAs( miConvertedToMenuBarItem ) );
+            // The sub-menu should have been cleared after undo.
+            Assert.That( firstChildAfterUndo.GetMenuItems(out _), Is.Empty );
 
-            // But the values need to be preserved
+            // Values need to be preserved.
             Assert.That( firstChildAfterUndo.Title, Is.EqualTo( mi.Title ) );
             Assert.That( firstChildAfterUndo.Data, Is.EqualTo( mi.Data ) );
             Assert.That( firstChildAfterUndo.Key, Is.EqualTo( mi.Key) );