Move Pane to Tab (GH7075)

.github/actions/spelling/allow/apis.txt

@@ -79,6 +79,7 @@ localtime
 lround
 LSHIFT
 memicmp
+mptt
 mov
 msappx
 MULTIPLEUSE

doc/cascadia/profiles.schema.json

@@ -239,6 +239,7 @@
         "identifyWindows",
         "moveFocus",
         "movePane",
+        "movePaneToTab",
         "moveTab",
         "newTab",
         "newWindow",
@@ -493,6 +494,23 @@
               "type": "integer",
               "default": 0,
               "description": "Which tab to switch to, with the first being 0"
+          }
+        }
+      }
+    ],
+    "required": [ "index" ]
+  },
+  "MovePaneToTabAction": {
+      "description": "Arguments corresponding to a Move Pane To Tab Action",
+      "allOf": [
+        { "$ref": "#/definitions/ShortcutAction" },
+        {
+          "properties": {
+            "action": { "type": "string", "pattern": "movePaneToTab" },
+            "index": {
+              "type": "integer",
+              "default": 0,
+              "description": "Which tab to move the pane to, with the first being 0"
             }
           }
         }

src/cascadia/TerminalApp/AppActionHandlers.cpp

@@ -143,6 +143,20 @@ namespace winrt::TerminalApp::implementation
         }
     }
 
+    void TerminalPage::_HandleMovePaneToTab(const IInspectable& /*sender*/,
+                                            const ActionEventArgs& args)
+    {
+        if (args == nullptr)
+        {
+            args.Handled(false);
+        }
+        else if (const auto& realArgs = args.ActionArgs().try_as<MovePaneToTabArgs>())
+        {
+            auto moved = _MovePaneToTab(realArgs.TabIndex());
+            args.Handled(moved);
+        }
+    }
+
     void TerminalPage::_HandleSplitPane(const IInspectable& /*sender*/,
                                         const ActionEventArgs& args)
     {

src/cascadia/TerminalApp/AppCommandlineArgs.cpp

@@ -190,6 +190,7 @@ void AppCommandlineArgs::_buildParser()
     // Subcommands
     _buildNewTabParser();
     _buildSplitPaneParser();
+    _buildMovePaneToTabParser();
     _buildFocusTabParser();
     _buildMoveFocusParser();
     _buildMovePaneParser();
@@ -297,6 +298,43 @@ void AppCommandlineArgs::_buildSplitPaneParser()
     setupSubcommand(_newPaneCommand);
     setupSubcommand(_newPaneShort);
 }
+// Method Description:
+// - Adds the `move-pane-to-tab` subcommand and related options to the commandline parser.
+// - Additionally adds the `mptt` subcommand, which is just a shortened version of `move-pane-to-tab`
+// Arguments:
+// - <none>
+// Return Value:
+// - <none>
+void AppCommandlineArgs::_buildMovePaneToTabParser()
+{
+    _movePaneToTabCommand = _app.add_subcommand("move-pane-to-tab", RS_A(L"CmdMovePaneToTabDesc"));
+    _movePaneToTabShort = _app.add_subcommand("mptt", RS_A(L"CmdMPTTDesc"));
+
+    auto setupSubcommand = [this](auto* subcommand) {
+        subcommand->add_option("-t,--target",
+                               _movePaneToTabIndex,
+                               RS_A(L"CmdMovePaneToTabTargetArgDesc"));
+
+        // When ParseCommand is called, if this subcommand was provided, this
+        // callback function will be triggered on the same thread. We can be sure
+        // that `this` will still be safe - this function just lets us know this
+        // command was parsed.
+        subcommand->callback([&, this]() {
+            // Build the action from the values we've parsed on the commandline.
+            ActionAndArgs movePaneToTabAction{};
+
+            if (_movePaneToTabIndex >= 0)
+            {
+                movePaneToTabAction.Action(ShortcutAction::MovePaneToTab);
+                MovePaneToTabArgs args{ static_cast<unsigned int>(_movePaneToTabIndex) };
+                movePaneToTabAction.Args(args);
+                _startupActions.push_back(movePaneToTabAction);
+            }
+        });
+    };
+    setupSubcommand(_movePaneToTabCommand);
+    setupSubcommand(_movePaneToTabShort);
+}
 
 // Method Description:
 // - Adds the `focus-tab` subcommand and related options to the commandline parser.
@@ -619,6 +657,8 @@ bool AppCommandlineArgs::_noCommandsProvided()
 {
     return !(*_newTabCommand.subcommand ||
              *_newTabShort.subcommand ||
+             *_movePaneToTabCommand ||
+             *_movePaneToTabShort ||
              *_focusTabCommand ||
              *_focusTabShort ||
              *_moveFocusCommand ||
@@ -653,6 +693,7 @@ void AppCommandlineArgs::_resetStateToDefault()
     _splitPaneSize = 0.5f;
     _splitDuplicate = false;
 
+    _movePaneToTabIndex = -1;
     _focusTabIndex = -1;
     _focusNextTab = false;
     _focusPrevTab = false;

src/cascadia/TerminalApp/AppCommandlineArgs.h

@@ -78,6 +78,8 @@ class TerminalApp::AppCommandlineArgs final
     NewTerminalSubcommand _newTabShort;
     NewPaneSubcommand _newPaneCommand;
     NewPaneSubcommand _newPaneShort;
+    CLI::App* _movePaneToTabCommand;
+    CLI::App* _movePaneToTabShort;
     CLI::App* _focusTabCommand;
     CLI::App* _focusTabShort;
     CLI::App* _moveFocusCommand;
@@ -107,6 +109,7 @@ class TerminalApp::AppCommandlineArgs final
     bool _splitDuplicate{ false };
     float _splitPaneSize{ 0.5f };
 
+    int _movePaneToTabIndex{ -1 };
     int _focusTabIndex{ -1 };
     bool _focusNextTab{ false };
     bool _focusPrevTab{ false };
@@ -128,6 +131,7 @@ class TerminalApp::AppCommandlineArgs final
     void _addNewTerminalArgs(NewTerminalSubcommand& subcommand);
     void _buildParser();
     void _buildNewTabParser();
+    void _buildMovePaneToTabParser();
     void _buildSplitPaneParser();
     void _buildFocusTabParser();
     void _buildMoveFocusParser();

src/cascadia/TerminalApp/Pane.cpp

@@ -1011,6 +1011,84 @@ void Pane::UpdateSettings(const TerminalSettingsCreateResult& settings, const GU
     }
 }
 
+// Method Description:
+// - Attempts to add the provided pane as a split of the current pane.
+// Arguments:
+// - pane: the new pane to add
+// Return Value:
+// - the new reference to the child created from the current pane.
+std::shared_ptr<Pane> Pane::AttachPane(std::shared_ptr<Pane> pane, SplitState splitType)
+{
+    // Splice the new pane into the tree
+    auto [first, _] = _Split(splitType, .5, pane);
+
+    // If the new pane has a child that was the focus, re-focus it
+    // to steal focus from the currently focused pane.
+    if (pane->_HasFocusedChild())
+    {
+        pane->WalkTree([](auto p) {
+            if (p->_lastActive)
+            {
+                p->_FocusFirstChild();
+                return true;
+            }
+            return false;
+        });
+    }
+
+    return first;
+}
+
+// Method Description:
+// - Attempts to find one of our children matching `id,` if found remove the
+//   pane from the tree and return it.
+// - If the removed pane was (or contained the focus) the first sibling will
+//   gain focus
+// Arguments:
+// - The id of the pane to close
+// Return Value:
+// - The removed pane, if found.
+std::shared_ptr<Pane> Pane::DetachPane(uint32_t id)
+{
+    // We can't remove a pane if we only have a reference to a leaf, even if we
+    // match the id.
+    if (_IsLeaf())
+    {
+        return nullptr;
+    }
+
+    // Check if either of our children matches the search
+    auto isFirstChild = _firstChild->_IsLeaf() && _firstChild->_id == id;
+    auto isSecondChild = _secondChild->_IsLeaf() && _secondChild->_id == id;
+
+    if (isFirstChild || isSecondChild)
+    {
+        // Keep a reference to the child we are removing
+        auto detached = isFirstChild ? _firstChild : _secondChild;
+        // Remove the child from the tree, replace the current node with the
+        // other child.
+        _CloseChild(isFirstChild);
+
+        detached->_borders = Borders::None;
+        detached->_UpdateBorders();
+
+        // Trigger the detached event on each child
+        detached->WalkTree([](auto pane) {
+            pane->_PaneDetachedHandlers(pane);
+            return false;
+        });
+
+        return detached;
+    }
+
+    if (auto detached = !_firstChild->_IsLeaf() ? _firstChild->DetachPane(id) : nullptr)
+    {
+        return detached;
+    }
+
+    return !_secondChild->_IsLeaf() ? _secondChild->DetachPane(id) : nullptr;
+}
+
 // Method Description:
 // - Closes one of our children. In doing so, takes the control from the other
 //   child, and makes this pane a leaf node again.
@@ -1073,12 +1151,10 @@ void Pane::_CloseChild(const bool closeFirst)
         // them.
         _lastActive = _firstChild->_lastActive || _secondChild->_lastActive;
 
-        // Remove all the ui elements of our children. This'll make sure we can
-        // re-attach the TermControl to our Grid.
-        _firstChild->_root.Children().Clear();
-        _secondChild->_root.Children().Clear();
-        _firstChild->_border.Child(nullptr);
-        _secondChild->_border.Child(nullptr);
+        // Remove all the ui elements of the remaining child. This'll make sure
+        // we can re-attach the TermControl to our Grid.
+        remainingChild->_root.Children().Clear();
+        remainingChild->_border.Child(nullptr);
 
         // Reset our UI:
         _root.Children().Clear();
@@ -1125,17 +1201,8 @@ void Pane::_CloseChild(const bool closeFirst)
     }
     else
     {
-        // Determine which border flag we gave to the child when we first split
-        // it, so that we can take just that flag away from them.
-        Borders clearBorderFlag = Borders::None;
-        if (_splitState == SplitState::Horizontal)
-        {
-            clearBorderFlag = closeFirst ? Borders::Top : Borders::Bottom;
-        }
-        else if (_splitState == SplitState::Vertical)
-        {
-            clearBorderFlag = closeFirst ? Borders::Left : Borders::Right;
-        }
+        // Find what borders need to persist after we close the child
+        auto remainingBorders = _GetCommonBorders();
 
         // First stash away references to the old panes and their tokens
         const auto oldFirstToken = _firstClosedToken;
@@ -1192,13 +1259,9 @@ void Pane::_CloseChild(const bool closeFirst)
         _root.Children().Append(_firstChild->GetRootElement());
         _root.Children().Append(_secondChild->GetRootElement());
 
-        // Take the flag away from the children that they inherited from their
-        // parent, and update their borders to visually match
-        WI_ClearAllFlags(_firstChild->_borders, clearBorderFlag);
-        WI_ClearAllFlags(_secondChild->_borders, clearBorderFlag);
-        _UpdateBorders();
-        _firstChild->_UpdateBorders();
-        _secondChild->_UpdateBorders();
+        // Propagate the new borders down to the children.
+        _borders = remainingBorders;
+        _ApplySplitDefinitions();
 
         // If the closed child was focused, transfer the focus to it's first sibling.
         if (closedChild->_lastActive)
@@ -1757,7 +1820,8 @@ std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Pane::Split(SplitState s
         return { nullptr, nullptr };
     }
 
-    return _Split(splitType, splitSize, profile, control);
+    auto newPane = std::make_shared<Pane>(profile, control);
+    return _Split(splitType, splitSize, newPane);
 }
 
 // Method Description:
@@ -1833,8 +1897,7 @@ SplitState Pane::_convertAutomaticSplitState(const SplitState& splitType) const
 // - The two newly created Panes
 std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Pane::_Split(SplitState splitType,
                                                                      const float splitSize,
-                                                                     const GUID& profile,
-                                                                     const TermControl& control)
+                                                                     std::shared_ptr<Pane> newPane)
 {
     if (splitType == SplitState::None)
     {
@@ -1874,7 +1937,7 @@ std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Pane::_Split(SplitState
     _firstChild->_connectionState = std::exchange(_connectionState, ConnectionState::NotConnected);
     _profile = std::nullopt;
     _control = { nullptr };
-    _secondChild = std::make_shared<Pane>(profile, control);
+    _secondChild = newPane;
 
     _CreateRowColDefinitions();
 
@@ -2551,3 +2614,4 @@ bool Pane::ContainsReadOnly() const
 DEFINE_EVENT(Pane, GotFocus, _GotFocusHandlers, winrt::delegate<std::shared_ptr<Pane>>);
 DEFINE_EVENT(Pane, LostFocus, _LostFocusHandlers, winrt::delegate<std::shared_ptr<Pane>>);
 DEFINE_EVENT(Pane, PaneRaiseBell, _PaneRaiseBellHandlers, winrt::Windows::Foundation::EventHandler<bool>);
+DEFINE_EVENT(Pane, Detached, _PaneDetachedHandlers, winrt::delegate<std::shared_ptr<Pane>>);