move the header around so it's more reasonable

(cherry picked from commit 0c6a353967)

src/cascadia/LocalTests_TerminalApp/TabTests.cpp

@@ -8,7 +8,7 @@
 #include "../TerminalApp/MinMaxCloseControl.h"
 #include "../TerminalApp/TabRowControl.h"
 #include "../TerminalApp/ShortcutActionDispatch.h"
-#include "../TerminalApp/TerminalTab.h"
+#include "../TerminalApp/TabBase.h"
 #include "../TerminalApp/CommandPalette.h"
 #include "../TerminalApp/ContentManager.h"
 #include "CppWinrtTailored.h"

src/cascadia/TerminalApp/AppActionHandlers.cpp

@@ -41,11 +41,11 @@ namespace winrt::TerminalApp::implementation
         }
         return _GetActiveControl();
     }
-    winrt::com_ptr<TerminalTab> TerminalPage::_senderOrFocusedTab(const IInspectable& sender)
+    winrt::com_ptr<TabBase> TerminalPage::_senderOrFocusedTab(const IInspectable& sender)
     {
         if (sender)
         {
-            if (auto tab{ sender.try_as<TerminalApp::TerminalTab>() })
+            if (auto tab{ sender.try_as<TerminalApp::TabBase>() })
             {
                 return _GetTerminalTabImpl(tab);
             }
@@ -1418,7 +1418,7 @@ namespace winrt::TerminalApp::implementation
         args.Handled(true);
     }
 
-    void TerminalPage::_HandleOpenScratchpad(const IInspectable& /*sender*/,
+    void TerminalPage::_HandleOpenScratchpad(const IInspectable& sender,
                                              const ActionEventArgs& args)
     {
         if (Feature_ScratchpadPane::IsEnabled())
@@ -1431,7 +1431,7 @@ namespace winrt::TerminalApp::implementation
             scratchPane->GetRoot().KeyDown({ this, &TerminalPage::_KeyDownHandler });
 
             const auto resultPane = std::make_shared<Pane>(*scratchPane);
-            _SplitPane(_GetFocusedTabImpl(), SplitDirection::Automatic, 0.5f, resultPane);
+            _SplitPane(_senderOrFocusedTab(sender), SplitDirection::Automatic, 0.5f, resultPane);
             args.Handled(true);
         }
     }

src/cascadia/TerminalApp/IPaneContent.idl

@@ -12,6 +12,7 @@ namespace TerminalApp
     interface IPaneContent
     {
         Windows.UI.Xaml.FrameworkElement GetRoot();
+        void UpdateSettings(Microsoft.Terminal.Settings.Model.CascadiaSettings settings);
 
         Windows.Foundation.Size MinimumSize { get; };
 
@@ -19,6 +20,9 @@ namespace TerminalApp
         UInt64 TaskbarState { get; };
         UInt64 TaskbarProgress { get; };
         Boolean ReadOnly { get; };
+        String Icon { get; };
+        Windows.Foundation.IReference<Windows.UI.Color> TabColor { get; };
+        Windows.UI.Xaml.Media.Brush BackgroundBrush { get; };
 
         Microsoft.Terminal.Settings.Model.NewTerminalArgs GetNewTerminalArgs(Boolean asContent);
 

src/cascadia/TerminalApp/Pane.cpp

@@ -1093,6 +1093,29 @@ TermControl Pane::GetLastFocusedTerminalControl()
     return GetTerminalControl();
 }
 
+IPaneContent Pane::GetLastFocusedContent()
+{
+    if (!_IsLeaf())
+    {
+        if (_lastActive)
+        {
+            auto pane = shared_from_this();
+            while (const auto p = pane->_parentChildPath.lock())
+            {
+                if (p->_IsLeaf())
+                {
+                    return p->_content;
+                }
+                pane = p;
+            }
+            // We didn't find our child somehow, they might have closed under us.
+        }
+        return _firstChild->GetLastFocusedContent();
+    }
+
+    return _content;
+}
+
 // Method Description:
 // - Gets the TermControl of this pane. If this Pane is not a leaf this will
 //   return the nullptr;
@@ -1233,7 +1256,10 @@ void Pane::UpdateVisuals()
 void Pane::_Focus()
 {
     GotFocus.raise(shared_from_this(), FocusState::Programmatic);
-    _content.Focus(FocusState::Programmatic);
+    if (const auto& lastContent{ GetLastFocusedContent() })
+    {
+        lastContent.Focus(FocusState::Programmatic);
+    }
 }
 
 // Method Description:
@@ -1272,20 +1298,21 @@ void Pane::_FocusFirstChild()
     }
 }
 
-// Method Description:
-// - Updates the settings of this pane, presuming that it is a leaf.
-// Arguments:
-// - settings: The new TerminalSettings to apply to any matching controls
-// - profile: The profile from which these settings originated.
-// Return Value:
-// - <none>
-void Pane::UpdateSettings(const TerminalSettingsCreateResult& settings, const Profile& profile)
+void Pane::UpdateSettings(const CascadiaSettings& settings, const winrt::TerminalApp::TerminalSettingsCache& cache)
 {
-    assert(_IsLeaf());
-
-    if (const auto& terminalPane{ _getTerminalContent() })
+    if (_content)
     {
-        return terminalPane.UpdateSettings(settings, profile);
+        // We need to do a bit more work here for terminal
+        // panes. They need to know about the profile that was used for
+        // them, and about the focused/unfocused settings.
+        if (const auto& terminalPaneContent{ _content.try_as<TerminalPaneContent>() })
+        {
+            terminalPaneContent.UpdateTerminalSettings(cache);
+        }
+        else
+        {
+            _content.UpdateSettings(settings);
+        }
     }
 }
 
@@ -1911,7 +1938,7 @@ void Pane::_SetupEntranceAnimation()
         auto child = isFirstChild ? _firstChild : _secondChild;
         auto childGrid = child->_root;
         // If we are splitting a parent pane this may be null
-        auto control = child->_content.GetRoot();
+        auto control = child->_content ? child->_content.GetRoot() : nullptr;
         // Build up our animation:
         // * it'll take as long as our duration (200ms)
         // * it'll change the value of our property from 0 to secondSize
@@ -2388,7 +2415,7 @@ std::optional<uint32_t> Pane::Id() noexcept
 
 // Method Description:
 // - Sets this pane's ID
-// - Panes are given IDs upon creation by TerminalTab
+// - Panes are given IDs upon creation by TabBase
 // Arguments:
 // - The number to set this pane's ID to
 void Pane::Id(uint32_t id) noexcept

src/cascadia/TerminalApp/Pane.h

@@ -31,7 +31,7 @@ namespace TerminalAppLocalTests
 
 namespace winrt::TerminalApp::implementation
 {
-    struct TerminalTab;
+    struct TabBase;
 }
 
 enum class Borders : int
@@ -73,6 +73,7 @@ public:
 
     std::shared_ptr<Pane> GetActivePane();
     winrt::Microsoft::Terminal::Control::TermControl GetLastFocusedTerminalControl();
+    winrt::TerminalApp::IPaneContent GetLastFocusedContent();
     winrt::Microsoft::Terminal::Control::TermControl GetTerminalControl() const;
     winrt::Microsoft::Terminal::Settings::Model::Profile GetFocusedProfile();
     bool IsConnectionClosed() const;
@@ -107,8 +108,7 @@ public:
     BuildStartupState BuildStartupActions(uint32_t currentId, uint32_t nextId, const bool asContent = false, const bool asMovePane = false);
     winrt::Microsoft::Terminal::Settings::Model::NewTerminalArgs GetTerminalArgsForPane(const bool asContent = false) const;
 
-    void UpdateSettings(const winrt::Microsoft::Terminal::Settings::Model::TerminalSettingsCreateResult& settings,
-                        const winrt::Microsoft::Terminal::Settings::Model::Profile& profile);
+    void UpdateSettings(const winrt::Microsoft::Terminal::Settings::Model::CascadiaSettings& settings, const winrt::TerminalApp::TerminalSettingsCache& cache);
     bool ResizePane(const winrt::Microsoft::Terminal::Settings::Model::ResizeDirection& direction);
     std::shared_ptr<Pane> NavigateDirection(const std::shared_ptr<Pane> sourcePane,
                                             const winrt::Microsoft::Terminal::Settings::Model::FocusDirection& direction,
@@ -397,6 +397,6 @@ private:
         LayoutSizeNode& operator=(const LayoutSizeNode& other);
     };
 
-    friend struct winrt::TerminalApp::implementation::TerminalTab;
+    friend struct winrt::TerminalApp::implementation::TabBase;
     friend class ::TerminalAppLocalTests::TabTests;
 };

src/cascadia/TerminalApp/ScratchpadContent.cpp

@@ -26,6 +26,11 @@ namespace winrt::TerminalApp::implementation
         _root.Children().Append(_box);
     }
 
+    void ScratchpadContent::UpdateSettings(const CascadiaSettings& /*settings*/)
+    {
+        // Nothing to do.
+    }
+
     winrt::Windows::UI::Xaml::FrameworkElement ScratchpadContent::GetRoot()
     {
         return _root;
@@ -47,4 +52,15 @@ namespace winrt::TerminalApp::implementation
     {
         return nullptr;
     }
+
+    winrt::hstring ScratchpadContent::Icon() const
+    {
+        static constexpr std::wstring_view glyph{ L"\xe70b" }; // QuickNote
+        return winrt::hstring{ glyph };
+    }
+
+    winrt::Windows::UI::Xaml::Media::Brush ScratchpadContent::BackgroundBrush()
+    {
+        return _root.Background();
+    }
 }

src/cascadia/TerminalApp/ScratchpadContent.h

@@ -13,6 +13,8 @@ namespace winrt::TerminalApp::implementation
 
         winrt::Windows::UI::Xaml::FrameworkElement GetRoot();
 
+        void UpdateSettings(const winrt::Microsoft::Terminal::Settings::Model::CascadiaSettings& settings);
+
         winrt::Windows::Foundation::Size MinimumSize();
 
         void Focus(winrt::Windows::UI::Xaml::FocusState reason = winrt::Windows::UI::Xaml::FocusState::Programmatic);
@@ -23,6 +25,9 @@ namespace winrt::TerminalApp::implementation
         uint64_t TaskbarState() { return 0; }
         uint64_t TaskbarProgress() { return 0; }
         bool ReadOnly() { return false; }
+        winrt::hstring Icon() const;
+        Windows::Foundation::IReference<winrt::Windows::UI::Color> TabColor() const noexcept { return nullptr; }
+        winrt::Windows::UI::Xaml::Media::Brush BackgroundBrush();
 
         til::typed_event<> ConnectionStateChanged;
         til::typed_event<IPaneContent> CloseRequested;

src/cascadia/TerminalApp/SettingsPaneContent.cpp

@@ -0,0 +1,84 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#include "pch.h"
+#include "SettingsPaneContent.h"
+#include "Utils.h"
+
+using namespace winrt::Windows::Foundation;
+using namespace winrt::Windows::UI::Xaml;
+using namespace winrt::Microsoft::Terminal::Settings::Model;
+
+#define ASSERT_UI_THREAD() assert(_sui.Dispatcher().HasThreadAccess())
+
+namespace winrt::TerminalApp::implementation
+{
+    SettingsPaneContent::SettingsPaneContent(CascadiaSettings settings)
+    {
+        _sui = winrt::Microsoft::Terminal::Settings::Editor::MainPage{ settings };
+
+        // Stash away the current requested theme of the app. We'll need that in
+        // _BackgroundBrush() to do a theme-aware resource lookup
+        _requestedTheme = settings.GlobalSettings().CurrentTheme().RequestedTheme();
+    }
+
+    void SettingsPaneContent::UpdateSettings(const CascadiaSettings& settings)
+    {
+        ASSERT_UI_THREAD();
+        _sui.UpdateSettings(settings);
+
+        _requestedTheme = settings.GlobalSettings().CurrentTheme().RequestedTheme();
+    }
+
+    winrt::Windows::UI::Xaml::FrameworkElement SettingsPaneContent::GetRoot()
+    {
+        return _sui;
+    }
+    winrt::Windows::Foundation::Size SettingsPaneContent::MinimumSize()
+    {
+        return { 1, 1 };
+    }
+    void SettingsPaneContent::Focus(winrt::Windows::UI::Xaml::FocusState reason)
+    {
+        if (reason != FocusState::Unfocused)
+        {
+            _sui.as<Controls::Page>().Focus(reason);
+        }
+    }
+    void SettingsPaneContent::Close()
+    {
+        CloseRequested.raise(*this, nullptr);
+    }
+
+    NewTerminalArgs SettingsPaneContent::GetNewTerminalArgs(const bool /* asContent */) const
+    {
+        // For now, we're doing a terrible thing in TerminalTab itself to
+        // generate an OpenSettings action manually, without asking for the pane
+        // structure.
+        return nullptr;
+    }
+
+    winrt::hstring SettingsPaneContent::Icon() const
+    {
+        // This is the Setting icon (looks like a gear)
+        static constexpr std::wstring_view glyph{ L"\xE713" };
+        return winrt::hstring{ glyph };
+    }
+
+    Windows::Foundation::IReference<winrt::Windows::UI::Color> SettingsPaneContent::TabColor() const noexcept
+    {
+        return nullptr;
+    }
+
+    winrt::Windows::UI::Xaml::Media::Brush SettingsPaneContent::BackgroundBrush()
+    {
+        // Look up the color we should use for the settings tab item from our
+        // resources. This should only be used for when "terminalBackground" is
+        // requested.
+        static const auto key = winrt::box_value(L"SettingsUiTabBrush");
+        // You can't just do a Application::Current().Resources().TryLookup
+        // lookup, cause the app theme never changes! Do the hacky version
+        // instead.
+        return ThemeLookup(Application::Current().Resources(), _requestedTheme, key).try_as<winrt::Windows::UI::Xaml::Media::Brush>();
+    }
+}

src/cascadia/TerminalApp/SettingsPaneContent.h

@@ -0,0 +1,46 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#pragma once
+#include "winrt/TerminalApp.h"
+#include <LibraryResources.h>
+
+namespace winrt::TerminalApp::implementation
+{
+    class SettingsPaneContent : public winrt::implements<SettingsPaneContent, IPaneContent>
+    {
+    public:
+        SettingsPaneContent(winrt::Microsoft::Terminal::Settings::Model::CascadiaSettings settings);
+
+        void UpdateSettings(const winrt::Microsoft::Terminal::Settings::Model::CascadiaSettings& settings);
+
+        winrt::Windows::UI::Xaml::FrameworkElement GetRoot();
+        winrt::Microsoft::Terminal::Settings::Editor::MainPage SettingsUI() { return _sui; }
+
+        winrt::Windows::Foundation::Size MinimumSize();
+        void Focus(winrt::Windows::UI::Xaml::FocusState reason = winrt::Windows::UI::Xaml::FocusState::Programmatic);
+        void Close();
+        winrt::Microsoft::Terminal::Settings::Model::NewTerminalArgs GetNewTerminalArgs(const bool asContent) const;
+
+        winrt::hstring Title() { return RS_(L"SettingsTab"); }
+        uint64_t TaskbarState() { return 0; }
+        uint64_t TaskbarProgress() { return 0; }
+        bool ReadOnly() { return false; }
+        winrt::hstring Icon() const;
+        Windows::Foundation::IReference<winrt::Windows::UI::Color> TabColor() const noexcept;
+        winrt::Windows::UI::Xaml::Media::Brush BackgroundBrush();
+
+        til::typed_event<> ConnectionStateChanged;
+        til::typed_event<IPaneContent> CloseRequested;
+        til::typed_event<IPaneContent, winrt::TerminalApp::BellEventArgs> BellRequested;
+        til::typed_event<IPaneContent> TitleChanged;
+        til::typed_event<IPaneContent> TabColorChanged;
+        til::typed_event<IPaneContent> TaskbarProgressChanged;
+        til::typed_event<IPaneContent> ReadOnlyChanged;
+        til::typed_event<IPaneContent> FocusRequested;
+
+    private:
+        winrt::Microsoft::Terminal::Settings::Editor::MainPage _sui{ nullptr };
+        winrt::Windows::UI::Xaml::ElementTheme _requestedTheme;
+    };
+}

src/cascadia/TerminalApp/SettingsTab.cpp

@@ -1,131 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-#include "pch.h"
-#include <LibraryResources.h>
-#include "SettingsTab.h"
-#include "SettingsTab.g.cpp"
-#include "Utils.h"
-
-using namespace winrt;
-using namespace winrt::Windows::UI::Xaml;
-using namespace winrt::Windows::UI::Core;
-using namespace winrt::Microsoft::Terminal::Control;
-using namespace winrt::Microsoft::Terminal::Settings::Model;
-using namespace winrt::Microsoft::Terminal::Settings::Editor;
-using namespace winrt::Windows::System;
-
-namespace winrt
-{
-    namespace MUX = Microsoft::UI::Xaml;
-    namespace WUX = Windows::UI::Xaml;
-}
-
-#define ASSERT_UI_THREAD() assert(TabViewItem().Dispatcher().HasThreadAccess())
-
-namespace winrt::TerminalApp::implementation
-{
-    SettingsTab::SettingsTab(MainPage settingsUI,
-                             winrt::Windows::UI::Xaml::ElementTheme requestedTheme)
-    {
-        Content(settingsUI);
-        _requestedTheme = requestedTheme;
-
-        _MakeTabViewItem();
-        _CreateContextMenu();
-        _CreateIcon();
-    }
-
-    void SettingsTab::UpdateSettings(CascadiaSettings settings)
-    {
-        ASSERT_UI_THREAD();
-
-        auto settingsUI{ Content().as<MainPage>() };
-        settingsUI.UpdateSettings(settings);
-
-        // Stash away the current requested theme of the app. We'll need that in
-        // _BackgroundBrush() to do a theme-aware resource lookup
-        _requestedTheme = settings.GlobalSettings().CurrentTheme().RequestedTheme();
-    }
-
-    // Method Description:
-    // - Creates a list of actions that can be run to recreate the state of this tab
-    // Arguments:
-    // - asContent: unused. There's nothing different we need to do when
-    //   serializing the settings tab for moving to another window. If we ever
-    //   really want to support opening the SUI to a specific page, we can
-    //   re-evaluate including that arg in this action then.
-    //  Return Value:
-    // - The list of actions.
-    std::vector<ActionAndArgs> SettingsTab::BuildStartupActions(const bool /*asContent*/) const
-    {
-        ASSERT_UI_THREAD();
-
-        ActionAndArgs action;
-        action.Action(ShortcutAction::OpenSettings);
-        OpenSettingsArgs args{ SettingsTarget::SettingsUI };
-        action.Args(args);
-
-        return std::vector{ std::move(action) };
-    }
-
-    // Method Description:
-    // - Focus the settings UI
-    // Arguments:
-    // - focusState: The FocusState mode by which focus is to be obtained.
-    // Return Value:
-    // - <none>
-    void SettingsTab::Focus(WUX::FocusState focusState)
-    {
-        ASSERT_UI_THREAD();
-
-        _focusState = focusState;
-
-        if (_focusState != FocusState::Unfocused)
-        {
-            Content().as<WUX::Controls::Page>().Focus(focusState);
-        }
-    }
-
-    // Method Description:
-    // - Initializes a TabViewItem for this Tab instance.
-    // Arguments:
-    // - <none>
-    // Return Value:
-    // - <none>
-    void SettingsTab::_MakeTabViewItem()
-    {
-        TabBase::_MakeTabViewItem();
-
-        Title(RS_(L"SettingsTab"));
-        TabViewItem().Header(winrt::box_value(Title()));
-    }
-
-    // Method Description:
-    // - Set the icon on the TabViewItem for this tab.
-    // Arguments:
-    // - <none>
-    // Return Value:
-    // - <none>
-    void SettingsTab::_CreateIcon()
-    {
-        // This is the Setting icon (looks like a gear)
-        static constexpr std::wstring_view glyph{ L"\xE713" };
-
-        // The TabViewItem Icon needs MUX while the IconSourceElement in the CommandPalette needs WUX...
-        Icon(winrt::hstring{ glyph });
-        TabViewItem().IconSource(Microsoft::Terminal::UI::IconPathConverter::IconSourceMUX(glyph, false));
-    }
-
-    winrt::Windows::UI::Xaml::Media::Brush SettingsTab::_BackgroundBrush()
-    {
-        // Look up the color we should use for the settings tab item from our
-        // resources. This should only be used for when "terminalBackground" is
-        // requested.
-        static const auto key = winrt::box_value(L"SettingsUiTabBrush");
-        // You can't just do a Application::Current().Resources().TryLookup
-        // lookup, cause the app theme never changes! Do the hacky version
-        // instead.
-        return ThemeLookup(Application::Current().Resources(), _requestedTheme, key).try_as<winrt::Windows::UI::Xaml::Media::Brush>();
-    }
-}

src/cascadia/TerminalApp/SettingsTab.h

@@ -1,43 +0,0 @@
-/*++
-Copyright (c) Microsoft Corporation
-Licensed under the MIT license.
-
-Module Name:
-- SettingsTab.h
-
-Abstract:
-- The SettingsTab is a tab whose content is a Settings UI control. They can
-  coexist in a TabView with all other types of tabs, like the TerminalTab.
-  There should only be at most one SettingsTab open at any given time.
-
-Author(s):
-- Leon Liang - October 2020
-
---*/
-
-#pragma once
-#include "TabBase.h"
-#include "SettingsTab.g.h"
-
-namespace winrt::TerminalApp::implementation
-{
-    struct SettingsTab : SettingsTabT<SettingsTab, TabBase>
-    {
-    public:
-        SettingsTab(winrt::Microsoft::Terminal::Settings::Editor::MainPage settingsUI,
-                    winrt::Windows::UI::Xaml::ElementTheme requestedTheme);
-
-        void UpdateSettings(Microsoft::Terminal::Settings::Model::CascadiaSettings settings);
-        void Focus(winrt::Windows::UI::Xaml::FocusState focusState) override;
-
-        std::vector<Microsoft::Terminal::Settings::Model::ActionAndArgs> BuildStartupActions(const bool asContent = false) const override;
-
-    private:
-        winrt::Windows::UI::Xaml::ElementTheme _requestedTheme;
-
-        void _MakeTabViewItem() override;
-        void _CreateIcon();
-
-        virtual winrt::Windows::UI::Xaml::Media::Brush _BackgroundBrush() override;
-    };
-}

src/cascadia/TerminalApp/SettingsTab.idl

@@ -1,12 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-import "TabBase.idl";
-
-namespace TerminalApp
-{
-    [default_interface] runtimeclass SettingsTab : TabBase
-    {
-        void UpdateSettings(Microsoft.Terminal.Settings.Model.CascadiaSettings settings);
-    }
-}

src/cascadia/TerminalApp/TabBase.cpp

@@ -25,41 +25,6 @@ namespace winrt
 
 namespace winrt::TerminalApp::implementation
 {
-
-    // Method Description:
-    // - Prepares this tab for being removed from the UI hierarchy
-    void TabBase::Shutdown()
-    {
-        ASSERT_UI_THREAD();
-
-        Content(nullptr);
-    }
-
-    // Method Description:
-    // - Creates a context menu attached to the tab.
-    // Currently contains elements allowing the user to close the selected tab
-    // Arguments:
-    // - <none>
-    // Return Value:
-    // - <none>
-    void TabBase::_CreateContextMenu()
-    {
-        auto weakThis{ get_weak() };
-
-        // Build the menu
-        Controls::MenuFlyout contextMenuFlyout;
-        // GH#5750 - When the context menu is dismissed with ESC, toss the focus
-        // back to our control.
-        contextMenuFlyout.Closed([weakThis](auto&&, auto&&) {
-            if (auto tab{ weakThis.get() })
-            {
-                tab->RequestFocusActiveControl.raise();
-            }
-        });
-        _AppendCloseMenuItems(contextMenuFlyout);
-        TabViewItem().ContextFlyout(contextMenuFlyout);
-    }
-
     // Method Description:
     // - Append the close menu items to the context menu flyout
     // Arguments:
@@ -204,17 +169,6 @@ namespace winrt::TerminalApp::implementation
         _UpdateToolTip();
     }
 
-    // Method Description:
-    // - Creates a text for the title run in the tool tip by returning tab title
-    // Arguments:
-    // - <none>
-    // Return Value:
-    // - The value to populate in the title run of the tool tip
-    winrt::hstring TabBase::_CreateToolTipTitle()
-    {
-        return _Title;
-    }
-
     // Method Description:
     // - Sets tab tool tip to a concatenation of title and key chord
     // Arguments:
@@ -245,46 +199,6 @@ namespace winrt::TerminalApp::implementation
         WUX::Controls::ToolTipService::SetToolTip(TabViewItem(), toolTip);
     }
 
-    // Method Description:
-    // - Initializes a TabViewItem for this Tab instance.
-    // Arguments:
-    // - <none>
-    // Return Value:
-    // - <none>
-    void TabBase::_MakeTabViewItem()
-    {
-        TabViewItem(::winrt::MUX::Controls::TabViewItem{});
-
-        // GH#3609 If the tab was tapped, and no one else was around to handle
-        // it, then ask our parent to toss focus into the active control.
-        TabViewItem().Tapped([weakThis{ get_weak() }](auto&&, auto&&) {
-            if (auto tab{ weakThis.get() })
-            {
-                tab->RequestFocusActiveControl.raise();
-            }
-        });
-
-        // BODGY: When the tab is drag/dropped, the TabView gets a
-        // TabDragStarting. However, the way it is implemented[^1], the
-        // TabViewItem needs either an Item or a Content for the event to
-        // include the correct TabViewItem. Otherwise, it will just return the
-        // first TabViewItem in the TabView with the same Content as the dragged
-        // tab (which, if the Content is null, will be the _first_ tab).
-        //
-        // So here, we'll stick an empty border in, just so that every tab has a
-        // Content which is not equal to the others.
-        //
-        // [^1]: microsoft-ui-xaml/blob/92fbfcd55f05c92ac65569f5d284c5b36492091e/dev/TabView/TabView.cpp#L751-L758
-        TabViewItem().Content(winrt::WUX::Controls::Border{});
-    }
-
-    std::optional<winrt::Windows::UI::Color> TabBase::GetTabColor()
-    {
-        ASSERT_UI_THREAD();
-
-        return std::nullopt;
-    }
-
     void TabBase::ThemeColor(const winrt::Microsoft::Terminal::Settings::Model::ThemeColor& focused,
                              const winrt::Microsoft::Terminal::Settings::Model::ThemeColor& unfocused,
                              const til::color& tabRowColor)

src/cascadia/TerminalApp/TabBase.h

@@ -2,6 +2,8 @@
 // Licensed under the MIT license.
 
 #pragma once
+#include "Pane.h"
+#include "ColorPickupFlyout.h"
 #include "TabBase.g.h"
 
 // fwdecl unittest classes
@@ -15,16 +17,90 @@ namespace winrt::TerminalApp::implementation
     struct TabBase : TabBaseT<TabBase>
     {
     public:
-        virtual void Focus(winrt::Windows::UI::Xaml::FocusState focusState) = 0;
+        TabBase(std::shared_ptr<Pane> rootPane);
+
+        // Called after construction to perform the necessary setup, which relies on weak_ptr
+        void Initialize();
+
+        winrt::Microsoft::Terminal::Control::TermControl GetActiveTerminalControl() const;
+        winrt::Microsoft::Terminal::Settings::Model::Profile GetFocusedProfile() const noexcept;
+        winrt::TerminalApp::IPaneContent GetActiveContent() const;
+
+        void Focus(winrt::Windows::UI::Xaml::FocusState focusState);
+
+        void Scroll(const int delta);
+
+        std::shared_ptr<Pane> DetachRoot();
+        std::shared_ptr<Pane> DetachPane();
+        void AttachPane(std::shared_ptr<Pane> pane);
+
+        void AttachColorPicker(winrt::TerminalApp::ColorPickupFlyout& colorPicker);
+
+        std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> SplitPane(winrt::Microsoft::Terminal::Settings::Model::SplitDirection splitType,
+                                                                          const float splitSize,
+                                                                          std::shared_ptr<Pane> newPane);
+
+        void ToggleSplitOrientation();
+        void UpdateIcon(const winrt::hstring& iconPath, const winrt::Microsoft::Terminal::Settings::Model::IconStyle iconStyle);
+        void HideIcon(const bool hide);
+
+        void ShowBellIndicator(const bool show);
+        void ActivateBellIndicatorTimer();
+
+        float CalcSnappedDimension(const bool widthOrHeight, const float dimension) const;
+        std::optional<winrt::Microsoft::Terminal::Settings::Model::SplitDirection> PreCalculateCanSplit(winrt::Microsoft::Terminal::Settings::Model::SplitDirection splitType,
+                                                                                                        const float splitSize,
+                                                                                                        winrt::Windows::Foundation::Size availableSpace) const;
+
+        void ResizePane(const winrt::Microsoft::Terminal::Settings::Model::ResizeDirection& direction);
+        bool NavigateFocus(const winrt::Microsoft::Terminal::Settings::Model::FocusDirection& direction);
+        bool SwapPane(const winrt::Microsoft::Terminal::Settings::Model::FocusDirection& direction);
+        bool FocusPane(const uint32_t id);
+
+        void UpdateSettings(const winrt::Microsoft::Terminal::Settings::Model::CascadiaSettings& settings, const TerminalApp::TerminalSettingsCache& cache);
+        void UpdateTitle();
+
+        void Shutdown();
+        void ClosePane();
+
+        void SetTabText(winrt::hstring title);
+        winrt::hstring GetTabText() const;
+        void ResetTabText();
+        void ActivateTabRenamer();
+
+        std::optional<winrt::Windows::UI::Color> GetTabColor();
+        void SetRuntimeTabColor(const winrt::Windows::UI::Color& color);
+        void ResetRuntimeTabColor();
+
+        void UpdateZoom(std::shared_ptr<Pane> newFocus);
+        void ToggleZoom();
+        bool IsZoomed();
+        void EnterZoom();
+        void ExitZoom();
+
+        std::vector<Microsoft::Terminal::Settings::Model::ActionAndArgs> BuildStartupActions(const bool asContent = false) const;
+
+        int GetLeafPaneCount() const noexcept;
+
+        void TogglePaneReadOnly();
+        void SetPaneReadOnly(const bool readOnlyState);
+        void ToggleBroadcastInput();
+
+        std::shared_ptr<Pane> GetActivePane() const;
+        winrt::TerminalApp::TaskbarState GetCombinedTaskbarState() const;
+
+        std::shared_ptr<Pane> GetRootPane() const { return _rootPane; }
+
+        winrt::TerminalApp::TerminalTabStatus TabStatus()
+        {
+            return _tabStatus;
+        }
 
-        virtual void Shutdown();
         void SetDispatch(const winrt::TerminalApp::ShortcutActionDispatch& dispatch);
 
         void UpdateTabViewIndex(const uint32_t idx, const uint32_t numTabs);
         void SetActionMap(const Microsoft::Terminal::Settings::Model::IActionMapView& actionMap);
-        virtual std::vector<Microsoft::Terminal::Settings::Model::ActionAndArgs> BuildStartupActions(const bool asContent = false) const = 0;
 
-        virtual std::optional<winrt::Windows::UI::Color> GetTabColor();
         void ThemeColor(const winrt::Microsoft::Terminal::Settings::Model::ThemeColor& focused,
                         const winrt::Microsoft::Terminal::Settings::Model::ThemeColor& unfocused,
                         const til::color& tabRowColor);
@@ -34,6 +110,12 @@ namespace winrt::TerminalApp::implementation
 
         til::event<winrt::delegate<void()>> RequestFocusActiveControl;
 
+        til::typed_event<TerminalApp::TerminalPaneContent> RestartTerminalRequested;
+
+        til::event<winrt::delegate<>> ActivePaneChanged;
+        til::event<winrt::delegate<>> TabRaiseVisualBell;
+        til::typed_event<IInspectable, IInspectable> TaskbarProgressChanged;
+
         til::event<winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable>> Closed;
         til::event<winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable>> CloseRequested;
         til::property_changed_event PropertyChanged;
@@ -64,10 +146,59 @@ namespace winrt::TerminalApp::implementation
 
         Microsoft::Terminal::Settings::Model::TabCloseButtonVisibility _closeButtonVisibility{ Microsoft::Terminal::Settings::Model::TabCloseButtonVisibility::Always };
 
-        virtual void _CreateContextMenu();
-        virtual winrt::hstring _CreateToolTipTitle();
+        static constexpr double HeaderRenameBoxWidthDefault{ 165 };
+        static constexpr double HeaderRenameBoxWidthTitleLength{ std::numeric_limits<double>::infinity() };
 
-        virtual void _MakeTabViewItem();
+        std::shared_ptr<Pane> _rootPane{ nullptr };
+        std::shared_ptr<Pane> _activePane{ nullptr };
+        std::shared_ptr<Pane> _zoomedPane{ nullptr };
+
+        Windows::UI::Xaml::Controls::MenuFlyoutItem _closePaneMenuItem;
+        Windows::UI::Xaml::Controls::MenuFlyoutItem _restartConnectionMenuItem;
+
+        winrt::Microsoft::Terminal::Settings::Model::IconStyle _lastIconStyle;
+        winrt::hstring _lastIconPath{};
+        std::optional<winrt::Windows::UI::Color> _runtimeTabColor{};
+        winrt::TerminalApp::TabHeaderControl _headerControl{};
+        winrt::TerminalApp::TerminalTabStatus _tabStatus{};
+
+        winrt::TerminalApp::ColorPickupFlyout _tabColorPickup{ nullptr };
+        winrt::event_token _colorSelectedToken;
+        winrt::event_token _colorClearedToken;
+        winrt::event_token _pickerClosedToken;
+
+        struct ContentEventTokens
+        {
+            winrt::TerminalApp::IPaneContent::BellRequested_revoker BellRequested;
+            winrt::TerminalApp::IPaneContent::TitleChanged_revoker TitleChanged;
+            winrt::TerminalApp::IPaneContent::TabColorChanged_revoker TabColorChanged;
+            winrt::TerminalApp::IPaneContent::TaskbarProgressChanged_revoker TaskbarProgressChanged;
+            winrt::TerminalApp::IPaneContent::ConnectionStateChanged_revoker ConnectionStateChanged;
+            winrt::TerminalApp::IPaneContent::ReadOnlyChanged_revoker ReadOnlyChanged;
+            winrt::TerminalApp::IPaneContent::FocusRequested_revoker FocusRequested;
+            winrt::TerminalApp::IPaneContent::CloseRequested_revoker CloseRequested;
+
+            // These events literally only apply if the content is a TermControl.
+            winrt::Microsoft::Terminal::Control::TermControl::KeySent_revoker KeySent;
+            winrt::Microsoft::Terminal::Control::TermControl::CharSent_revoker CharSent;
+            winrt::Microsoft::Terminal::Control::TermControl::StringSent_revoker StringSent;
+
+            winrt::TerminalApp::TerminalPaneContent::RestartTerminalRequested_revoker RestartTerminalRequested;
+        };
+        std::unordered_map<uint32_t, ContentEventTokens> _contentEvents;
+
+        winrt::event_token _rootClosedToken{};
+
+        std::vector<uint32_t> _mruPanes;
+        uint32_t _nextPaneId{ 0 };
+
+        bool _receivedKeyDown{ false };
+        bool _iconHidden{ false };
+        bool _changingActivePane{ false };
+
+        winrt::hstring _runtimeTabText{};
+        bool _inRename{ false };
+        winrt::Windows::UI::Xaml::Controls::TextBox::LayoutUpdated_revoker _tabRenameBoxLayoutUpdatedRevoker;
 
         winrt::Windows::UI::Xaml::Controls::MenuFlyoutSubItem _AppendCloseMenuItems(winrt::Windows::UI::Xaml::Controls::MenuFlyout flyout);
         void _EnableCloseMenuItems();
@@ -80,11 +211,53 @@ namespace winrt::TerminalApp::implementation
         void _ApplyTabColorOnUIThread(const winrt::Windows::UI::Color& color);
         void _ClearTabBackgroundColor();
         void _RefreshVisualState();
-        virtual winrt::Windows::UI::Xaml::Media::Brush _BackgroundBrush() = 0;
-
         bool _focused() const noexcept;
         void _updateIsClosable();
 
+        void _Setup();
+
+        SafeDispatcherTimer _bellIndicatorTimer;
+        void _BellIndicatorTimerTick(const Windows::Foundation::IInspectable& sender, const Windows::Foundation::IInspectable& e);
+
+        void _MakeTabViewItem();
+
+        void _UpdateHeaderControlMaxWidth();
+
+        void _CreateContextMenu();
+        winrt::hstring _CreateToolTipTitle();
+
+        void _DetachEventHandlersFromContent(const uint32_t paneId);
+        void _AttachEventHandlersToContent(const uint32_t paneId, const winrt::TerminalApp::IPaneContent& content);
+        void _AttachEventHandlersToPane(std::shared_ptr<Pane> pane);
+
+        void _UpdateActivePane(std::shared_ptr<Pane> pane);
+
+        winrt::hstring _GetActiveTitle() const;
+
+        void _RecalculateAndApplyReadOnly();
+
+        void _UpdateProgressState();
+
+        void _UpdateConnectionClosedState();
+        void _RestartActivePaneConnection();
+
+        void _DuplicateTab();
+
+        winrt::Windows::UI::Xaml::Media::Brush _BackgroundBrush();
+
+        void _addBroadcastHandlers(const winrt::Microsoft::Terminal::Control::TermControl& control, ContentEventTokens& events);
+
+        void _chooseColorClicked(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::RoutedEventArgs& e);
+        void _renameTabClicked(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::RoutedEventArgs& e);
+        void _duplicateTabClicked(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::RoutedEventArgs& e);
+        void _splitTabClicked(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::RoutedEventArgs& e);
+        void _closePaneClicked(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::RoutedEventArgs& e);
+        void _exportTextClicked(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::RoutedEventArgs& e);
+        void _moveTabToNewWindowClicked(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::RoutedEventArgs& e);
+        void _findClicked(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::RoutedEventArgs& e);
+
+        void _bubbleRestartTerminalRequested(TerminalApp::TerminalPaneContent sender, const winrt::Windows::Foundation::IInspectable& args);
+
         friend class ::TerminalAppLocalTests::TabTests;
     };
 }

src/cascadia/TerminalApp/TabBase.idl

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 import "ShortcutActionDispatch.idl";
+import "TerminalTabStatus.idl";
 
 namespace TerminalApp
 {
@@ -11,6 +12,8 @@ namespace TerminalApp
         Boolean ReadOnly { get; };
         Microsoft.Terminal.Settings.Model.TabCloseButtonVisibility CloseButtonVisibility { get; set; };
 
+        TerminalTabStatus TabStatus { get; };
+
         Microsoft.UI.Xaml.Controls.TabViewItem TabViewItem { get; };
         Windows.UI.Xaml.FrameworkElement Content { get; };
 

src/cascadia/TerminalApp/TabManagement.cpp

@@ -19,7 +19,6 @@
 #include "TabRowControl.h"
 #include "ColorHelper.h"
 #include "DebugTapConnection.h"
-#include "SettingsTab.h"
 #include "..\TerminalSettingsModel\FileUtils.h"
 
 #include <shlobj.h>
@@ -96,7 +95,7 @@ namespace winrt::TerminalApp::implementation
     // Arguments:
     // - newTabImpl: the uninitialized tab.
     // - insertPosition: Optional parameter to indicate the position of tab.
-    void TerminalPage::_InitializeTab(winrt::com_ptr<TerminalTab> newTabImpl, uint32_t insertPosition)
+    void TerminalPage::_InitializeTab(winrt::com_ptr<TabBase> newTabImpl, uint32_t insertPosition)
     {
         newTabImpl->Initialize();
 
@@ -171,17 +170,8 @@ namespace winrt::TerminalApp::implementation
         auto tabViewItem = newTabImpl->TabViewItem();
         _tabView.TabItems().InsertAt(insertPosition, tabViewItem);
 
-        // Set this tab's icon to the icon from the user's profile
-        if (const auto profile{ newTabImpl->GetFocusedProfile() })
-        {
-            const auto& icon = profile.EvaluatedIcon();
-            if (!icon.empty())
-            {
-                const auto theme = _settings.GlobalSettings().CurrentTheme();
-                const auto iconStyle = (theme && theme.Tab()) ? theme.Tab().IconStyle() : IconStyle::Default;
-                newTabImpl->UpdateIcon(icon, iconStyle);
-            }
-        }
+        // Set this tab's icon to the icon from the content
+        _UpdateTabIcon(*newTabImpl);
 
         tabViewItem.PointerReleased({ this, &TerminalPage::_OnTabClick });
 
@@ -226,13 +216,15 @@ namespace winrt::TerminalApp::implementation
     // Arguments:
     // - pane: The pane to use as the root.
     // - insertPosition: Optional parameter to indicate the position of tab.
-    void TerminalPage::_CreateNewTabFromPane(std::shared_ptr<Pane> pane, uint32_t insertPosition)
+    TerminalApp::TabBase TerminalPage::_CreateNewTabFromPane(std::shared_ptr<Pane> pane, uint32_t insertPosition)
     {
         if (pane)
         {
-            auto newTabImpl = winrt::make_self<TerminalTab>(pane);
+            auto newTabImpl = winrt::make_self<TabBase>(pane);
             _InitializeTab(newTabImpl, insertPosition);
+            return *newTabImpl;
         }
+        return nullptr;
     }
 
     // Method Description:
@@ -240,13 +232,15 @@ namespace winrt::TerminalApp::implementation
     //   tab's icon to that icon.
     // Arguments:
     // - tab: the Tab to update the title for.
-    void TerminalPage::_UpdateTabIcon(TerminalTab& tab)
+    void TerminalPage::_UpdateTabIcon(TabBase& tab)
     {
-        if (const auto profile = tab.GetFocusedProfile())
+        if (const auto content{ tab.GetActiveContent() })
         {
+            const auto& icon{ content.Icon() };
             const auto theme = _settings.GlobalSettings().CurrentTheme();
             const auto iconStyle = (theme && theme.Tab()) ? theme.Tab().IconStyle() : IconStyle::Default;
-            tab.UpdateIcon(profile.EvaluatedIcon(), iconStyle);
+
+            tab.UpdateIcon(icon, iconStyle);
         }
     }
 
@@ -296,7 +290,7 @@ namespace winrt::TerminalApp::implementation
     // - Duplicates specified tab
     // Arguments:
     // - tab: tab to duplicate
-    void TerminalPage::_DuplicateTab(const TerminalTab& tab)
+    void TerminalPage::_DuplicateTab(const TabBase& tab)
     {
         try
         {
@@ -329,7 +323,7 @@ namespace winrt::TerminalApp::implementation
     // - Exports the content of the Terminal Buffer inside the tab
     // Arguments:
     // - tab: tab to export
-    winrt::fire_and_forget TerminalPage::_ExportTab(const TerminalTab& tab, winrt::hstring filepath)
+    winrt::fire_and_forget TerminalPage::_ExportTab(const TabBase& tab, winrt::hstring filepath)
     {
         // This will be used to set up the file picker "filter", to select .txt
         // files by default.
@@ -667,7 +661,7 @@ namespace winrt::TerminalApp::implementation
     // Method Description:
     // - returns a com_ptr to the currently focused tab implementation. This might return null,
     //   so make sure to check the result!
-    winrt::com_ptr<TerminalTab> TerminalPage::_GetFocusedTabImpl() const noexcept
+    winrt::com_ptr<TabBase> TerminalPage::_GetFocusedTabImpl() const noexcept
     {
         if (auto tab{ _GetFocusedTab() })
         {
@@ -800,14 +794,6 @@ namespace winrt::TerminalApp::implementation
                 }
             }
         }
-        else if (auto index{ _GetFocusedTabIndex() })
-        {
-            const auto tab{ _tabs.GetAt(*index) };
-            if (tab.try_as<TerminalApp::SettingsTab>())
-            {
-                _HandleCloseTabRequested(tab);
-            }
-        }
     }
 
     // Method Description:
@@ -815,7 +801,7 @@ namespace winrt::TerminalApp::implementation
     // Arguments:
     // - weakTab: weak reference to the tab that the pane belongs to.
     // - paneIds: collection of the IDs of the panes that are marked for removal.
-    void TerminalPage::_ClosePanes(weak_ref<TerminalTab> weakTab, std::vector<uint32_t> paneIds)
+    void TerminalPage::_ClosePanes(weak_ref<TabBase> weakTab, std::vector<uint32_t> paneIds)
     {
         if (auto strongTab{ weakTab.get() })
         {

src/cascadia/TerminalApp/TabPaletteItem.cpp

@@ -3,7 +3,7 @@
 
 #include "pch.h"
 #include "TabPaletteItem.h"
-#include "TerminalTab.h"
+#include "TabBase.h"
 #include <LibraryResources.h>
 
 #include "TabPaletteItem.g.cpp"
@@ -43,7 +43,7 @@ namespace winrt::TerminalApp::implementation
             }
         });
 
-        if (const auto terminalTab{ tab.try_as<winrt::TerminalApp::TerminalTab>() })
+        if (const auto terminalTab{ tab.try_as<winrt::TerminalApp::TabBase>() })
         {
             const auto status = terminalTab.TabStatus();
             TabStatus(status);

src/cascadia/TerminalApp/TerminalAppLib.vcxproj

@@ -88,9 +88,6 @@
       <DependentUpon>PaletteItemTemplateSelector.idl</DependentUpon>
       <SubType>Code</SubType>
     </ClInclude>
-    <ClInclude Include="SettingsTab.h">
-      <DependentUpon>SettingsTab.idl</DependentUpon>
-    </ClInclude>
     <ClInclude Include="PaletteItem.h" />
     <ClInclude Include="TabBase.h">
       <DependentUpon>TabBase.idl</DependentUpon>
@@ -99,9 +96,6 @@
     <ClInclude Include="TaskbarState.h">
       <DependentUpon>TaskbarState.idl</DependentUpon>
     </ClInclude>
-    <ClInclude Include="TerminalTab.h">
-      <DependentUpon>TerminalTab.idl</DependentUpon>
-    </ClInclude>
     <ClInclude Include="TerminalPage.h">
       <DependentUpon>TerminalPage.xaml</DependentUpon>
       <SubType>Code</SubType>
@@ -164,7 +158,13 @@
     <ClInclude Include="ScratchpadContent.h">
       <DependentUpon>TerminalPaneContent.idl</DependentUpon>
     </ClInclude>
+    <ClInclude Include="SettingsPaneContent.h">
+      <DependentUpon>TerminalPaneContent.idl</DependentUpon>
+    </ClInclude>
     <ClInclude Include="Toast.h" />
+    <ClInclude Include="TerminalSettingsCache.h">
+      <DependentUpon>TerminalSettingsCache.idl</DependentUpon>
+    </ClInclude>
     <ClInclude Include="SuggestionsControl.h">
       <DependentUpon>SuggestionsControl.xaml</DependentUpon>
     </ClInclude>
@@ -185,9 +185,6 @@
       <DependentUpon>PaletteItemTemplateSelector.idl</DependentUpon>
       <SubType>Code</SubType>
     </ClCompile>
-    <ClCompile Include="SettingsTab.cpp">
-      <DependentUpon>SettingsTab.idl</DependentUpon>
-    </ClCompile>
     <ClCompile Include="PaletteItem.cpp" />
     <ClCompile Include="TabBase.cpp">
       <DependentUpon>TabBase.idl</DependentUpon>
@@ -197,7 +194,7 @@
       <DependentUpon>TaskbarState.idl</DependentUpon>
     </ClCompile>
     <ClCompile Include="TerminalTab.cpp">
-      <DependentUpon>TerminalTab.idl</DependentUpon>
+      <DependentUpon>TabBase.idl</DependentUpon>
     </ClCompile>
     <ClCompile Include="TerminalPage.cpp">
       <DependentUpon>TerminalPage.xaml</DependentUpon>
@@ -272,10 +269,16 @@
       <DependentUpon>TerminalPaneContent.idl</DependentUpon>
     </ClCompile>
     <ClCompile Include="ScratchpadContent.cpp">
-      <DependentUpon>ScratchpadContent.idl</DependentUpon>
+      <DependentUpon>TerminalPaneContent.idl</DependentUpon>
+    </ClCompile>
+    <ClCompile Include="SettingsPaneContent.cpp">
+      <DependentUpon>TerminalPaneContent.idl</DependentUpon>
     </ClCompile>
     <ClCompile Include="$(GeneratedFilesDir)module.g.cpp" />
     <ClCompile Include="Toast.cpp" />
+    <ClCompile Include="TerminalSettingsCache.cpp">
+      <DependentUpon>TerminalSettingsCache.idl</DependentUpon>
+    </ClCompile>
     <ClCompile Include="SuggestionsControl.cpp">
       <DependentUpon>SuggestionsControl.xaml</DependentUpon>
     </ClCompile>
@@ -295,7 +298,6 @@
     <Midl Include="PaletteItemTemplateSelector.idl">
       <SubType>Designer</SubType>
     </Midl>
-    <Midl Include="SettingsTab.idl" />
     <Midl Include="PaletteItem.idl" />
     <Midl Include="ShortcutActionDispatch.idl" />
     <Midl Include="AppKeyBindings.idl" />
@@ -308,7 +310,6 @@
     <Midl Include="TabBase.idl" />
     <Midl Include="TabPaletteItem.idl" />
     <Midl Include="TaskbarState.idl" />
-    <Midl Include="TerminalTab.idl" />
     <Midl Include="TerminalPage.idl">
       <DependentUpon>TerminalPage.xaml</DependentUpon>
       <SubType>Code</SubType>
@@ -348,6 +349,7 @@
     <Midl Include="FilteredCommand.idl" />
     <Midl Include="IPaneContent.idl" />
     <Midl Include="TerminalPaneContent.idl" />
+    <Midl Include="TerminalSettingsCache.idl" />
   </ItemGroup>
   <!-- ========================= Misc Files ======================== -->
   <ItemGroup>

src/cascadia/TerminalApp/TerminalAppLib.vcxproj.filters

@@ -24,9 +24,6 @@
     <ClCompile Include="Tab.cpp">
       <Filter>tab</Filter>
     </ClCompile>
-    <ClCompile Include="SettingsTab.cpp">
-      <Filter>tab</Filter>
-    </ClCompile>
     <ClCompile Include="FilteredCommand.cpp">
       <Filter>commandPalette</Filter>
     </ClCompile>
@@ -64,9 +61,6 @@
     <ClInclude Include="Tab.h">
       <Filter>tab</Filter>
     </ClInclude>
-    <ClInclude Include="SettingsTab.h">
-      <Filter>tab</Filter>
-    </ClInclude>
     <ClInclude Include="FilteredCommand.h">
       <Filter>commandPalette</Filter>
     </ClInclude>
@@ -98,6 +92,7 @@
     <Midl Include="ShortcutActionDispatch.idl">
       <Filter>settings</Filter>
     </Midl>
+    <Midl Include="IDirectKeyListener.idl" />
     <Midl Include="SettingsTab.idl">
       <Filter>tab</Filter>
     </Midl>

src/cascadia/TerminalApp/TerminalPage.cpp

@@ -21,7 +21,7 @@
 #include "App.h"
 #include "ColorHelper.h"
 #include "DebugTapConnection.h"
-#include "SettingsTab.h"
+#include "SettingsPaneContent.h"
 #include "TabRowControl.h"
 #include "Utils.h"
 
@@ -1620,7 +1620,7 @@ namespace winrt::TerminalApp::implementation
     //   TitleChanged event.
     // Arguments:
     // - tab: the Tab to update the title for.
-    void TerminalPage::_UpdateTitle(const TerminalTab& tab)
+    void TerminalPage::_UpdateTitle(const TabBase& tab)
     {
         auto newTabTitle = tab.Title();
 
@@ -1697,7 +1697,7 @@ namespace winrt::TerminalApp::implementation
     //    * the Color{Selected,Cleared} events to change the color of a tab.
     // Arguments:
     // - hostingTab: The Tab that's hosting this TermControl instance
-    void TerminalPage::_RegisterTabEvents(TerminalTab& hostingTab)
+    void TerminalPage::_RegisterTabEvents(TabBase& hostingTab)
     {
         auto weakTab{ hostingTab.get_weak() };
         auto weakThis{ get_weak() };
@@ -2149,13 +2149,10 @@ namespace winrt::TerminalApp::implementation
 
     void TerminalPage::_DetachTabFromWindow(const winrt::com_ptr<TabBase>& tab)
     {
-        if (const auto terminalTab = tab.try_as<TerminalTab>())
+        // Detach the root pane, which will act like the whole tab got detached.
+        if (const auto rootPane = tab->GetRootPane())
         {
-            // Detach the root pane, which will act like the whole tab got detached.
-            if (const auto rootPane = terminalTab->GetRootPane())
-            {
-                _DetachPaneFromWindow(rootPane);
-            }
+            _DetachPaneFromWindow(rootPane);
         }
     }
 
@@ -2183,7 +2180,7 @@ namespace winrt::TerminalApp::implementation
         RequestMoveContent.raise(*this, *request);
     }
 
-    bool TerminalPage::_MoveTab(winrt::com_ptr<TerminalTab> tab, MoveTabArgs args)
+    bool TerminalPage::_MoveTab(winrt::com_ptr<TabBase> tab, MoveTabArgs args)
     {
         if (!tab)
         {
@@ -2324,7 +2321,7 @@ namespace winrt::TerminalApp::implementation
     // - splitDirection: one value from the TerminalApp::SplitDirection enum, indicating how the
     //   new pane should be split from its parent.
     // - splitSize: the size of the split
-    void TerminalPage::_SplitPane(const winrt::com_ptr<TerminalTab>& tab,
+    void TerminalPage::_SplitPane(const winrt::com_ptr<TabBase>& tab,
                                   const SplitDirection splitDirection,
                                   const float splitSize,
                                   std::shared_ptr<Pane> newPane)
@@ -2358,6 +2355,12 @@ namespace winrt::TerminalApp::implementation
             }
         }
 
+        // For now, prevent splitting the _settingsTab. We can always revisit this later.
+        if (*activeTab == _settingsTab)
+        {
+            return;
+        }
+
         // If the caller is calling us with the return value of _MakePane
         // directly, it's possible that nullptr was returned, if the connections
         // was supposed to be launched in an elevated window. In that case, do
@@ -3283,50 +3286,18 @@ namespace winrt::TerminalApp::implementation
 
         // Refresh UI elements
 
-        // Mapping by GUID isn't _excellent_ because the defaults profile doesn't have a stable GUID; however,
-        // when we stabilize its guid this will become fully safe.
-        std::unordered_map<winrt::guid, std::pair<Profile, TerminalSettingsCreateResult>> profileGuidSettingsMap;
-        const auto profileDefaults{ _settings.ProfileDefaults() };
-        const auto allProfiles{ _settings.AllProfiles() };
-
-        profileGuidSettingsMap.reserve(allProfiles.Size() + 1);
-
-        // Include the Defaults profile for consideration
-        profileGuidSettingsMap.insert_or_assign(profileDefaults.Guid(), std::pair{ profileDefaults, nullptr });
-        for (const auto& newProfile : allProfiles)
-        {
-            // Avoid creating a TerminalSettings right now. They're not totally cheap, and we suspect that users with many
-            // panes may not be using all of their profiles at the same time. Lazy evaluation is king!
-            profileGuidSettingsMap.insert_or_assign(newProfile.Guid(), std::pair{ newProfile, nullptr });
-        }
+        // Recreate the TerminalSettings cache here. We'll use that as we're
+        // updating terminal panes, so that we don't have to build a _new_
+        // TerminalSettings for every profile we update - we can just look them
+        // up the previous ones we built.
+        _terminalSettingsCache = TerminalApp::TerminalSettingsCache{ _settings, *_bindings };
 
         for (const auto& tab : _tabs)
         {
             if (auto terminalTab{ _GetTerminalTabImpl(tab) })
             {
-                terminalTab->UpdateSettings();
-
-                // Manually enumerate the panes in each tab; this will let us recycle TerminalSettings
-                // objects but only have to iterate one time.
-                terminalTab->GetRootPane()->WalkTree([&](auto&& pane) {
-                    if (const auto profile{ pane->GetProfile() })
-                    {
-                        const auto found{ profileGuidSettingsMap.find(profile.Guid()) };
-                        // GH#2455: If there are any panes with controls that had been
-                        // initialized with a Profile that no longer exists in our list of
-                        // profiles, we'll leave it unmodified. The profile doesn't exist
-                        // anymore, so we can't possibly update its settings.
-                        if (found != profileGuidSettingsMap.cend())
-                        {
-                            auto& pair{ found->second };
-                            if (!pair.second)
-                            {
-                                pair.second = TerminalSettings::CreateWithProfile(_settings, pair.first, *_bindings);
-                            }
-                            pane->UpdateSettings(pair.second, pair.first);
-                        }
-                    }
-                });
+                // Let the tab know that there are new settings. It's up to each content to decide what to do with them.
+                terminalTab->UpdateSettings(_settings, _terminalSettingsCache);
 
                 // Update the icon of the tab for the currently focused profile in that tab.
                 // Only do this for TerminalTabs. Other types of tabs won't have multiple panes
@@ -3336,10 +3307,6 @@ namespace winrt::TerminalApp::implementation
                 // Force the TerminalTab to re-grab its currently active control's title.
                 terminalTab->UpdateTitle();
             }
-            else if (auto settingsTab = tab.try_as<TerminalApp::SettingsTab>())
-            {
-                settingsTab.UpdateSettings(_settings);
-            }
 
             auto tabImpl{ winrt::get_self<TabBase>(tab) };
             tabImpl->SetActionMap(_settings.ActionMap());
@@ -3543,7 +3510,7 @@ namespace winrt::TerminalApp::implementation
     // - tab: the tab where the search box should be created
     // Return Value:
     // - <none>
-    void TerminalPage::_Find(const TerminalTab& tab)
+    void TerminalPage::_Find(const TabBase& tab)
     {
         if (const auto& control{ tab.GetActiveTerminalControl() })
         {
@@ -3901,7 +3868,10 @@ namespace winrt::TerminalApp::implementation
                 }
             }
 
-            winrt::Microsoft::Terminal::Settings::Editor::MainPage sui{ _settings };
+            // Create the SUI pane content
+            auto settingsContent{ winrt::make_self<SettingsPaneContent>(_settings) };
+            auto sui = settingsContent->SettingsUI();
+
             if (_hostingHwnd)
             {
                 sui.SetHostingWindow(reinterpret_cast<uint64_t>(*_hostingHwnd));
@@ -3917,54 +3887,9 @@ namespace winrt::TerminalApp::implementation
                 }
             });
 
-            auto newTabImpl = winrt::make_self<SettingsTab>(sui, _settings.GlobalSettings().CurrentTheme().RequestedTheme());
-
-            // Add the new tab to the list of our tabs.
-            _tabs.Append(*newTabImpl);
-            _mruTabs.Append(*newTabImpl);
-
-            newTabImpl->SetDispatch(*_actionDispatch);
-            newTabImpl->SetActionMap(_settings.ActionMap());
-
-            // Give the tab its index in the _tabs vector so it can manage its own SwitchToTab command.
-            _UpdateTabIndices();
-
-            // Don't capture a strong ref to the tab. If the tab is removed as this
-            // is called, we don't really care anymore about handling the event.
-            auto weakTab = make_weak(newTabImpl);
-
-            auto tabViewItem = newTabImpl->TabViewItem();
-            _tabView.TabItems().Append(tabViewItem);
-
-            tabViewItem.PointerPressed({ this, &TerminalPage::_OnTabClick });
-
-            // When the tab requests close, try to close it (prompt for approval, if required)
-            newTabImpl->CloseRequested([weakTab, weakThis{ get_weak() }](auto&& /*s*/, auto&& /*e*/) {
-                auto page{ weakThis.get() };
-                auto tab{ weakTab.get() };
-
-                if (page && tab)
-                {
-                    page->_HandleCloseTabRequested(*tab);
-                }
-            });
-
-            // When the tab is closed, remove it from our list of tabs.
-            newTabImpl->Closed([weakTab, weakThis{ get_weak() }](auto&& /*s*/, auto&& /*e*/) {
-                const auto page = weakThis.get();
-                const auto tab = weakTab.get();
-
-                if (page && tab)
-                {
-                    page->_RemoveTab(*tab);
-                }
-            });
-
-            _settingsTab = *newTabImpl;
-
-            // This kicks off TabView::SelectionChanged, in response to which
-            // we'll attach the terminal's Xaml control to the Xaml root.
-            _tabView.SelectedItem(tabViewItem);
+            // Create the tab
+            auto resultPane = std::make_shared<Pane>(*settingsContent);
+            _settingsTab = _CreateNewTabFromPane(resultPane);
         }
         else
         {
@@ -3980,18 +3905,11 @@ namespace winrt::TerminalApp::implementation
     // Return Value:
     // - If the tab is a TerminalTab, a com_ptr to the implementation type.
     //   If the tab is not a TerminalTab, nullptr
-    winrt::com_ptr<TerminalTab> TerminalPage::_GetTerminalTabImpl(const TerminalApp::TabBase& tab)
+    winrt::com_ptr<TabBase> TerminalPage::_GetTerminalTabImpl(const TerminalApp::TabBase& tab)
     {
-        if (auto terminalTab = tab.try_as<TerminalApp::TerminalTab>())
-        {
-            winrt::com_ptr<TerminalTab> tabImpl;
-            tabImpl.copy_from(winrt::get_self<TerminalTab>(terminalTab));
-            return tabImpl;
-        }
-        else
-        {
-            return nullptr;
-        }
+        winrt::com_ptr<TabBase> tabImpl;
+        tabImpl.copy_from(winrt::get_self<TabBase>(tab));
+        return tabImpl;
     }
 
     // Method Description:
@@ -4583,13 +4501,15 @@ namespace winrt::TerminalApp::implementation
         til::color bgColor = backgroundSolidBrush.Color();
 
         Media::Brush terminalBrush{ nullptr };
-        if (const auto& control{ _GetActiveControl() })
+        if (const auto tab{ _GetFocusedTabImpl() })
         {
-            terminalBrush = control.BackgroundBrush();
-        }
-        else if (const auto& settingsTab{ _GetFocusedTab().try_as<TerminalApp::SettingsTab>() })
-        {
-            terminalBrush = settingsTab.Content().try_as<Settings::Editor::MainPage>().BackgroundBrush();
+            if (const auto& pane{ tab->GetActivePane() })
+            {
+                if (const auto& lastContent{ pane->GetLastFocusedContent() })
+                {
+                    terminalBrush = lastContent.BackgroundBrush();
+                }
+            }
         }
 
         if (_settings.GlobalSettings().UseAcrylicInTabRow())

src/cascadia/TerminalApp/TerminalPage.h

@@ -4,7 +4,7 @@
 #pragma once
 
 #include "TerminalPage.g.h"
-#include "TerminalTab.h"
+#include "TabBase.h"
 #include "AppKeyBindings.h"
 #include "AppCommandlineArgs.h"
 #include "LastTabClosedEventArgs.g.h"
@@ -219,11 +219,11 @@ namespace winrt::TerminalApp::implementation
 
         Windows::Foundation::Collections::IObservableVector<TerminalApp::TabBase> _tabs;
         Windows::Foundation::Collections::IObservableVector<TerminalApp::TabBase> _mruTabs;
-        static winrt::com_ptr<TerminalTab> _GetTerminalTabImpl(const TerminalApp::TabBase& tab);
+        static winrt::com_ptr<TabBase> _GetTerminalTabImpl(const TerminalApp::TabBase& tab);
 
         void _UpdateTabIndices();
 
-        TerminalApp::SettingsTab _settingsTab{ nullptr };
+        TerminalApp::TabBase _settingsTab{ nullptr };
 
         bool _isInFocusMode{ false };
         bool _isFullscreen{ false };
@@ -271,6 +271,8 @@ namespace winrt::TerminalApp::implementation
 
         TerminalApp::ContentManager _manager{ nullptr };
 
+        TerminalApp::TerminalSettingsCache _terminalSettingsCache{ nullptr };
+
         struct StashedDragData
         {
             winrt::com_ptr<winrt::TerminalApp::implementation::TabBase> draggedTab{ nullptr };
@@ -302,7 +304,7 @@ namespace winrt::TerminalApp::implementation
 
         void _OpenNewTabDropdown();
         HRESULT _OpenNewTab(const Microsoft::Terminal::Settings::Model::NewTerminalArgs& newTerminalArgs);
-        void _CreateNewTabFromPane(std::shared_ptr<Pane> pane, uint32_t insertPosition = -1);
+        TerminalApp::TabBase _CreateNewTabFromPane(std::shared_ptr<Pane> pane, uint32_t insertPosition = -1);
 
         std::wstring _evaluatePathForCwd(std::wstring_view path);
 
@@ -325,25 +327,25 @@ namespace winrt::TerminalApp::implementation
         void _HookupKeyBindings(const Microsoft::Terminal::Settings::Model::IActionMapView& actionMap) noexcept;
         void _RegisterActionCallbacks();
 
-        void _UpdateTitle(const TerminalTab& tab);
-        void _UpdateTabIcon(TerminalTab& tab);
+        void _UpdateTitle(const TabBase& tab);
+        void _UpdateTabIcon(TabBase& tab);
         void _UpdateTabView();
         void _UpdateTabWidthMode();
         void _SetBackgroundImage(const winrt::Microsoft::Terminal::Settings::Model::IAppearanceConfig& newAppearance);
 
         void _DuplicateFocusedTab();
-        void _DuplicateTab(const TerminalTab& tab);
+        void _DuplicateTab(const TabBase& tab);
 
-        winrt::fire_and_forget _ExportTab(const TerminalTab& tab, winrt::hstring filepath);
+        winrt::fire_and_forget _ExportTab(const TabBase& tab, winrt::hstring filepath);
 
         winrt::Windows::Foundation::IAsyncAction _HandleCloseTabRequested(winrt::TerminalApp::TabBase tab);
         void _CloseTabAtIndex(uint32_t index);
         void _RemoveTab(const winrt::TerminalApp::TabBase& tab);
         winrt::fire_and_forget _RemoveTabs(const std::vector<winrt::TerminalApp::TabBase> tabs);
 
-        void _InitializeTab(winrt::com_ptr<TerminalTab> newTabImpl, uint32_t insertPosition = -1);
+        void _InitializeTab(winrt::com_ptr<TabBase> newTabImpl, uint32_t insertPosition = -1);
         void _RegisterTerminalEvents(Microsoft::Terminal::Control::TermControl term);
-        void _RegisterTabEvents(TerminalTab& hostingTab);
+        void _RegisterTabEvents(TabBase& hostingTab);
 
         void _DismissTabContextMenus();
         void _FocusCurrentTab(const bool focusAlways);
@@ -355,7 +357,7 @@ namespace winrt::TerminalApp::implementation
         bool _MoveFocus(const Microsoft::Terminal::Settings::Model::FocusDirection& direction);
         bool _SwapPane(const Microsoft::Terminal::Settings::Model::FocusDirection& direction);
         bool _MovePane(const Microsoft::Terminal::Settings::Model::MovePaneArgs args);
-        bool _MoveTab(winrt::com_ptr<TerminalTab> tab, const Microsoft::Terminal::Settings::Model::MoveTabArgs args);
+        bool _MoveTab(winrt::com_ptr<TabBase> tab, const Microsoft::Terminal::Settings::Model::MoveTabArgs args);
 
         template<typename F>
         bool _ApplyToActiveControls(F f)
@@ -381,19 +383,19 @@ namespace winrt::TerminalApp::implementation
         std::optional<uint32_t> _GetFocusedTabIndex() const noexcept;
         std::optional<uint32_t> _GetTabIndex(const TerminalApp::TabBase& tab) const noexcept;
         TerminalApp::TabBase _GetFocusedTab() const noexcept;
-        winrt::com_ptr<TerminalTab> _GetFocusedTabImpl() const noexcept;
+        winrt::com_ptr<TabBase> _GetFocusedTabImpl() const noexcept;
         TerminalApp::TabBase _GetTabByTabViewItem(const Microsoft::UI::Xaml::Controls::TabViewItem& tabViewItem) const noexcept;
 
         void _HandleClosePaneRequested(std::shared_ptr<Pane> pane);
         winrt::fire_and_forget _SetFocusedTab(const winrt::TerminalApp::TabBase tab);
         winrt::fire_and_forget _CloseFocusedPane();
-        void _ClosePanes(weak_ref<TerminalTab> weakTab, std::vector<uint32_t> paneIds);
+        void _ClosePanes(weak_ref<TabBase> weakTab, std::vector<uint32_t> paneIds);
         winrt::Windows::Foundation::IAsyncOperation<bool> _PaneConfirmCloseReadOnly(std::shared_ptr<Pane> pane);
         void _AddPreviouslyClosedPaneOrTab(std::vector<Microsoft::Terminal::Settings::Model::ActionAndArgs>&& args);
 
         void _Scroll(ScrollDirection scrollDirection, const Windows::Foundation::IReference<uint32_t>& rowsToScroll);
 
-        void _SplitPane(const winrt::com_ptr<TerminalTab>& tab,
+        void _SplitPane(const winrt::com_ptr<TabBase>& tab,
                         const Microsoft::Terminal::Settings::Model::SplitDirection splitType,
                         const float splitSize,
                         std::shared_ptr<Pane> newPane);
@@ -438,7 +440,7 @@ namespace winrt::TerminalApp::implementation
         void _OnCommandLineExecutionRequested(const IInspectable& sender, const winrt::hstring& commandLine);
         void _OnSwitchToTabRequested(const IInspectable& sender, const winrt::TerminalApp::TabBase& tab);
 
-        void _Find(const TerminalTab& tab);
+        void _Find(const TabBase& tab);
 
         winrt::Microsoft::Terminal::Control::TermControl _CreateNewControlAndContent(const winrt::Microsoft::Terminal::Settings::Model::TerminalSettingsCreateResult& settings,
                                                                                      const winrt::Microsoft::Terminal::TerminalConnection::ITerminalConnection& connection);
@@ -537,7 +539,7 @@ namespace winrt::TerminalApp::implementation
         winrt::Windows::UI::Xaml::Controls::MenuFlyout _CreateRunAsAdminFlyout(int profileIndex);
 
         winrt::Microsoft::Terminal::Control::TermControl _senderOrActiveControl(const winrt::Windows::Foundation::IInspectable& sender);
-        winrt::com_ptr<TerminalTab> _senderOrFocusedTab(const IInspectable& sender);
+        winrt::com_ptr<TabBase> _senderOrFocusedTab(const IInspectable& sender);
 
 #pragma region ActionHandlers
         // These are all defined in AppActionHandlers.cpp

src/cascadia/TerminalApp/TerminalPaneContent.cpp

@@ -77,6 +77,16 @@ namespace winrt::TerminalApp::implementation
         CloseRequested.raise(*this, nullptr);
     }
 
+    winrt::hstring TerminalPaneContent::Icon() const
+    {
+        return _profile.EvaluatedIcon();
+    }
+
+    Windows::Foundation::IReference<winrt::Windows::UI::Color> TerminalPaneContent::TabColor() const noexcept
+    {
+        return _control.TabColor();
+    }
+
     NewTerminalArgs TerminalPaneContent::GetNewTerminalArgs(const bool asContent) const
     {
         NewTerminalArgs args{};
@@ -305,11 +315,20 @@ namespace winrt::TerminalApp::implementation
         RestartTerminalRequested.raise(*this, nullptr);
     }
 
-    void TerminalPaneContent::UpdateSettings(const TerminalSettingsCreateResult& settings,
-                                             const Profile& profile)
+    void TerminalPaneContent::UpdateSettings(const CascadiaSettings& /*settings*/)
     {
-        _profile = profile;
-        _control.UpdateControlSettings(settings.DefaultSettings(), settings.UnfocusedSettings());
+        // Do nothing. We'll later be updated manually by
+        // UpdateTerminalSettings, which we need for profile and
+        // focused/unfocused settings.
+        assert(false); // If you hit this, you done goofed.
+    }
+
+    void TerminalPaneContent::UpdateTerminalSettings(const TerminalApp::TerminalSettingsCache& cache)
+    {
+        if (const auto& settings{ cache.TryLookup(_profile) })
+        {
+            _control.UpdateControlSettings(settings.DefaultSettings(), settings.UnfocusedSettings());
+        }
     }
 
     // Method Description:
@@ -321,6 +340,11 @@ namespace winrt::TerminalApp::implementation
         _isDefTermSession = true;
     }
 
+    winrt::Windows::UI::Xaml::Media::Brush TerminalPaneContent::BackgroundBrush()
+    {
+        return _control.BackgroundBrush();
+    }
+
     float TerminalPaneContent::SnapDownToGrid(const TerminalApp::PaneSnapDirection direction, const float sizeToSnap)
     {
         return _control.SnapDimensionToGrid(direction == PaneSnapDirection::Width, sizeToSnap);

src/cascadia/TerminalApp/TerminalPaneContent.h

@@ -29,8 +29,8 @@ namespace winrt::TerminalApp::implementation
 
         winrt::Microsoft::Terminal::Settings::Model::NewTerminalArgs GetNewTerminalArgs(const bool asContent) const;
 
-        void UpdateSettings(const winrt::Microsoft::Terminal::Settings::Model::TerminalSettingsCreateResult& settings,
-                            const winrt::Microsoft::Terminal::Settings::Model::Profile& profile);
+        void UpdateSettings(const winrt::Microsoft::Terminal::Settings::Model::CascadiaSettings& settings);
+        void UpdateTerminalSettings(const TerminalApp::TerminalSettingsCache& cache);
 
         void MarkAsDefterm();
 
@@ -43,6 +43,9 @@ namespace winrt::TerminalApp::implementation
         uint64_t TaskbarState() { return _control.TaskbarState(); }
         uint64_t TaskbarProgress() { return _control.TaskbarProgress(); }
         bool ReadOnly() { return _control.ReadOnly(); }
+        winrt::hstring Icon() const;
+        Windows::Foundation::IReference<winrt::Windows::UI::Color> TabColor() const noexcept;
+        winrt::Windows::UI::Xaml::Media::Brush BackgroundBrush();
 
         float SnapDownToGrid(const TerminalApp::PaneSnapDirection direction, const float sizeToSnap);
         Windows::Foundation::Size GridUnitSize();

src/cascadia/TerminalApp/TerminalPaneContent.idl

@@ -2,6 +2,7 @@
 // Licensed under the MIT license.
 
 import "IPaneContent.idl";
+import "TerminalSettingsCache.idl";
 
 namespace TerminalApp
 {
@@ -9,8 +10,7 @@ namespace TerminalApp
     {
         Microsoft.Terminal.Control.TermControl GetTermControl();
 
-        void UpdateSettings(const Microsoft.Terminal.Settings.Model.TerminalSettingsCreateResult settings,
-                            const Microsoft.Terminal.Settings.Model.Profile profile);
+        void UpdateTerminalSettings(TerminalSettingsCache cache);
 
         void MarkAsDefterm();
 

src/cascadia/TerminalApp/TerminalSettingsCache.cpp

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#include "pch.h"
+#include "TerminalSettingsCache.h"
+#include "TerminalSettingsCache.g.cpp"
+
+namespace winrt
+{
+    namespace MUX = Microsoft::UI::Xaml;
+    namespace WUX = Windows::UI::Xaml;
+    namespace MTSM = Microsoft::Terminal::Settings::Model;
+}
+
+namespace winrt::TerminalApp::implementation
+{
+    TerminalSettingsCache::TerminalSettingsCache(const MTSM::CascadiaSettings& settings, const TerminalApp::AppKeyBindings& bindings) :
+        _settings{ settings },
+        _bindings{ bindings }
+    {
+        // Mapping by GUID isn't _excellent_ because the defaults profile doesn't have a stable GUID; however,
+        // when we stabilize its guid this will become fully safe.
+        const auto profileDefaults{ _settings.ProfileDefaults() };
+        const auto allProfiles{ _settings.AllProfiles() };
+
+        profileGuidSettingsMap.reserve(allProfiles.Size() + 1);
+
+        // Include the Defaults profile for consideration
+        profileGuidSettingsMap.insert_or_assign(profileDefaults.Guid(), std::pair{ profileDefaults, nullptr });
+        for (const auto& newProfile : allProfiles)
+        {
+            // Avoid creating a TerminalSettings right now. They're not totally cheap, and we suspect that users with many
+            // panes may not be using all of their profiles at the same time. Lazy evaluation is king!
+            profileGuidSettingsMap.insert_or_assign(newProfile.Guid(), std::pair{ newProfile, nullptr });
+        }
+    }
+
+    MTSM::TerminalSettingsCreateResult TerminalSettingsCache::TryLookup(const MTSM::Profile& profile)
+    {
+        const auto found{ profileGuidSettingsMap.find(profile.Guid()) };
+        // GH#2455: If there are any panes with controls that had been
+        // initialized with a Profile that no longer exists in our list of
+        // profiles, we'll leave it unmodified. The profile doesn't exist
+        // anymore, so we can't possibly update its settings.
+        if (found != profileGuidSettingsMap.cend())
+        {
+            auto& pair{ found->second };
+            if (!pair.second)
+            {
+                pair.second = MTSM::TerminalSettings::CreateWithProfile(_settings, pair.first, _bindings);
+            }
+            return pair.second;
+        }
+
+        return nullptr;
+    }
+}

src/cascadia/TerminalApp/TerminalSettingsCache.h

@@ -0,0 +1,37 @@
+/*++
+Copyright (c) Microsoft Corporation
+Licensed under the MIT license.
+
+Class Name:
+- TerminalSettingsCache.h
+
+Abstract:
+- This is a helper class used as we update the settings for panes. This class
+  contains a single map of guid -> TerminalSettings, so that as we update all
+  the panes during a settings reload, we only need to create a TerminalSettings
+  once per profile.
+--*/
+#pragma once
+
+#include "TerminalSettingsCache.g.h"
+#include <inc/cppwinrt_utils.h>
+
+namespace winrt::TerminalApp::implementation
+{
+    class TerminalSettingsCache : public TerminalSettingsCacheT<TerminalSettingsCache>
+    {
+    public:
+        TerminalSettingsCache(const Microsoft::Terminal::Settings::Model::CascadiaSettings& settings, const TerminalApp::AppKeyBindings& bindings);
+        Microsoft::Terminal::Settings::Model::TerminalSettingsCreateResult TryLookup(const Microsoft::Terminal::Settings::Model::Profile& profile);
+
+    private:
+        Microsoft::Terminal::Settings::Model::CascadiaSettings _settings{ nullptr };
+        TerminalApp::AppKeyBindings _bindings{ nullptr };
+        std::unordered_map<winrt::guid, std::pair<Microsoft::Terminal::Settings::Model::Profile, Microsoft::Terminal::Settings::Model::TerminalSettingsCreateResult>> profileGuidSettingsMap;
+    };
+}
+
+namespace winrt::TerminalApp::factory_implementation
+{
+    BASIC_FACTORY(TerminalSettingsCache);
+}

src/cascadia/TerminalApp/TerminalSettingsCache.idl

@@ -0,0 +1,12 @@
+import "AppKeyBindings.idl";
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+namespace TerminalApp
+{
+    [default_interface] runtimeclass TerminalSettingsCache
+    {
+        TerminalSettingsCache(Microsoft.Terminal.Settings.Model.CascadiaSettings settings, AppKeyBindings bindings);
+        Microsoft.Terminal.Settings.Model.TerminalSettingsCreateResult TryLookup(Microsoft.Terminal.Settings.Model.Profile profile);
+    }
+}

src/cascadia/TerminalApp/TerminalTab.cpp

@@ -4,8 +4,9 @@
 #include "pch.h"
 #include <LibraryResources.h>
 #include "ColorPickupFlyout.h"
-#include "TerminalTab.h"
-#include "TerminalTab.g.cpp"
+#include "SettingsPaneContent.h"
+#include "TabBase.h"
+#include "TabBase.g.cpp"
 #include "Utils.h"
 #include "ColorHelper.h"
 #include "AppLogic.h"
@@ -30,7 +31,7 @@ namespace winrt
 
 namespace winrt::TerminalApp::implementation
 {
-    TerminalTab::TerminalTab(std::shared_ptr<Pane> rootPane)
+    TabBase::TabBase(std::shared_ptr<Pane> rootPane)
     {
         _rootPane = rootPane;
         _activePane = nullptr;
@@ -77,7 +78,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - <none>
-    void TerminalTab::_Setup()
+    void TabBase::_Setup()
     {
         _rootClosedToken = _rootPane->Closed([=](auto&& /*s*/, auto&& /*e*/) {
             Closed.raise(nullptr, nullptr);
@@ -118,7 +119,7 @@ namespace winrt::TerminalApp::implementation
     // - Removes the bell indicator from the tab header
     // Arguments:
     // - sender, e: not used
-    void TerminalTab::_BellIndicatorTimerTick(const Windows::Foundation::IInspectable& /*sender*/, const Windows::Foundation::IInspectable& /*e*/)
+    void TabBase::_BellIndicatorTimerTick(const Windows::Foundation::IInspectable& /*sender*/, const Windows::Foundation::IInspectable& /*e*/)
     {
         ShowBellIndicator(false);
         _bellIndicatorTimer.Stop();
@@ -130,9 +131,31 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - <none>
-    void TerminalTab::_MakeTabViewItem()
+    void TabBase::_MakeTabViewItem()
     {
-        TabBase::_MakeTabViewItem();
+        TabViewItem(::winrt::MUX::Controls::TabViewItem{});
+
+        // GH#3609 If the tab was tapped, and no one else was around to handle
+        // it, then ask our parent to toss focus into the active control.
+        TabViewItem().Tapped([weakThis{ get_weak() }](auto&&, auto&&) {
+            if (auto tab{ weakThis.get() })
+            {
+                tab->RequestFocusActiveControl.raise();
+            }
+        });
+
+        // BODGY: When the tab is drag/dropped, the TabView gets a
+        // TabDragStarting. However, the way it is implemented[^1], the
+        // TabViewItem needs either an Item or a Content for the event to
+        // include the correct TabViewItem. Otherwise, it will just return the
+        // first TabViewItem in the TabView with the same Content as the dragged
+        // tab (which, if the Content is null, will be the _first_ tab).
+        //
+        // So here, we'll stick an empty border in, just so that every tab has a
+        // Content which is not equal to the others.
+        //
+        // [^1]: microsoft-ui-xaml/blob/92fbfcd55f05c92ac65569f5d284c5b36492091e/dev/TabView/TabView.cpp#L751-L758
+        TabViewItem().Content(winrt::WUX::Controls::Border{});
 
         TabViewItem().DoubleTapped([weakThis = get_weak()](auto&& /*s*/, auto&& /*e*/) {
             if (auto tab{ weakThis.get() })
@@ -145,7 +168,7 @@ namespace winrt::TerminalApp::implementation
         _RecalculateAndApplyTabColor();
     }
 
-    void TerminalTab::_UpdateHeaderControlMaxWidth()
+    void TabBase::_UpdateHeaderControlMaxWidth()
     {
         try
         {
@@ -175,7 +198,7 @@ namespace winrt::TerminalApp::implementation
     // Return Value:
     // - nullptr if no children were marked `_lastFocused`, else the TermControl
     //   that was last focused.
-    TermControl TerminalTab::GetActiveTerminalControl() const
+    TermControl TabBase::GetActiveTerminalControl() const
     {
         ASSERT_UI_THREAD();
 
@@ -186,7 +209,7 @@ namespace winrt::TerminalApp::implementation
         return nullptr;
     }
 
-    IPaneContent TerminalTab::GetActiveContent() const
+    IPaneContent TabBase::GetActiveContent() const
     {
         return _activePane ? _activePane->GetContent() : nullptr;
     }
@@ -198,7 +221,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - <none>
-    void TerminalTab::Initialize()
+    void TabBase::Initialize()
     {
         ASSERT_UI_THREAD();
 
@@ -219,7 +242,7 @@ namespace winrt::TerminalApp::implementation
     // - focused: our new focus state
     // Return Value:
     // - <none>
-    void TerminalTab::Focus(WUX::FocusState focusState)
+    void TabBase::Focus(WUX::FocusState focusState)
     {
         ASSERT_UI_THREAD();
 
@@ -253,7 +276,7 @@ namespace winrt::TerminalApp::implementation
     // Return Value:
     // - nullopt if no children of this tab were the last control to be
     //   focused, else the GUID of the profile of the last control to be focused
-    Profile TerminalTab::GetFocusedProfile() const noexcept
+    Profile TabBase::GetFocusedProfile() const noexcept
     {
         ASSERT_UI_THREAD();
 
@@ -266,12 +289,18 @@ namespace winrt::TerminalApp::implementation
     //   of the settings that apply to all tabs.
     // Return Value:
     // - <none>
-    void TerminalTab::UpdateSettings()
+    void TabBase::UpdateSettings(const CascadiaSettings& settings, const TerminalApp::TerminalSettingsCache& cache)
     {
         ASSERT_UI_THREAD();
 
         // The tabWidthMode may have changed, update the header control accordingly
         _UpdateHeaderControlMaxWidth();
+
+        // Update the settings on all our panes.
+        _rootPane->WalkTree([&](auto pane) {
+            pane->UpdateSettings(settings, cache);
+            return false;
+        });
     }
 
     // Method Description:
@@ -280,7 +309,7 @@ namespace winrt::TerminalApp::implementation
     // - iconPath: The new path string to use as the IconPath for our TabViewItem
     // Return Value:
     // - <none>
-    void TerminalTab::UpdateIcon(const winrt::hstring iconPath, const winrt::Microsoft::Terminal::Settings::Model::IconStyle iconStyle)
+    void TabBase::UpdateIcon(const winrt::hstring& iconPath, const winrt::Microsoft::Terminal::Settings::Model::IconStyle iconStyle)
     {
         ASSERT_UI_THREAD();
 
@@ -318,7 +347,7 @@ namespace winrt::TerminalApp::implementation
     // - Used when we want to show the progress ring, which should replace the icon
     // Arguments:
     // - hide: if true, we hide the icon; if false, we show the icon
-    void TerminalTab::HideIcon(const bool hide)
+    void TabBase::HideIcon(const bool hide)
     {
         ASSERT_UI_THREAD();
 
@@ -342,7 +371,7 @@ namespace winrt::TerminalApp::implementation
     // - Hide or show the bell indicator in the tab header
     // Arguments:
     // - show: if true, we show the indicator; if false, we hide the indicator
-    void TerminalTab::ShowBellIndicator(const bool show)
+    void TabBase::ShowBellIndicator(const bool show)
     {
         ASSERT_UI_THREAD();
 
@@ -352,14 +381,14 @@ namespace winrt::TerminalApp::implementation
     // Method Description:
     // - Activates the timer for the bell indicator in the tab
     // - Called if a bell raised when the tab already has focus
-    void TerminalTab::ActivateBellIndicatorTimer()
+    void TabBase::ActivateBellIndicatorTimer()
     {
         ASSERT_UI_THREAD();
 
         if (!_bellIndicatorTimer)
         {
             _bellIndicatorTimer.Interval(std::chrono::milliseconds(2000));
-            _bellIndicatorTimer.Tick({ get_weak(), &TerminalTab::_BellIndicatorTimerTick });
+            _bellIndicatorTimer.Tick({ get_weak(), &TabBase::_BellIndicatorTimerTick });
         }
 
         _bellIndicatorTimer.Start();
@@ -372,7 +401,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - the title string of the last focused terminal control in our tree.
-    winrt::hstring TerminalTab::_GetActiveTitle() const
+    winrt::hstring TabBase::_GetActiveTitle() const
     {
         if (!_runtimeTabText.empty())
         {
@@ -383,7 +412,7 @@ namespace winrt::TerminalApp::implementation
             return RS_(L"MultiplePanes");
         }
         const auto activeContent = GetActiveContent();
-        return activeContent ? activeContent.Title() : L"";
+        return activeContent ? activeContent.Title() : winrt::hstring{ L"" };
     }
 
     // Method Description:
@@ -394,7 +423,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - <none>
-    void TerminalTab::UpdateTitle()
+    void TabBase::UpdateTitle()
     {
         ASSERT_UI_THREAD();
 
@@ -416,7 +445,7 @@ namespace winrt::TerminalApp::implementation
     // - delta: a number of lines to move the viewport relative to the current viewport.
     // Return Value:
     // - <none>
-    void TerminalTab::Scroll(const int delta)
+    void TabBase::Scroll(const int delta)
     {
         ASSERT_UI_THREAD();
 
@@ -432,15 +461,38 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - A vector of commands
-    std::vector<ActionAndArgs> TerminalTab::BuildStartupActions(const bool asContent) const
+    std::vector<ActionAndArgs> TabBase::BuildStartupActions(const bool asContent) const
     {
         ASSERT_UI_THREAD();
 
         // Give initial ids (0 for the child created with this tab,
         // 1 for the child after the first split.
-        auto state = _rootPane->BuildStartupActions(0, 1, asContent);
+        Pane::BuildStartupState state;
 
+        // HORRIBLE
+        //
+        // Workaround till we know how we actually want to handle state
+        // restoring other kinda of panes. If this is a settings tab, just
+        // restore it as a settings tab. Don't bother recreating terminal args
+        // for every pane.
+        //
+        // In the future, we'll want to definitely get rid of
+        // Pane::GetTerminalArgsForPane, and somehow instead find a better way
+        // of re-creating the pane state. Probably through a combo of ResizePane
+        // actions and SetPaneOrientation actions.
+        if (const auto& settings{ _rootPane->GetContent().try_as<SettingsPaneContent>() })
         {
+            ActionAndArgs action;
+            action.Action(ShortcutAction::OpenSettings);
+            OpenSettingsArgs args{ SettingsTarget::SettingsUI };
+            action.Args(args);
+
+            state.args = std::vector{ std::move(action) };
+        }
+        else
+        {
+            state = _rootPane->BuildStartupActions(0, 1, asContent);
+
             ActionAndArgs newTabAction{};
             newTabAction.Action(ShortcutAction::NewTab);
             NewTabArgs newTabArgs{ state.firstPane->GetTerminalArgsForPane(asContent) };
@@ -505,9 +557,9 @@ namespace winrt::TerminalApp::implementation
     //         could itself be a parent pane/the root node of a tree of panes
     // Return Value:
     // - <none>
-    std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> TerminalTab::SplitPane(SplitDirection splitType,
-                                                                                   const float splitSize,
-                                                                                   std::shared_ptr<Pane> pane)
+    std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> TabBase::SplitPane(SplitDirection splitType,
+                                                                               const float splitSize,
+                                                                               std::shared_ptr<Pane> pane)
     {
         ASSERT_UI_THREAD();
 
@@ -566,7 +618,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - The removed pane, if the remove succeeded.
-    std::shared_ptr<Pane> TerminalTab::DetachPane()
+    std::shared_ptr<Pane> TabBase::DetachPane()
     {
         ASSERT_UI_THREAD();
 
@@ -595,7 +647,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - The root pane.
-    std::shared_ptr<Pane> TerminalTab::DetachRoot()
+    std::shared_ptr<Pane> TabBase::DetachRoot()
     {
         ASSERT_UI_THREAD();
 
@@ -623,7 +675,7 @@ namespace winrt::TerminalApp::implementation
     // - pane: The pane to add.
     // Return Value:
     // - <none>
-    void TerminalTab::AttachPane(std::shared_ptr<Pane> pane)
+    void TabBase::AttachPane(std::shared_ptr<Pane> pane)
     {
         ASSERT_UI_THREAD();
 
@@ -674,7 +726,7 @@ namespace winrt::TerminalApp::implementation
     // - colorPicker: The color picker that we should attach to ourselves
     // Return Value:
     // - <none>
-    void TerminalTab::AttachColorPicker(TerminalApp::ColorPickupFlyout& colorPicker)
+    void TabBase::AttachColorPicker(TerminalApp::ColorPickupFlyout& colorPicker)
     {
         ASSERT_UI_THREAD();
 
@@ -714,7 +766,7 @@ namespace winrt::TerminalApp::implementation
     //   its parent. E.g. switch from Horizontal to Vertical.
     // Return Value:
     // - <none>
-    void TerminalTab::ToggleSplitOrientation()
+    void TabBase::ToggleSplitOrientation()
     {
         ASSERT_UI_THREAD();
 
@@ -723,7 +775,7 @@ namespace winrt::TerminalApp::implementation
 
     // Method Description:
     // - See Pane::CalcSnappedDimension
-    float TerminalTab::CalcSnappedDimension(const bool widthOrHeight, const float dimension) const
+    float TabBase::CalcSnappedDimension(const bool widthOrHeight, const float dimension) const
     {
         ASSERT_UI_THREAD();
 
@@ -737,7 +789,7 @@ namespace winrt::TerminalApp::implementation
     // - direction: The direction to move the separator in.
     // Return Value:
     // - <none>
-    void TerminalTab::ResizePane(const ResizeDirection& direction)
+    void TabBase::ResizePane(const ResizeDirection& direction)
     {
         ASSERT_UI_THREAD();
 
@@ -754,7 +806,7 @@ namespace winrt::TerminalApp::implementation
     // Return Value:
     // - Whether changing the focus succeeded. This allows a keychord to propagate
     //   to the terminal when no other panes are present (GH#6219)
-    bool TerminalTab::NavigateFocus(const FocusDirection& direction)
+    bool TabBase::NavigateFocus(const FocusDirection& direction)
     {
         ASSERT_UI_THREAD();
 
@@ -786,7 +838,7 @@ namespace winrt::TerminalApp::implementation
     // - direction: The direction to move the pane in.
     // Return Value:
     // - true if two panes were swapped.
-    bool TerminalTab::SwapPane(const FocusDirection& direction)
+    bool TabBase::SwapPane(const FocusDirection& direction)
     {
         ASSERT_UI_THREAD();
 
@@ -811,7 +863,7 @@ namespace winrt::TerminalApp::implementation
         return false;
     }
 
-    bool TerminalTab::FocusPane(const uint32_t id)
+    bool TabBase::FocusPane(const uint32_t id)
     {
         ASSERT_UI_THREAD();
 
@@ -827,10 +879,12 @@ namespace winrt::TerminalApp::implementation
 
     // Method Description:
     // - Prepares this tab for being removed from the UI hierarchy by shutting down all active connections.
-    void TerminalTab::Shutdown()
+    void TabBase::Shutdown()
     {
         ASSERT_UI_THREAD();
 
+        Content(nullptr);
+
         if (_rootPane)
         {
             _rootPane->Shutdown();
@@ -845,14 +899,14 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - <none>
-    void TerminalTab::ClosePane()
+    void TabBase::ClosePane()
     {
         ASSERT_UI_THREAD();
 
         _activePane->Close();
     }
 
-    void TerminalTab::SetTabText(winrt::hstring title)
+    void TabBase::SetTabText(winrt::hstring title)
     {
         ASSERT_UI_THREAD();
 
@@ -860,14 +914,14 @@ namespace winrt::TerminalApp::implementation
         UpdateTitle();
     }
 
-    winrt::hstring TerminalTab::GetTabText() const
+    winrt::hstring TabBase::GetTabText() const
     {
         ASSERT_UI_THREAD();
 
         return _runtimeTabText;
     }
 
-    void TerminalTab::ResetTabText()
+    void TabBase::ResetTabText()
     {
         ASSERT_UI_THREAD();
 
@@ -882,7 +936,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - <none>
-    void TerminalTab::ActivateTabRenamer()
+    void TabBase::ActivateTabRenamer()
     {
         ASSERT_UI_THREAD();
 
@@ -898,7 +952,7 @@ namespace winrt::TerminalApp::implementation
     // - paneId: The ID of the pane that contains the given content.
     // Return Value:
     // - <none>
-    void TerminalTab::_DetachEventHandlersFromContent(const uint32_t paneId)
+    void TabBase::_DetachEventHandlersFromContent(const uint32_t paneId)
     {
         auto it = _contentEvents.find(paneId);
         if (it != _contentEvents.end())
@@ -920,7 +974,7 @@ namespace winrt::TerminalApp::implementation
     // - control: the TermControl to add events to.
     // Return Value:
     // - <none>
-    void TerminalTab::_AttachEventHandlersToContent(const uint32_t paneId, const TerminalApp::IPaneContent& content)
+    void TabBase::_AttachEventHandlersToContent(const uint32_t paneId, const TerminalApp::IPaneContent& content)
     {
         auto weakThis{ get_weak() };
         auto dispatcher = TabViewItem().Dispatcher();
@@ -1061,7 +1115,7 @@ namespace winrt::TerminalApp::implementation
 
         if (const auto& terminal{ content.try_as<TerminalApp::TerminalPaneContent>() })
         {
-            events.RestartTerminalRequested = terminal.RestartTerminalRequested(winrt::auto_revoke, { get_weak(), &TerminalTab::_bubbleRestartTerminalRequested });
+            events.RestartTerminalRequested = terminal.RestartTerminalRequested(winrt::auto_revoke, { get_weak(), &TabBase::_bubbleRestartTerminalRequested });
         }
 
         if (_tabStatus.IsInputBroadcastActive())
@@ -1087,7 +1141,7 @@ namespace winrt::TerminalApp::implementation
     // Return Value:
     // - A TaskbarState object representing the combined taskbar state and
     //   progress percentage of all our panes.
-    winrt::TerminalApp::TaskbarState TerminalTab::GetCombinedTaskbarState() const
+    winrt::TerminalApp::TaskbarState TabBase::GetCombinedTaskbarState() const
     {
         ASSERT_UI_THREAD();
 
@@ -1113,7 +1167,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - <none>
-    void TerminalTab::_UpdateProgressState()
+    void TabBase::_UpdateProgressState()
     {
         const auto state{ GetCombinedTaskbarState() };
 
@@ -1157,7 +1211,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - <none>
-    void TerminalTab::_UpdateConnectionClosedState()
+    void TabBase::_UpdateConnectionClosedState()
     {
         ASSERT_UI_THREAD();
 
@@ -1178,7 +1232,7 @@ namespace winrt::TerminalApp::implementation
         }
     }
 
-    void TerminalTab::_RestartActivePaneConnection()
+    void TabBase::_RestartActivePaneConnection()
     {
         ActionAndArgs restartConnection{ ShortcutAction::RestartConnection, nullptr };
         _dispatch.DoAction(*this, restartConnection);
@@ -1192,7 +1246,7 @@ namespace winrt::TerminalApp::implementation
     // - pane: a Pane to mark as active.
     // Return Value:
     // - <none>
-    void TerminalTab::_UpdateActivePane(std::shared_ptr<Pane> pane)
+    void TabBase::_UpdateActivePane(std::shared_ptr<Pane> pane)
     {
         // Clear the active state of the entire tree, and mark only the pane as active.
         _rootPane->ClearActive();
@@ -1239,7 +1293,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - <none>
-    void TerminalTab::_AttachEventHandlersToPane(std::shared_ptr<Pane> pane)
+    void TabBase::_AttachEventHandlersToPane(std::shared_ptr<Pane> pane)
     {
         auto weakThis{ get_weak() };
         std::weak_ptr<Pane> weakPane{ pane };
@@ -1361,7 +1415,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - <none>
-    void TerminalTab::_CreateContextMenu()
+    void TabBase::_CreateContextMenu()
     {
         auto weakThis{ get_weak() };
 
@@ -1372,7 +1426,7 @@ namespace winrt::TerminalApp::implementation
             colorPickSymbol.FontFamily(Media::FontFamily{ L"Segoe Fluent Icons, Segoe MDL2 Assets" });
             colorPickSymbol.Glyph(L"\xE790");
 
-            chooseColorMenuItem.Click({ get_weak(), &TerminalTab::_chooseColorClicked });
+            chooseColorMenuItem.Click({ get_weak(), &TabBase::_chooseColorClicked });
             chooseColorMenuItem.Text(RS_(L"TabColorChoose"));
             chooseColorMenuItem.Icon(colorPickSymbol);
 
@@ -1389,7 +1443,7 @@ namespace winrt::TerminalApp::implementation
             renameTabSymbol.FontFamily(Media::FontFamily{ L"Segoe Fluent Icons, Segoe MDL2 Assets" });
             renameTabSymbol.Glyph(L"\xE8AC"); // Rename
 
-            renameTabMenuItem.Click({ get_weak(), &TerminalTab::_renameTabClicked });
+            renameTabMenuItem.Click({ get_weak(), &TabBase::_renameTabClicked });
             renameTabMenuItem.Text(RS_(L"RenameTabText"));
             renameTabMenuItem.Icon(renameTabSymbol);
 
@@ -1406,7 +1460,7 @@ namespace winrt::TerminalApp::implementation
             duplicateTabSymbol.FontFamily(Media::FontFamily{ L"Segoe Fluent Icons, Segoe MDL2 Assets" });
             duplicateTabSymbol.Glyph(L"\xF5ED");
 
-            duplicateTabMenuItem.Click({ get_weak(), &TerminalTab::_duplicateTabClicked });
+            duplicateTabMenuItem.Click({ get_weak(), &TabBase::_duplicateTabClicked });
             duplicateTabMenuItem.Text(RS_(L"DuplicateTabText"));
             duplicateTabMenuItem.Icon(duplicateTabSymbol);
 
@@ -1423,7 +1477,7 @@ namespace winrt::TerminalApp::implementation
             splitTabSymbol.FontFamily(Media::FontFamily{ L"Segoe Fluent Icons, Segoe MDL2 Assets" });
             splitTabSymbol.Glyph(L"\xF246"); // ViewDashboard
 
-            splitTabMenuItem.Click({ get_weak(), &TerminalTab::_splitTabClicked });
+            splitTabMenuItem.Click({ get_weak(), &TabBase::_splitTabClicked });
             splitTabMenuItem.Text(RS_(L"SplitTabText"));
             splitTabMenuItem.Icon(splitTabSymbol);
 
@@ -1440,7 +1494,7 @@ namespace winrt::TerminalApp::implementation
             moveTabToNewWindowTabSymbol.FontFamily(Media::FontFamily{ L"Segoe Fluent Icons, Segoe MDL2 Assets" });
             moveTabToNewWindowTabSymbol.Glyph(L"\xE8A7");
 
-            moveTabToNewWindowMenuItem.Click({ get_weak(), &TerminalTab::_moveTabToNewWindowClicked });
+            moveTabToNewWindowMenuItem.Click({ get_weak(), &TabBase::_moveTabToNewWindowClicked });
             moveTabToNewWindowMenuItem.Text(RS_(L"MoveTabToNewWindowText"));
             moveTabToNewWindowMenuItem.Icon(moveTabToNewWindowTabSymbol);
 
@@ -1453,7 +1507,7 @@ namespace winrt::TerminalApp::implementation
         Controls::MenuFlyoutItem closePaneMenuItem = _closePaneMenuItem;
         {
             // "Close Pane"
-            closePaneMenuItem.Click({ get_weak(), &TerminalTab::_closePaneClicked });
+            closePaneMenuItem.Click({ get_weak(), &TabBase::_closePaneClicked });
             closePaneMenuItem.Text(RS_(L"ClosePaneText"));
 
             const auto closePaneToolTip = RS_(L"ClosePaneToolTip");
@@ -1469,7 +1523,7 @@ namespace winrt::TerminalApp::implementation
             exportTabSymbol.FontFamily(Media::FontFamily{ L"Segoe Fluent Icons, Segoe MDL2 Assets" });
             exportTabSymbol.Glyph(L"\xE74E"); // Save
 
-            exportTabMenuItem.Click({ get_weak(), &TerminalTab::_exportTextClicked });
+            exportTabMenuItem.Click({ get_weak(), &TabBase::_exportTextClicked });
             exportTabMenuItem.Text(RS_(L"ExportTabText"));
             exportTabMenuItem.Icon(exportTabSymbol);
 
@@ -1486,7 +1540,7 @@ namespace winrt::TerminalApp::implementation
             findSymbol.FontFamily(Media::FontFamily{ L"Segoe Fluent Icons, Segoe MDL2 Assets" });
             findSymbol.Glyph(L"\xF78B"); // SearchMedium
 
-            findMenuItem.Click({ get_weak(), &TerminalTab::_findClicked });
+            findMenuItem.Click({ get_weak(), &TabBase::_findClicked });
             findMenuItem.Text(RS_(L"FindText"));
             findMenuItem.Icon(findSymbol);
 
@@ -1562,16 +1616,16 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - The tab's color, if any
-    std::optional<winrt::Windows::UI::Color> TerminalTab::GetTabColor()
+    std::optional<winrt::Windows::UI::Color> TabBase::GetTabColor()
     {
         ASSERT_UI_THREAD();
 
-        std::optional<winrt::Windows::UI::Color> controlTabColor;
-        if (const auto& control = GetActiveTerminalControl())
+        std::optional<winrt::Windows::UI::Color> contentTabColor;
+        if (const auto& content{ GetActiveContent() })
         {
-            if (const auto color = control.TabColor())
+            if (const auto color = content.TabColor())
             {
-                controlTabColor = color.Value();
+                contentTabColor = color.Value();
             }
         }
 
@@ -1581,7 +1635,7 @@ namespace winrt::TerminalApp::implementation
         // Color                |             | Set by
         // -------------------- | --          | --
         // Runtime Color        | _optional_  | Color Picker / `setTabColor` action
-        // Control Tab Color    | _optional_  | Profile's `tabColor`, or a color set by VT
+        // Content Tab Color    | _optional_  | Profile's `tabColor`, or a color set by VT (whatever the tab's content wants)
         // Theme Tab Background | _optional_  | `tab.backgroundColor` in the theme (handled in _RecalculateAndApplyTabColor)
         // Tab Default Color    | **default** | TabView in XAML
         //
@@ -1590,7 +1644,7 @@ namespace winrt::TerminalApp::implementation
         // tabview color" (and clear out any colors we've set).
 
         return til::coalesce(_runtimeTabColor,
-                             controlTabColor,
+                             contentTabColor,
                              std::optional<Windows::UI::Color>(std::nullopt));
     }
 
@@ -1602,7 +1656,7 @@ namespace winrt::TerminalApp::implementation
     // - color: the color the user picked for their tab
     // Return Value:
     // - <none>
-    void TerminalTab::SetRuntimeTabColor(const winrt::Windows::UI::Color& color)
+    void TabBase::SetRuntimeTabColor(const winrt::Windows::UI::Color& color)
     {
         ASSERT_UI_THREAD();
 
@@ -1618,7 +1672,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - <none>
-    void TerminalTab::ResetRuntimeTabColor()
+    void TabBase::ResetRuntimeTabColor()
     {
         ASSERT_UI_THREAD();
 
@@ -1626,10 +1680,10 @@ namespace winrt::TerminalApp::implementation
         _RecalculateAndApplyTabColor();
     }
 
-    winrt::Windows::UI::Xaml::Media::Brush TerminalTab::_BackgroundBrush()
+    winrt::Windows::UI::Xaml::Media::Brush TabBase::_BackgroundBrush()
     {
         Media::Brush terminalBrush{ nullptr };
-        if (const auto& c{ GetActiveTerminalControl() })
+        if (const auto& c{ GetActiveContent() })
         {
             terminalBrush = c.BackgroundBrush();
         }
@@ -1642,7 +1696,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - The total number of leaf panes hosted by this tab.
-    int TerminalTab::GetLeafPaneCount() const noexcept
+    int TabBase::GetLeafPaneCount() const noexcept
     {
         ASSERT_UI_THREAD();
 
@@ -1659,9 +1713,9 @@ namespace winrt::TerminalApp::implementation
     // Return value:
     // - This will return nullopt if a split of the given size/direction was not possible,
     //   or it will return the split direction with automatic converted to a cardinal direction.
-    std::optional<SplitDirection> TerminalTab::PreCalculateCanSplit(SplitDirection splitType,
-                                                                    const float splitSize,
-                                                                    winrt::Windows::Foundation::Size availableSpace) const
+    std::optional<SplitDirection> TabBase::PreCalculateCanSplit(SplitDirection splitType,
+                                                                const float splitSize,
+                                                                winrt::Windows::Foundation::Size availableSpace) const
     {
         ASSERT_UI_THREAD();
 
@@ -1674,7 +1728,7 @@ namespace winrt::TerminalApp::implementation
     // - newFocus: the new pane to be zoomed
     // Return Value:
     // - <none>
-    void TerminalTab::UpdateZoom(std::shared_ptr<Pane> newFocus)
+    void TabBase::UpdateZoom(std::shared_ptr<Pane> newFocus)
     {
         ASSERT_UI_THREAD();
 
@@ -1696,7 +1750,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - <none>
-    void TerminalTab::ToggleZoom()
+    void TabBase::ToggleZoom()
     {
         ASSERT_UI_THREAD();
 
@@ -1710,7 +1764,7 @@ namespace winrt::TerminalApp::implementation
         }
     }
 
-    void TerminalTab::EnterZoom()
+    void TabBase::EnterZoom()
     {
         ASSERT_UI_THREAD();
 
@@ -1725,7 +1779,7 @@ namespace winrt::TerminalApp::implementation
         _tabStatus.IsPaneZoomed(true);
         Content(_zoomedPane->GetRootElement());
     }
-    void TerminalTab::ExitZoom()
+    void TabBase::ExitZoom()
     {
         ASSERT_UI_THREAD();
 
@@ -1737,7 +1791,7 @@ namespace winrt::TerminalApp::implementation
         Content(_rootPane->GetRootElement());
     }
 
-    bool TerminalTab::IsZoomed()
+    bool TabBase::IsZoomed()
     {
         ASSERT_UI_THREAD();
 
@@ -1760,7 +1814,7 @@ namespace winrt::TerminalApp::implementation
     // - Toggle read-only mode on the active pane
     // - If a parent pane is selected, this will ensure that all children have
     //   the same read-only status.
-    void TerminalTab::TogglePaneReadOnly()
+    void TabBase::TogglePaneReadOnly()
     {
         ASSERT_UI_THREAD();
 
@@ -1794,7 +1848,7 @@ namespace winrt::TerminalApp::implementation
     // - Set read-only mode on the active pane
     // - If a parent pane is selected, this will ensure that all children have
     //   the same read-only status.
-    void TerminalTab::SetPaneReadOnly(const bool readOnlyState)
+    void TabBase::SetPaneReadOnly(const bool readOnlyState)
     {
         auto hasReadOnly = false;
         auto allReadOnly = true;
@@ -1826,7 +1880,7 @@ namespace winrt::TerminalApp::implementation
     // - Calculates if the tab is read-only.
     // The tab is considered read-only if one of the panes is read-only.
     // If after the calculation the tab is read-only we hide the close button on the tab view item
-    void TerminalTab::_RecalculateAndApplyReadOnly()
+    void TabBase::_RecalculateAndApplyReadOnly()
     {
         const auto control = GetActiveTerminalControl();
         if (control)
@@ -1843,7 +1897,7 @@ namespace winrt::TerminalApp::implementation
         _rootPane->WalkTree([](const auto& p) { p->UpdateVisuals(); });
     }
 
-    std::shared_ptr<Pane> TerminalTab::GetActivePane() const
+    std::shared_ptr<Pane> TabBase::GetActivePane() const
     {
         ASSERT_UI_THREAD();
 
@@ -1857,7 +1911,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - The value to populate in the title run of the tool tip
-    winrt::hstring TerminalTab::_CreateToolTipTitle()
+    winrt::hstring TabBase::_CreateToolTipTitle()
     {
         if (const auto& control{ GetActiveTerminalControl() })
         {
@@ -1873,7 +1927,7 @@ namespace winrt::TerminalApp::implementation
 
     // Method Description:
     // - Toggle broadcasting input to all the panes in this tab.
-    void TerminalTab::ToggleBroadcastInput()
+    void TabBase::ToggleBroadcastInput()
     {
         const bool newIsBroadcasting = !_tabStatus.IsInputBroadcastActive();
         _tabStatus.IsInputBroadcastActive(newIsBroadcasting);
@@ -1912,7 +1966,7 @@ namespace winrt::TerminalApp::implementation
         });
     }
 
-    void TerminalTab::_addBroadcastHandlers(const TermControl& termControl, ContentEventTokens& events)
+    void TabBase::_addBroadcastHandlers(const TermControl& termControl, ContentEventTokens& events)
     {
         auto weakThis{ get_weak() };
         // ADD EVENT HANDLERS HERE
@@ -1955,55 +2009,55 @@ namespace winrt::TerminalApp::implementation
         });
     }
 
-    void TerminalTab::_chooseColorClicked(const winrt::Windows::Foundation::IInspectable& /* sender */,
-                                          const winrt::Windows::UI::Xaml::RoutedEventArgs& /* args */)
+    void TabBase::_chooseColorClicked(const winrt::Windows::Foundation::IInspectable& /* sender */,
+                                      const winrt::Windows::UI::Xaml::RoutedEventArgs& /* args */)
     {
         _dispatch.DoAction(*this, { ShortcutAction::OpenTabColorPicker, nullptr });
     }
-    void TerminalTab::_renameTabClicked(const winrt::Windows::Foundation::IInspectable& /* sender */,
-                                        const winrt::Windows::UI::Xaml::RoutedEventArgs& /* args */)
+    void TabBase::_renameTabClicked(const winrt::Windows::Foundation::IInspectable& /* sender */,
+                                    const winrt::Windows::UI::Xaml::RoutedEventArgs& /* args */)
     {
         ActivateTabRenamer();
     }
-    void TerminalTab::_duplicateTabClicked(const winrt::Windows::Foundation::IInspectable& /* sender */,
-                                           const winrt::Windows::UI::Xaml::RoutedEventArgs& /* args */)
+    void TabBase::_duplicateTabClicked(const winrt::Windows::Foundation::IInspectable& /* sender */,
+                                       const winrt::Windows::UI::Xaml::RoutedEventArgs& /* args */)
     {
         ActionAndArgs actionAndArgs{ ShortcutAction::DuplicateTab, nullptr };
         _dispatch.DoAction(*this, actionAndArgs);
     }
-    void TerminalTab::_splitTabClicked(const winrt::Windows::Foundation::IInspectable& /* sender */,
-                                       const winrt::Windows::UI::Xaml::RoutedEventArgs& /* args */)
+    void TabBase::_splitTabClicked(const winrt::Windows::Foundation::IInspectable& /* sender */,
+                                   const winrt::Windows::UI::Xaml::RoutedEventArgs& /* args */)
     {
         ActionAndArgs actionAndArgs{ ShortcutAction::SplitPane, SplitPaneArgs{ SplitType::Duplicate } };
         _dispatch.DoAction(*this, actionAndArgs);
     }
-    void TerminalTab::_closePaneClicked(const winrt::Windows::Foundation::IInspectable& /* sender */,
-                                        const winrt::Windows::UI::Xaml::RoutedEventArgs& /* args */)
+    void TabBase::_closePaneClicked(const winrt::Windows::Foundation::IInspectable& /* sender */,
+                                    const winrt::Windows::UI::Xaml::RoutedEventArgs& /* args */)
     {
         ClosePane();
     }
-    void TerminalTab::_exportTextClicked(const winrt::Windows::Foundation::IInspectable& /* sender */,
-                                         const winrt::Windows::UI::Xaml::RoutedEventArgs& /* args */)
+    void TabBase::_exportTextClicked(const winrt::Windows::Foundation::IInspectable& /* sender */,
+                                     const winrt::Windows::UI::Xaml::RoutedEventArgs& /* args */)
     {
         ActionAndArgs actionAndArgs{};
         actionAndArgs.Action(ShortcutAction::ExportBuffer);
         _dispatch.DoAction(*this, actionAndArgs);
     }
-    void TerminalTab::_moveTabToNewWindowClicked(const winrt::Windows::Foundation::IInspectable& /* sender */,
-                                                 const winrt::Windows::UI::Xaml::RoutedEventArgs& /* args */)
+    void TabBase::_moveTabToNewWindowClicked(const winrt::Windows::Foundation::IInspectable& /* sender */,
+                                             const winrt::Windows::UI::Xaml::RoutedEventArgs& /* args */)
     {
         MoveTabArgs args{ winrt::to_hstring(NewWindow), MoveTabDirection::Forward };
         ActionAndArgs actionAndArgs{ ShortcutAction::MoveTab, args };
         _dispatch.DoAction(*this, actionAndArgs);
     }
-    void TerminalTab::_findClicked(const winrt::Windows::Foundation::IInspectable& /* sender */,
-                                   const winrt::Windows::UI::Xaml::RoutedEventArgs& /* args */)
+    void TabBase::_findClicked(const winrt::Windows::Foundation::IInspectable& /* sender */,
+                               const winrt::Windows::UI::Xaml::RoutedEventArgs& /* args */)
     {
         ActionAndArgs actionAndArgs{ ShortcutAction::Find, nullptr };
         _dispatch.DoAction(*this, actionAndArgs);
     }
-    void TerminalTab::_bubbleRestartTerminalRequested(TerminalApp::TerminalPaneContent sender,
-                                                      const winrt::Windows::Foundation::IInspectable& args)
+    void TabBase::_bubbleRestartTerminalRequested(TerminalApp::TerminalPaneContent sender,
+                                                  const winrt::Windows::Foundation::IInspectable& args)
     {
         RestartTerminalRequested.raise(sender, args);
     }

src/cascadia/TerminalApp/TerminalTab.h

@@ -1,207 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-#pragma once
-#include "Pane.h"
-#include "ColorPickupFlyout.h"
-#include "TabBase.h"
-#include "TerminalTab.g.h"
-
-// fwdecl unittest classes
-namespace TerminalAppLocalTests
-{
-    class TabTests;
-};
-
-namespace winrt::TerminalApp::implementation
-{
-    struct TerminalTab : TerminalTabT<TerminalTab, TabBase>
-    {
-    public:
-        TerminalTab(std::shared_ptr<Pane> rootPane);
-
-        // Called after construction to perform the necessary setup, which relies on weak_ptr
-        void Initialize();
-
-        winrt::Microsoft::Terminal::Control::TermControl GetActiveTerminalControl() const;
-        winrt::Microsoft::Terminal::Settings::Model::Profile GetFocusedProfile() const noexcept;
-        winrt::TerminalApp::IPaneContent GetActiveContent() const;
-
-        void Focus(winrt::Windows::UI::Xaml::FocusState focusState) override;
-
-        void Scroll(const int delta);
-
-        std::shared_ptr<Pane> DetachRoot();
-        std::shared_ptr<Pane> DetachPane();
-        void AttachPane(std::shared_ptr<Pane> pane);
-
-        void AttachColorPicker(winrt::TerminalApp::ColorPickupFlyout& colorPicker);
-
-        std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> SplitPane(winrt::Microsoft::Terminal::Settings::Model::SplitDirection splitType,
-                                                                          const float splitSize,
-                                                                          std::shared_ptr<Pane> newPane);
-
-        void ToggleSplitOrientation();
-        void UpdateIcon(const winrt::hstring iconPath, const winrt::Microsoft::Terminal::Settings::Model::IconStyle iconStyle);
-        void HideIcon(const bool hide);
-
-        void ShowBellIndicator(const bool show);
-        void ActivateBellIndicatorTimer();
-
-        float CalcSnappedDimension(const bool widthOrHeight, const float dimension) const;
-        std::optional<winrt::Microsoft::Terminal::Settings::Model::SplitDirection> PreCalculateCanSplit(winrt::Microsoft::Terminal::Settings::Model::SplitDirection splitType,
-                                                                                                        const float splitSize,
-                                                                                                        winrt::Windows::Foundation::Size availableSpace) const;
-
-        void ResizePane(const winrt::Microsoft::Terminal::Settings::Model::ResizeDirection& direction);
-        bool NavigateFocus(const winrt::Microsoft::Terminal::Settings::Model::FocusDirection& direction);
-        bool SwapPane(const winrt::Microsoft::Terminal::Settings::Model::FocusDirection& direction);
-        bool FocusPane(const uint32_t id);
-
-        void UpdateSettings();
-        void UpdateTitle();
-
-        void Shutdown() override;
-        void ClosePane();
-
-        void SetTabText(winrt::hstring title);
-        winrt::hstring GetTabText() const;
-        void ResetTabText();
-        void ActivateTabRenamer();
-
-        virtual std::optional<winrt::Windows::UI::Color> GetTabColor() override;
-        void SetRuntimeTabColor(const winrt::Windows::UI::Color& color);
-        void ResetRuntimeTabColor();
-
-        void UpdateZoom(std::shared_ptr<Pane> newFocus);
-        void ToggleZoom();
-        bool IsZoomed();
-        void EnterZoom();
-        void ExitZoom();
-
-        std::vector<Microsoft::Terminal::Settings::Model::ActionAndArgs> BuildStartupActions(const bool asContent = false) const override;
-
-        int GetLeafPaneCount() const noexcept;
-
-        void TogglePaneReadOnly();
-        void SetPaneReadOnly(const bool readOnlyState);
-        void ToggleBroadcastInput();
-
-        std::shared_ptr<Pane> GetActivePane() const;
-        winrt::TerminalApp::TaskbarState GetCombinedTaskbarState() const;
-
-        std::shared_ptr<Pane> GetRootPane() const { return _rootPane; }
-
-        winrt::TerminalApp::TerminalTabStatus TabStatus()
-        {
-            return _tabStatus;
-        }
-
-        til::typed_event<TerminalApp::TerminalPaneContent> RestartTerminalRequested;
-
-        til::event<winrt::delegate<>> ActivePaneChanged;
-        til::event<winrt::delegate<>> TabRaiseVisualBell;
-        til::typed_event<IInspectable, IInspectable> TaskbarProgressChanged;
-
-    private:
-        static constexpr double HeaderRenameBoxWidthDefault{ 165 };
-        static constexpr double HeaderRenameBoxWidthTitleLength{ std::numeric_limits<double>::infinity() };
-
-        std::shared_ptr<Pane> _rootPane{ nullptr };
-        std::shared_ptr<Pane> _activePane{ nullptr };
-        std::shared_ptr<Pane> _zoomedPane{ nullptr };
-
-        Windows::UI::Xaml::Controls::MenuFlyoutItem _closePaneMenuItem;
-        Windows::UI::Xaml::Controls::MenuFlyoutItem _restartConnectionMenuItem;
-
-        winrt::Microsoft::Terminal::Settings::Model::IconStyle _lastIconStyle;
-        winrt::hstring _lastIconPath{};
-        std::optional<winrt::Windows::UI::Color> _runtimeTabColor{};
-        winrt::TerminalApp::TabHeaderControl _headerControl{};
-        winrt::TerminalApp::TerminalTabStatus _tabStatus{};
-
-        winrt::TerminalApp::ColorPickupFlyout _tabColorPickup{ nullptr };
-        winrt::event_token _colorSelectedToken;
-        winrt::event_token _colorClearedToken;
-        winrt::event_token _pickerClosedToken;
-
-        struct ContentEventTokens
-        {
-            winrt::TerminalApp::IPaneContent::BellRequested_revoker BellRequested;
-            winrt::TerminalApp::IPaneContent::TitleChanged_revoker TitleChanged;
-            winrt::TerminalApp::IPaneContent::TabColorChanged_revoker TabColorChanged;
-            winrt::TerminalApp::IPaneContent::TaskbarProgressChanged_revoker TaskbarProgressChanged;
-            winrt::TerminalApp::IPaneContent::ConnectionStateChanged_revoker ConnectionStateChanged;
-            winrt::TerminalApp::IPaneContent::ReadOnlyChanged_revoker ReadOnlyChanged;
-            winrt::TerminalApp::IPaneContent::FocusRequested_revoker FocusRequested;
-            winrt::TerminalApp::IPaneContent::CloseRequested_revoker CloseRequested;
-
-            // These events literally only apply if the content is a TermControl.
-            winrt::Microsoft::Terminal::Control::TermControl::KeySent_revoker KeySent;
-            winrt::Microsoft::Terminal::Control::TermControl::CharSent_revoker CharSent;
-            winrt::Microsoft::Terminal::Control::TermControl::StringSent_revoker StringSent;
-
-            winrt::TerminalApp::TerminalPaneContent::RestartTerminalRequested_revoker RestartTerminalRequested;
-        };
-        std::unordered_map<uint32_t, ContentEventTokens> _contentEvents;
-
-        winrt::event_token _rootClosedToken{};
-
-        std::vector<uint32_t> _mruPanes;
-        uint32_t _nextPaneId{ 0 };
-
-        bool _receivedKeyDown{ false };
-        bool _iconHidden{ false };
-        bool _changingActivePane{ false };
-
-        winrt::hstring _runtimeTabText{};
-        bool _inRename{ false };
-        winrt::Windows::UI::Xaml::Controls::TextBox::LayoutUpdated_revoker _tabRenameBoxLayoutUpdatedRevoker;
-
-        void _Setup();
-
-        SafeDispatcherTimer _bellIndicatorTimer;
-        void _BellIndicatorTimerTick(const Windows::Foundation::IInspectable& sender, const Windows::Foundation::IInspectable& e);
-
-        void _MakeTabViewItem() override;
-
-        void _UpdateHeaderControlMaxWidth();
-
-        void _CreateContextMenu() override;
-        virtual winrt::hstring _CreateToolTipTitle() override;
-
-        void _DetachEventHandlersFromContent(const uint32_t paneId);
-        void _AttachEventHandlersToContent(const uint32_t paneId, const winrt::TerminalApp::IPaneContent& content);
-        void _AttachEventHandlersToPane(std::shared_ptr<Pane> pane);
-
-        void _UpdateActivePane(std::shared_ptr<Pane> pane);
-
-        winrt::hstring _GetActiveTitle() const;
-
-        void _RecalculateAndApplyReadOnly();
-
-        void _UpdateProgressState();
-
-        void _UpdateConnectionClosedState();
-        void _RestartActivePaneConnection();
-
-        void _DuplicateTab();
-
-        virtual winrt::Windows::UI::Xaml::Media::Brush _BackgroundBrush() override;
-
-        void _addBroadcastHandlers(const winrt::Microsoft::Terminal::Control::TermControl& control, ContentEventTokens& events);
-
-        void _chooseColorClicked(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::RoutedEventArgs& e);
-        void _renameTabClicked(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::RoutedEventArgs& e);
-        void _duplicateTabClicked(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::RoutedEventArgs& e);
-        void _splitTabClicked(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::RoutedEventArgs& e);
-        void _closePaneClicked(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::RoutedEventArgs& e);
-        void _exportTextClicked(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::RoutedEventArgs& e);
-        void _moveTabToNewWindowClicked(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::RoutedEventArgs& e);
-        void _findClicked(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::RoutedEventArgs& e);
-
-        void _bubbleRestartTerminalRequested(TerminalApp::TerminalPaneContent sender, const winrt::Windows::Foundation::IInspectable& args);
-
-        friend class ::TerminalAppLocalTests::TabTests;
-    };
-}

src/cascadia/TerminalApp/TerminalTab.idl

@@ -1,13 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-import "TabBase.idl";
-import "TerminalTabStatus.idl";
-
-namespace TerminalApp
-{
-    [default_interface] runtimeclass TerminalTab : TabBase
-    {
-        TerminalTabStatus TabStatus { get; };
-    }
-}

src/cascadia/TerminalApp/dll/TerminalApp.vcxproj

@@ -35,8 +35,7 @@
     <ClInclude Include="../TitlebarControl.h" />
     <ClInclude Include="../TabRowControl.h" />
     <ClInclude Include="../App.h" />
-    <ClInclude Include="../TerminalTab.h" />
-    <ClInclude Include="../SettingsTab.h" />
+    <ClInclude Include="../TabBase.h" />
   </ItemGroup>
   <!-- ========================= Cpp Files ======================== -->
   <ItemGroup>