Persist window layout on window close

src/cascadia/TerminalApp/AppActionHandlers.cpp

@@ -463,10 +463,12 @@ namespace winrt::TerminalApp::implementation
                         // 1 is important to make sure that the effects of
                         // something like `colortool` are cleared when setting
                         // the scheme.
+                        /*
                         if (controlSettings.GetParent() != nullptr)
                         {
                             parentSettings = controlSettings.GetParent();
                         }
+                        */
 
                         // ApplyColorScheme(nullptr) will clear the old color scheme.
                         controlSettings.ApplyColorScheme(nullptr);

src/cascadia/TerminalApp/Pane.cpp

@@ -71,6 +71,127 @@ Pane::Pane(const GUID& profile, const TermControl& control, const bool lastFocus
     });
 }
 
+// Method Description:
+// - Extract the terminal settings from the current (leaf) pane's control
+//   to be used to create an equivalent control
+// Arguments:
+// - <none>
+// Return Value:
+// - Arguments appropriate for a SplitPane or NewTab action
+NewTerminalArgs Pane::GetTerminalArgsForPane() const
+{
+    // Leaves are the only things that have controls
+    assert(_IsLeaf());
+
+    NewTerminalArgs args{};
+    auto controlSettings = _control.Settings().as<TerminalSettings>();
+
+    args.Profile(controlSettings.ProfileName());
+    args.StartingDirectory(controlSettings.StartingDirectory());
+    args.TabTitle(controlSettings.StartingTitle());
+    args.Commandline(controlSettings.Commandline());
+    args.SuppressApplicationTitle(controlSettings.SuppressApplicationTitle());
+    if (controlSettings.TabColor() || controlSettings.StartingTabColor())
+    {
+
+        til::color c;
+        // StartingTabColor is prioritized over other colors
+        if (controlSettings.StartingTabColor())
+        {
+            c = til::color(controlSettings.StartingTabColor().Value());
+        }
+        else
+        {
+            c = til::color(controlSettings.TabColor().Value());
+        }
+
+        args.TabColor(winrt::Windows::Foundation::IReference<winrt::Windows::UI::Color>(c));
+    }
+
+    if (controlSettings.AppliedColorScheme())
+    {
+        auto name = controlSettings.AppliedColorScheme().Name();
+        args.ColorScheme(name);
+    }
+
+    return args;
+}
+
+// Method Description:
+// - Serializes the state of this tab as a series of commands that can be
+//   executed to recreate it.
+// - This will always result in the right-most child being the focus
+//   after the commands finish executing.
+// Arguments:
+// - <none>
+// Return Value:
+// - A vector of commands and the original root pane for this new tree
+std::pair<std::vector<ActionAndArgs>, std::shared_ptr<Pane>> Pane::BuildStartupActions()
+{
+    // if we are a leaf then all there is to do is defer to the parent.
+    if (_IsLeaf())
+    {
+        return { {}, shared_from_this() };
+    }
+
+    auto buildSplitPane = [&](auto newPane) {
+        ActionAndArgs actionAndArgs;
+        actionAndArgs.Action(ShortcutAction::SplitPane);
+        auto terminalArgs{ newPane->GetTerminalArgsForPane() };
+        SplitPaneArgs args{ SplitType::Manual, _splitState, _desiredSplitPosition, terminalArgs };
+        actionAndArgs.Args(args);
+
+        return actionAndArgs;
+    };
+
+    auto buildMoveFocus = [](auto direction) {
+        MoveFocusArgs args{ direction };
+
+        ActionAndArgs actionAndArgs{};
+        actionAndArgs.Action(ShortcutAction::MoveFocus);
+        actionAndArgs.Args(args);
+
+        return actionAndArgs;
+    };
+
+    // Handle simple case of a single split (a minor optimization for clarity)
+    // Here we just create the second child (by splitting) and return the first
+    // child for the parent to deal with.
+    if (_firstChild->_IsLeaf() && _secondChild->_IsLeaf())
+    {
+        auto actionAndArgs = buildSplitPane(_secondChild);
+        return { { actionAndArgs }, _firstChild };
+    }
+
+    // We now need to execute the commands for each side of the tree
+    auto [a1, p1] = _firstChild->BuildStartupActions();
+    auto [a2, p2] = _secondChild->BuildStartupActions();
+
+    std::vector<ActionAndArgs> actions;
+    actions.reserve(a1.size() + a2.size() + 3);
+
+    // first we make our split
+    auto newSplit = buildSplitPane(p2);
+    actions.push_back(newSplit);
+
+    if (a1.size() > 0)
+    {
+        // Then move to the first child and execute any actions on the left branch
+        // then move back
+        actions.push_back(buildMoveFocus(FocusDirection::PreviousInOrder));
+        actions.insert(actions.end(), a1.begin(), a1.end());
+        actions.push_back(buildMoveFocus(FocusDirection::NextInOrder));
+    }
+
+    // And if there are any commands to run on the right branch do so
+    if (a2.size() > 0)
+    {
+        actions.insert(actions.end(), a2.begin(), a2.end());
+    }
+
+    return { { actions }, p1 };
+}
+
 // Method Description:
 // - Update the size of this pane. Resizes each of our columns so they have the
 //   same relative sizes, given the newSize.

src/cascadia/TerminalApp/Pane.h

@@ -62,6 +62,9 @@ class Pane : public std::enable_shared_from_this<Pane>
     void ClearActive();
     void SetActive();
 
+    std::pair<std::vector<winrt::Microsoft::Terminal::Settings::Model::ActionAndArgs>, std::shared_ptr<Pane>> BuildStartupActions();
+    winrt::Microsoft::Terminal::Settings::Model::NewTerminalArgs GetTerminalArgsForPane() const;
+
     void UpdateSettings(const winrt::Microsoft::Terminal::Settings::Model::TerminalSettingsCreateResult& settings,
                         const GUID& profile);
     void ResizeContent(const winrt::Windows::Foundation::Size& newSize);

src/cascadia/TerminalApp/TerminalPage.cpp

@@ -320,6 +320,19 @@ namespace winrt::TerminalApp::implementation
         if (_startupState == StartupState::NotInitialized)
         {
             _startupState = StartupState::InStartup;
+
+            // If the user selected to save their tab layout, we are the first
+            // window opened, and wt was not run with any other arguments, then
+            // we should use the saved settings.
+            if (_settings.GlobalSettings().PersistTabLayout() && _WindowId == 1 && _startupActions.Size() == 1)
+            {
+                auto actions = ApplicationState::SharedInstance().PersistedTabLayout();
+                if (actions && actions.Size() > 0)
+                {
+                    _startupActions = actions;
+                }
+            }
+
             ProcessStartupActions(_startupActions, true);
 
             // If we were told that the COM server needs to be started to listen for incoming
@@ -1146,6 +1159,50 @@ namespace winrt::TerminalApp::implementation
         return nullptr;
     }
 
+    // Method Description:
+    // - Saves the tab layout to the application state
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void TerminalPage::PersistTabLayout()
+    {
+        std::vector<ActionAndArgs> actions;
+
+        for (auto tab : _tabs)
+        {
+            if (auto terminalTab = _GetTerminalTabImpl(tab))
+            {
+                auto tabActions = terminalTab->BuildStartupActions();
+                actions.insert(actions.end(), tabActions.begin(), tabActions.end());
+            }
+            else if (tab.try_as<SettingsTab>())
+            {
+                ActionAndArgs action;
+                action.Action(ShortcutAction::OpenSettings);
+                OpenSettingsArgs args{ SettingsTarget::SettingsUI };
+                action.Args(args);
+
+                actions.push_back(action);
+            }
+        }
+
+        // if the focused tab was not the last tab, restore that
+        auto idx = _GetFocusedTabIndex();
+        if (idx && idx != _tabs.Size() - 1)
+        {
+            ActionAndArgs action;
+            action.Action(ShortcutAction::SwitchToTab);
+            SwitchToTabArgs switchToTabArgs{ idx.value() };
+            action.Args(switchToTabArgs);
+
+            actions.push_back(action);
+        }
+
+        auto state = ApplicationState::SharedInstance();
+        state.PersistedTabLayout(winrt::single_threaded_vector<ActionAndArgs>(std::move(actions)));
+    }
+
     // Method Description:
     // - Close the terminal app. If there is more
     //   than one tab opened, show a warning dialog.
@@ -1165,6 +1222,11 @@ namespace winrt::TerminalApp::implementation
             }
         }
 
+        if (_settings.GlobalSettings().PersistTabLayout() && _WindowId == 1)
+        {
+            PersistTabLayout();
+        }
+
         _RemoveAllTabs();
     }
 

src/cascadia/TerminalApp/TerminalPage.h

@@ -79,6 +79,8 @@ namespace winrt::TerminalApp::implementation
         bool AlwaysOnTop() const;
 
         void SetStartupActions(std::vector<Microsoft::Terminal::Settings::Model::ActionAndArgs>& actions);
+        void PersistTabLayout();
+
         void SetInboundListener(bool isEmbedding);
         static std::vector<Microsoft::Terminal::Settings::Model::ActionAndArgs> ConvertExecuteCommandlineToActions(const Microsoft::Terminal::Settings::Model::ExecuteCommandlineArgs& args);
 

src/cascadia/TerminalApp/TerminalTab.cpp

@@ -440,6 +440,31 @@ namespace winrt::TerminalApp::implementation
         control.ScrollViewport(::base::ClampAdd(currentOffset, delta));
     }
 
+    // Method Description:
+    // - Serializes the state of this tab as a series of commands that can be
+    //   executed to recreate it.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - A vector of commands
+    std::vector<ActionAndArgs> TerminalTab::BuildStartupActions() const
+    {
+        auto [args, pane] = _rootPane->BuildStartupActions();
+
+        ActionAndArgs newTabAction{};
+        newTabAction.Action(ShortcutAction::NewTab);
+        // _getNewTerminalArgs MUST be called before parsing any other options,
+        // as it might clear those options while finding the commandline
+        NewTabArgs newTabArgs{ pane->GetTerminalArgsForPane() };
+        newTabAction.Args(newTabArgs);
+
+        args.insert(args.begin(), newTabAction);
+
+        // TODO: persist focused pane? zoomed pane?
+
+        return args;
+    }
+
     // Method Description:
     // - Split the focused pane in our tree of panes, and place the
     //   given TermControl into the newly created pane.

src/cascadia/TerminalApp/TerminalTab.h

@@ -84,6 +84,8 @@ namespace winrt::TerminalApp::implementation
         void EnterZoom();
         void ExitZoom();
 
+        std::vector<Microsoft::Terminal::Settings::Model::ActionAndArgs> BuildStartupActions() const;
+
         int GetLeafPaneCount() const noexcept;
 
         void TogglePaneReadOnly();

src/cascadia/TerminalSettingsEditor/Launch.xaml

@@ -133,6 +133,11 @@
                     <ToggleSwitch IsOn="{x:Bind State.Settings.GlobalSettings.StartOnUserLogin, Mode=TwoWay}" />
                 </local:SettingContainer>
 
+                <!--  Retain and Reload Tab Layout  -->
+                <local:SettingContainer x:Uid="Globals_PersistTabLayout">
+                    <ToggleSwitch IsOn="{x:Bind State.Settings.GlobalSettings.PersistTabLayout, Mode=TwoWay}" />
+                </local:SettingContainer>
+
                 <!--  Launch Mode  -->
                 <local:SettingContainer x:Uid="Globals_LaunchMode">
                     <muxc:RadioButtons ItemTemplate="{StaticResource EnumRadioButtonTemplate}"

src/cascadia/TerminalSettingsEditor/Resources/en-US/Resources.resw

@@ -375,6 +375,14 @@
     <value>When enabled, this enables the launch of Windows Terminal at machine startup.</value>
     <comment>A description for what the "start on user login" setting does. Presented near "Globals_StartOnUserLogin.Header".</comment>
   </data>
+  <data name="Globals_PersistTabLayout.Header" xml:space="preserve">
+    <value>Persist terminal tab layout</value>
+    <comment>Header for a control to toggle whether the app should launch when the user's machine starts up, or not.</comment>
+  </data>
+  <data name="Globals_PersistTabLayout.HelpText" xml:space="preserve">
+    <value>When enabled, the tab layout of terminal windows will be saved on close and reloaded on open.</value>
+    <comment>A description for what the "start on user login" setting does. Presented near "Globals_PersistTabLayout.Header".</comment>
+  </data>
   <data name="Globals_AlwaysOnTop.Header" xml:space="preserve">
     <value>Always on top</value>
     <comment>Header for a control to toggle if the app will always be presented on top of other windows, or is treated normally (when disabled).</comment>