11680 SNAP LAYOUT

(cherry picked from commit b499d44d4baf21c279dbb9f3a766bc9c37528b62)

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

@@ -43,12 +43,14 @@ fullkbd
 futex
 GETDESKWALLPAPER
 GETHIGHCONTRAST
+GETMOUSEHOVERTIME
 Hashtable
 HIGHCONTRASTON
 HIGHCONTRASTW
 hotkeys
 href
 hrgn
+HTCLOSE
 IActivation
 IApp
 IAppearance
@@ -93,11 +95,14 @@ MENUINFO
 MENUITEMINFOW
 memicmp
 mptt
+MOUSELEAVE
 mov
 msappx
 MULTIPLEUSE
 NCHITTEST
 NCLBUTTONDBLCLK
+NCMOUSELEAVE
+NCMOUSEMOVE
 NCRBUTTONDBLCLK
 NIF
 NIN
@@ -163,9 +168,11 @@ TASKBARCREATED
 TBPF
 THEMECHANGED
 tlg
+TME
 tmp
 tolower
 toupper
+TRACKMOUSEEVENT
 TTask
 TVal
 UChar

src/cascadia/LocalTests_SettingsModel/TerminalSettingsTests.cpp

@@ -55,8 +55,12 @@ namespace SettingsModelLocalTests
         TerminalSettings settings;
         VERIFY_IS_NOT_NULL(settings);
         auto oldFontSize = settings.FontSize();
-        settings.FontSize(oldFontSize + 5);
-        auto newFontSize = settings.FontSize();
+
+        auto selfSettings = winrt::make_self<implementation::TerminalSettings>();
+        VERIFY_ARE_EQUAL(oldFontSize, selfSettings->FontSize());
+
+        selfSettings->FontSize(oldFontSize + 5);
+        auto newFontSize = selfSettings->FontSize();
         VERIFY_ARE_NOT_EQUAL(oldFontSize, newFontSize);
     }
 

src/cascadia/LocalTests_TerminalApp/TabTests.cpp

@@ -90,7 +90,6 @@ namespace TerminalAppLocalTests
         TEST_METHOD(TestWindowRenameSuccessful);
         TEST_METHOD(TestWindowRenameFailure);
 
-        TEST_METHOD(TestControlSettingsHasParent);
         TEST_METHOD(TestPreviewCommitScheme);
         TEST_METHOD(TestPreviewDismissScheme);
         TEST_METHOD(TestPreviewSchemeWhilePreviewing);
@@ -134,10 +133,6 @@ namespace TerminalAppLocalTests
         // Just creating it is enough to know that everything is working.
         TerminalSettings settings;
         VERIFY_IS_NOT_NULL(settings);
-        auto oldFontSize = settings.FontSize();
-        settings.FontSize(oldFontSize + 5);
-        auto newFontSize = settings.FontSize();
-        VERIFY_ARE_NOT_EQUAL(oldFontSize, newFontSize);
     }
 
     void TabTests::TryCreateConnectionType()
@@ -1297,25 +1292,6 @@ namespace TerminalAppLocalTests
         });
     }
 
-    void TabTests::TestControlSettingsHasParent()
-    {
-        Log::Comment(L"Ensure that when we create a control, it always has a parent TerminalSettings");
-
-        auto page = _commonSetup();
-        VERIFY_IS_NOT_NULL(page);
-
-        TestOnUIThread([&page]() {
-            const auto& activeControl{ page->_GetActiveControl() };
-            VERIFY_IS_NOT_NULL(activeControl);
-
-            const auto& controlSettings = activeControl.Settings().as<TerminalSettings>();
-            VERIFY_IS_NOT_NULL(controlSettings);
-
-            const auto& originalSettings = controlSettings.GetParent();
-            VERIFY_IS_NOT_NULL(originalSettings);
-        });
-    }
-
     void TabTests::TestPreviewCommitScheme()
     {
         Log::Comment(L"Preview a color scheme. Make sure it's applied, then committed accordingly");
@@ -1327,12 +1303,9 @@ namespace TerminalAppLocalTests
             const auto& activeControl{ page->_GetActiveControl() };
             VERIFY_IS_NOT_NULL(activeControl);
 
-            const auto& controlSettings = activeControl.Settings().as<TerminalSettings>();
+            const auto& controlSettings = activeControl.Settings();
             VERIFY_IS_NOT_NULL(controlSettings);
 
-            const auto& originalSettings = controlSettings.GetParent();
-            VERIFY_IS_NOT_NULL(originalSettings);
-
             VERIFY_ARE_EQUAL(til::color{ 0xff0c0c0c }, controlSettings.DefaultBackground());
         });
 
@@ -1346,17 +1319,12 @@ namespace TerminalAppLocalTests
             const auto& activeControl{ page->_GetActiveControl() };
             VERIFY_IS_NOT_NULL(activeControl);
 
-            const auto& controlSettings = activeControl.Settings().as<TerminalSettings>();
+            const auto& controlSettings = activeControl.Settings();
             VERIFY_IS_NOT_NULL(controlSettings);
 
-            const auto& previewSettings = controlSettings.GetParent();
-            VERIFY_IS_NOT_NULL(previewSettings);
-
-            const auto& originalSettings = previewSettings.GetParent();
-            VERIFY_IS_NOT_NULL(originalSettings);
-
             Log::Comment(L"Color should be changed to the preview");
             VERIFY_ARE_EQUAL(til::color{ 0xff000000 }, controlSettings.DefaultBackground());
+
             // And we should have stored a function to revert the change.
             VERIFY_ARE_EQUAL(1u, page->_restorePreviewFuncs.size());
         });
@@ -1373,20 +1341,22 @@ namespace TerminalAppLocalTests
             const auto& activeControl{ page->_GetActiveControl() };
             VERIFY_IS_NOT_NULL(activeControl);
 
-            const auto& controlSettings = activeControl.Settings().as<TerminalSettings>();
+            const auto& controlSettings = activeControl.Settings();
             VERIFY_IS_NOT_NULL(controlSettings);
 
-            const auto& originalSettings = controlSettings.GetParent();
-            VERIFY_IS_NOT_NULL(originalSettings);
-
-            const auto& grandparentSettings = originalSettings.GetParent();
-            VERIFY_IS_NULL(grandparentSettings);
-
             Log::Comment(L"Color should be changed");
             VERIFY_ARE_EQUAL(til::color{ 0xff000000 }, controlSettings.DefaultBackground());
+
             // After preview there should be no more restore functions to execute.
             VERIFY_ARE_EQUAL(0u, page->_restorePreviewFuncs.size());
         });
+
+        Log::Comment(L"Sleep to let events propagate");
+        // If you don't do this, we will _sometimes_ crash as we're tearing down
+        // the control from this test as we start the next one. We crash
+        // somewhere in the CursorPositionChanged handler. It's annoying, but
+        // this works.
+        Sleep(250);
     }
 
     void TabTests::TestPreviewDismissScheme()
@@ -1400,12 +1370,9 @@ namespace TerminalAppLocalTests
             const auto& activeControl{ page->_GetActiveControl() };
             VERIFY_IS_NOT_NULL(activeControl);
 
-            const auto& controlSettings = activeControl.Settings().as<TerminalSettings>();
+            const auto& controlSettings = activeControl.Settings();
             VERIFY_IS_NOT_NULL(controlSettings);
 
-            const auto& originalSettings = controlSettings.GetParent();
-            VERIFY_IS_NOT_NULL(originalSettings);
-
             VERIFY_ARE_EQUAL(til::color{ 0xff0c0c0c }, controlSettings.DefaultBackground());
         });
 
@@ -1419,15 +1386,9 @@ namespace TerminalAppLocalTests
             const auto& activeControl{ page->_GetActiveControl() };
             VERIFY_IS_NOT_NULL(activeControl);
 
-            const auto& controlSettings = activeControl.Settings().as<TerminalSettings>();
+            const auto& controlSettings = activeControl.Settings();
             VERIFY_IS_NOT_NULL(controlSettings);
 
-            const auto& previewSettings = controlSettings.GetParent();
-            VERIFY_IS_NOT_NULL(previewSettings);
-
-            const auto& originalSettings = previewSettings.GetParent();
-            VERIFY_IS_NOT_NULL(originalSettings);
-
             Log::Comment(L"Color should be changed to the preview");
             VERIFY_ARE_EQUAL(til::color{ 0xff000000 }, controlSettings.DefaultBackground());
         });
@@ -1441,18 +1402,14 @@ namespace TerminalAppLocalTests
             const auto& activeControl{ page->_GetActiveControl() };
             VERIFY_IS_NOT_NULL(activeControl);
 
-            const auto& controlSettings = activeControl.Settings().as<TerminalSettings>();
+            const auto& controlSettings = activeControl.Settings();
             VERIFY_IS_NOT_NULL(controlSettings);
 
-            const auto& originalSettings = controlSettings.GetParent();
-            VERIFY_IS_NOT_NULL(originalSettings);
-
-            const auto& grandparentSettings = originalSettings.GetParent();
-            VERIFY_IS_NULL(grandparentSettings);
-
             Log::Comment(L"Color should be the same as it originally was");
             VERIFY_ARE_EQUAL(til::color{ 0xff0c0c0c }, controlSettings.DefaultBackground());
         });
+        Log::Comment(L"Sleep to let events propagate");
+        Sleep(250);
     }
 
     void TabTests::TestPreviewSchemeWhilePreviewing()
@@ -1468,12 +1425,9 @@ namespace TerminalAppLocalTests
             const auto& activeControl{ page->_GetActiveControl() };
             VERIFY_IS_NOT_NULL(activeControl);
 
-            const auto& controlSettings = activeControl.Settings().as<TerminalSettings>();
+            const auto& controlSettings = activeControl.Settings();
             VERIFY_IS_NOT_NULL(controlSettings);
 
-            const auto& originalSettings = controlSettings.GetParent();
-            VERIFY_IS_NOT_NULL(originalSettings);
-
             VERIFY_ARE_EQUAL(til::color{ 0xff0c0c0c }, controlSettings.DefaultBackground());
         });
 
@@ -1487,15 +1441,9 @@ namespace TerminalAppLocalTests
             const auto& activeControl{ page->_GetActiveControl() };
             VERIFY_IS_NOT_NULL(activeControl);
 
-            const auto& controlSettings = activeControl.Settings().as<TerminalSettings>();
+            const auto& controlSettings = activeControl.Settings();
             VERIFY_IS_NOT_NULL(controlSettings);
 
-            const auto& previewSettings = controlSettings.GetParent();
-            VERIFY_IS_NOT_NULL(previewSettings);
-
-            const auto& originalSettings = previewSettings.GetParent();
-            VERIFY_IS_NOT_NULL(originalSettings);
-
             Log::Comment(L"Color should be changed to the preview");
             VERIFY_ARE_EQUAL(til::color{ 0xff000000 }, controlSettings.DefaultBackground());
         });
@@ -1510,15 +1458,9 @@ namespace TerminalAppLocalTests
             const auto& activeControl{ page->_GetActiveControl() };
             VERIFY_IS_NOT_NULL(activeControl);
 
-            const auto& controlSettings = activeControl.Settings().as<TerminalSettings>();
+            const auto& controlSettings = activeControl.Settings();
             VERIFY_IS_NOT_NULL(controlSettings);
 
-            const auto& previewSettings = controlSettings.GetParent();
-            VERIFY_IS_NOT_NULL(previewSettings);
-
-            const auto& originalSettings = previewSettings.GetParent();
-            VERIFY_IS_NOT_NULL(originalSettings);
-
             Log::Comment(L"Color should be changed to the preview");
             VERIFY_ARE_EQUAL(til::color{ 0xffFAFAFA }, controlSettings.DefaultBackground());
         });
@@ -1535,18 +1477,14 @@ namespace TerminalAppLocalTests
             const auto& activeControl{ page->_GetActiveControl() };
             VERIFY_IS_NOT_NULL(activeControl);
 
-            const auto& controlSettings = activeControl.Settings().as<TerminalSettings>();
+            const auto& controlSettings = activeControl.Settings();
             VERIFY_IS_NOT_NULL(controlSettings);
 
-            const auto& originalSettings = controlSettings.GetParent();
-            VERIFY_IS_NOT_NULL(originalSettings);
-
-            const auto& grandparentSettings = originalSettings.GetParent();
-            VERIFY_IS_NULL(grandparentSettings);
-
             Log::Comment(L"Color should be changed");
             VERIFY_ARE_EQUAL(til::color{ 0xffFAFAFA }, controlSettings.DefaultBackground());
         });
+        Log::Comment(L"Sleep to let events propagate");
+        Sleep(250);
     }
 
     void TabTests::TestClampSwitchToTab()

src/cascadia/LocalTests_TerminalApp/TerminalApp.LocalTests.vcxproj

@@ -43,7 +43,8 @@
     <ClCompile Include="CommandlineTest.cpp" />
     <ClCompile Include="SettingsTests.cpp" />
     <ClCompile Include="TabTests.cpp" />
-	<ClCompile Include="FilteredCommandTests.cpp" />
+    <ClCompile Include="TrustCommandlineTests.cpp" />
+    <ClCompile Include="FilteredCommandTests.cpp" />
     <ClCompile Include="pch.cpp">
       <PrecompiledHeader>Create</PrecompiledHeader>
     </ClCompile>

src/cascadia/LocalTests_TerminalApp/TrustCommandlineTests.cpp

@@ -0,0 +1,123 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+//
+// A series of tests for the TerminalPage::_isTrustedCommandline function.
+// That's a heuristic function for deciding if we should automatically trust
+// certain commandlines by default. The logic in there is weird and there are
+// lots of edge cases, so it's easier to just write a unit test.
+
+#include "pch.h"
+
+#include "../TerminalApp/TerminalPage.h"
+
+using namespace Microsoft::Console;
+using namespace TerminalApp;
+using namespace winrt::TerminalApp;
+using namespace winrt::Microsoft::Terminal::Settings::Model;
+
+using namespace WEX::Logging;
+using namespace WEX::TestExecution;
+using namespace WEX::Common;
+
+using namespace winrt::Windows::ApplicationModel::DataTransfer;
+using namespace winrt::Windows::Foundation::Collections;
+using namespace winrt::Windows::System;
+using namespace winrt::Windows::UI::Xaml;
+using namespace winrt::Windows::UI::Xaml::Controls;
+using namespace winrt::Windows::UI::Core;
+using namespace winrt::Windows::UI::Text;
+
+namespace winrt
+{
+    namespace MUX = Microsoft::UI::Xaml;
+    namespace WUX = Windows::UI::Xaml;
+    using IInspectable = Windows::Foundation::IInspectable;
+}
+
+namespace TerminalAppLocalTests
+{
+    class TrustCommandlineTests
+    {
+        BEGIN_TEST_CLASS(TrustCommandlineTests)
+        END_TEST_CLASS()
+
+        TEST_METHOD(SimpleTests);
+        TEST_METHOD(TestCommandlineWithArgs);
+        TEST_METHOD(TestCommandlineWithSpaces);
+        TEST_METHOD(TestCommandlineWithEnvVars);
+        TEST_METHOD(WslTests);
+        TEST_METHOD(TestPwshLocation);
+
+        bool trust(std::wstring_view cmdline);
+    };
+
+    bool TrustCommandlineTests::trust(std::wstring_view cmdline)
+    {
+        return implementation::TerminalPage::_isTrustedCommandline(cmdline);
+    }
+
+    void TrustCommandlineTests::SimpleTests()
+    {
+        VERIFY_IS_TRUE(trust(L"C:\\Windows\\System32\\cmd.exe"));
+        VERIFY_IS_TRUE(trust(L"C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe"));
+        VERIFY_IS_FALSE(trust(L"C:\\Windows\\System32\\i-definitely-don't-exist.exe"));
+
+        Log::Comment(L"These are not fully qualified, and _shouldn't_ be trusted");
+        VERIFY_IS_FALSE(trust(L"cmd.exe"));
+        VERIFY_IS_FALSE(trust(L"powershell.exe"));
+    }
+
+    void TrustCommandlineTests::TestCommandlineWithArgs()
+    {
+        Log::Comment(L"These are sneaky things that _shouldn't_ be trusted");
+        VERIFY_IS_FALSE(trust(L"C:\\Windows\\System32\\cmd.exe /k echo Boo!"));
+        VERIFY_IS_FALSE(trust(L"C:\\Windows\\System32\\cmd.exe /k echo Boo! & cmd.exe"));
+    }
+
+    void TrustCommandlineTests::TestCommandlineWithSpaces()
+    {
+        Log::Comment(L"This is a valid place for powershell to live, and the space can be tricky");
+        VERIFY_IS_TRUE(trust(L"C:\\Program Files\\PowerShell\\7\\pwsh.exe"));
+
+        Log::Comment(L"These are sneaky things that _shouldn't_ be trusted");
+        VERIFY_IS_FALSE(trust(L"C:\\Windows\\System 32\\cmd.exe"));
+        VERIFY_IS_FALSE(trust(L"C:\\Windows\\System32\\ cmd.exe"));
+        VERIFY_IS_FALSE(trust(L"C:\\Windows\\System32\\cmd.exe /c cmd.exe"));
+    }
+
+    void TrustCommandlineTests::TestCommandlineWithEnvVars()
+    {
+        Log::Comment(L"Make sure we auto-expand environment variables");
+
+        VERIFY_IS_TRUE(trust(L"%WINDIR%\\system32\\cmd.exe"));
+        VERIFY_IS_TRUE(trust(L"%WINDIR%\\system32\\WindowsPowerShell\\v1.0\\powershell.exe"));
+        VERIFY_IS_TRUE(trust(L"%ProgramFiles%\\PowerShell\\7\\pwsh.exe"));
+    }
+
+    void TrustCommandlineTests::WslTests()
+    {
+        Log::Comment(L"We are explicitly deciding to not auto-approve "
+                     L"`wsl.exe -d distro`-like commandlines. If we change this"
+                     L" policy, remove this test.");
+
+        VERIFY_IS_FALSE(trust(L"C:\\Windows\\System32\\wsl"));
+        VERIFY_IS_TRUE(trust(L"C:\\Windows\\System32\\wsl.exe"), L"This we will trust though, since it's an exe in system32");
+        VERIFY_IS_FALSE(trust(L"C:\\Windows\\System32\\wsl.exe -d Ubuntu"));
+        VERIFY_IS_FALSE(trust(L"wsl.exe"));
+    }
+
+    void TrustCommandlineTests::TestPwshLocation()
+    {
+        Log::Comment(L"Test various locations that pwsh.exe can be in");
+
+        VERIFY_IS_TRUE(trust(L"%ProgramFiles%\\PowerShell\\7\\pwsh.exe"));
+        VERIFY_IS_TRUE(trust(L"%LOCALAPPDATA%\\Microsoft\\WindowsApps\\pwsh.exe"));
+        VERIFY_IS_TRUE(trust(L"%ProgramFiles%\\PowerShell\\10\\pwsh.exe"));
+        VERIFY_IS_TRUE(trust(L"%ProgramFiles%\\PowerShell\\7.1.5\\pwsh.exe"));
+
+        Log::Comment(L"These are sneaky things that _shouldn't_ be trusted");
+        VERIFY_IS_FALSE(trust(L"%ProgramFiles%\\PowerShell\\7\\pwsh.exe bad-stuff pwsh.exe"));
+        VERIFY_IS_FALSE(trust(L"%ProgramFiles%\\PowerShell\\7\\pwsh.exe bad-stuff c:\\pwsh.exe"));
+        VERIFY_IS_FALSE(trust(L"%ProgramFiles%\\PowerShell\\7\\pwsh.exe bad-stuff c:\\ %ProgramFiles%\\PowerShell\\7\\pwsh.exe"));
+    }
+}

src/cascadia/TerminalApp/ActionPreviewHandlers.cpp

@@ -67,8 +67,12 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     void TerminalPage::_EndPreviewColorScheme()
     {
-        for (const auto& f : _restorePreviewFuncs)
+        // Apply the reverts in reverse order - If we had multiple previews
+        // stacked on top of each other, then this will ensure the first one in
+        // is the last one out.
+        for (auto i{ _restorePreviewFuncs.rbegin() }; i < _restorePreviewFuncs.rend(); i++)
         {
+            auto f = *i;
             f();
         }
         _restorePreviewFuncs.clear();
@@ -90,59 +94,18 @@ namespace winrt::TerminalApp::implementation
     {
         if (const auto& scheme{ _settings.GlobalSettings().ColorSchemes().TryLookup(args.SchemeName()) })
         {
-            // Clear the saved preview funcs because we don't need to add a restore each time
-            // the preview color changes, we only need to be able to restore the last one.
-            _restorePreviewFuncs.clear();
-
             _ApplyToActiveControls([&](const auto& control) {
-                // Get the settings of the focused control and stash them
-                const auto& controlSettings = control.Settings().as<TerminalSettings>();
-                // Make sure to recurse up to the root - if you're doing
-                // this while you're currently previewing a SetColorScheme
-                // action, then the parent of the control's settings is _the
-                // last preview TerminalSettings we inserted! We don't want
-                // to save that one!
-                auto originalSettings = controlSettings.GetParent();
-                while (originalSettings.GetParent() != nullptr)
-                {
-                    originalSettings = originalSettings.GetParent();
-                }
-                // Create a new child for those settings
-                TerminalSettingsCreateResult fake{ originalSettings };
-                const auto& childStruct = TerminalSettings::CreateWithParent(fake);
-                // Modify the child to have the applied color scheme
-                childStruct.DefaultSettings().ApplyColorScheme(scheme);
+                // Stash a copy of the current scheme.
+                auto originalScheme{ control.ColorScheme() };
 
-                // Insert that new child as the parent of the control's settings
-                controlSettings.SetParent(childStruct.DefaultSettings());
-                control.UpdateSettings();
+                // Apply the new scheme.
+                control.ColorScheme(scheme.ToCoreScheme());
 
-                // Take a copy of the inputs, since they are pointers anyways.
+                // Each control will emplace a revert into the
+                // _restorePreviewFuncs for itself.
                 _restorePreviewFuncs.emplace_back([=]() {
-                    // Get the runtime settings of the focused control
-                    const auto& controlSettings{ control.Settings().as<TerminalSettings>() };
-
-                    // Get the control's root settings, the ones that we actually
-                    // assigned to it.
-                    auto parentSettings{ controlSettings.GetParent() };
-                    while (parentSettings.GetParent() != nullptr)
-                    {
-                        parentSettings = parentSettings.GetParent();
-                    }
-
-                    // If the root settings are the same as the ones we stashed,
-                    // then reset the parent of the runtime settings to the stashed
-                    // settings. This condition might be false if the settings
-                    // hot-reloaded while the palette was open. In that case, we
-                    // don't want to reset the settings to what they were _before_
-                    // the hot-reload.
-                    if (originalSettings == parentSettings)
-                    {
-                        // Set the original settings as the parent of the control's settings
-                        control.Settings().as<TerminalSettings>().SetParent(originalSettings);
-                    }
-
-                    control.UpdateSettings();
+                    // On dismiss, restore the original scheme.
+                    control.ColorScheme(originalScheme);
                 });
             });
         }

src/cascadia/TerminalApp/AdminWarningPlaceholder.cpp

@@ -0,0 +1,74 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#pragma once
+
+#include "pch.h"
+#include "AdminWarningPlaceholder.h"
+#include "AdminWarningPlaceholder.g.cpp"
+#include <LibraryResources.h>
+using namespace winrt::Windows::UI::Xaml;
+
+namespace winrt::TerminalApp::implementation
+{
+    AdminWarningPlaceholder::AdminWarningPlaceholder(const winrt::Microsoft::Terminal::Control::TermControl& control, const winrt::hstring& cmdline) :
+        _control{ control },
+        _Commandline{ cmdline }
+    {
+        InitializeComponent();
+        // If the content we're hosting is a TermControl, then use the control's
+        // BG as our BG, to give the impression that it's there, under the
+        // dialog.
+        if (const auto termControl{ control.try_as<winrt::Microsoft::Terminal::Control::TermControl>() })
+        {
+            RootGrid().Background(termControl.BackgroundBrush());
+        }
+    }
+    void AdminWarningPlaceholder::_primaryButtonClick(winrt::Windows::Foundation::IInspectable const& /*sender*/,
+                                                      RoutedEventArgs const& e)
+    {
+        _PrimaryButtonClickedHandlers(*this, e);
+    }
+    void AdminWarningPlaceholder::_cancelButtonClick(winrt::Windows::Foundation::IInspectable const& /*sender*/,
+                                                     RoutedEventArgs const& e)
+    {
+        _CancelButtonClickedHandlers(*this, e);
+    }
+    winrt::Windows::UI::Xaml::Controls::UserControl AdminWarningPlaceholder::Control()
+    {
+        return _control;
+    }
+
+    // Method Description:
+    // - Move the focus to the cancel button by default. This has the LOAD
+    //   BEARING side effect of also triggering Narrator to read out the
+    //   contents of the dialog. It's unclear why doing this works, but it does.
+    // - Using a LayoutUpdated event to trigger the focus change when we're
+    //   added to the UI tree did not seem to work.
+    // - Whoever is adding us to the UI tree is responsible for calling this!
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void AdminWarningPlaceholder::FocusOnLaunch()
+    {
+        CancelButton().Focus(FocusState::Programmatic);
+    }
+
+    winrt::hstring AdminWarningPlaceholder::ControlName()
+    {
+        return RS_(L"AdminWarningPlaceholderName");
+    }
+
+    void AdminWarningPlaceholder::_keyUpHandler(IInspectable const& /*sender*/,
+                                                Windows::UI::Xaml::Input::KeyRoutedEventArgs const& e)
+    {
+        // If the user presses escape, close the dialog (without confirming)
+        const auto key = e.OriginalKey();
+        if (key == winrt::Windows::System::VirtualKey::Escape)
+        {
+            _CancelButtonClickedHandlers(*this, e);
+            e.Handled(true);
+        }
+    }
+}

src/cascadia/TerminalApp/AdminWarningPlaceholder.h

@@ -0,0 +1,51 @@
+/*++
+Copyright (c) Microsoft Corporation
+Licensed under the MIT license.
+
+Module Name:
+- AdminWarningPlaceholder
+
+Abstract:
+- The AdminWarningPlaceholder is a control used to fill space in a pane and
+  present a warning to the user. It holds on to a real control that it should be
+  replaced with. It looks just like a ContentDialog, except it exists per-pane,
+  whereas a ContentDialog can only be added to take up the whole window.
+- The caller should make sure to bind our PrimaryButtonClicked and
+  CancelButtonClicked events, to be informed as to which was pressed.
+
+Author(s):
+- Mike Griese - September 2021
+
+--*/
+
+#pragma once
+
+#include "AdminWarningPlaceholder.g.h"
+#include "../../cascadia/inc/cppwinrt_utils.h"
+
+namespace winrt::TerminalApp::implementation
+{
+    struct AdminWarningPlaceholder : AdminWarningPlaceholderT<AdminWarningPlaceholder>
+    {
+        AdminWarningPlaceholder(const winrt::Microsoft::Terminal::Control::TermControl& control, const winrt::hstring& cmdline);
+        void FocusOnLaunch();
+        winrt::Windows::UI::Xaml::Controls::UserControl Control();
+        winrt::hstring ControlName();
+        WINRT_CALLBACK(PropertyChanged, Windows::UI::Xaml::Data::PropertyChangedEventHandler);
+        WINRT_OBSERVABLE_PROPERTY(winrt::hstring, Commandline, _PropertyChangedHandlers);
+        TYPED_EVENT(PrimaryButtonClicked, TerminalApp::AdminWarningPlaceholder, winrt::Windows::UI::Xaml::RoutedEventArgs);
+        TYPED_EVENT(CancelButtonClicked, TerminalApp::AdminWarningPlaceholder, winrt::Windows::UI::Xaml::RoutedEventArgs);
+
+    private:
+        friend struct AdminWarningPlaceholderT<AdminWarningPlaceholder>; // friend our parent so it can bind private event handlers
+
+        winrt::Microsoft::Terminal::Control::TermControl _control{ nullptr };
+
+        void _primaryButtonClick(winrt::Windows::Foundation::IInspectable const& sender,
+                                 winrt::Windows::UI::Xaml::RoutedEventArgs const& e);
+        void _cancelButtonClick(winrt::Windows::Foundation::IInspectable const& sender,
+                                winrt::Windows::UI::Xaml::RoutedEventArgs const& e);
+        void _keyUpHandler(Windows::Foundation::IInspectable const& sender,
+                           Windows::UI::Xaml::Input::KeyRoutedEventArgs const& e);
+    };
+}

src/cascadia/TerminalApp/AdminWarningPlaceholder.idl

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+namespace TerminalApp
+{
+    [default_interface] runtimeclass AdminWarningPlaceholder : Windows.UI.Xaml.Controls.UserControl,
+                                                               Windows.UI.Xaml.Data.INotifyPropertyChanged
+    {
+        String Commandline { get; };
+        String ControlName { get; };
+    }
+}

src/cascadia/TerminalApp/AdminWarningPlaceholder.xaml

@@ -0,0 +1,97 @@
+<!--
+    Copyright (c) Microsoft Corporation. All rights reserved. Licensed under
+    the MIT License. See LICENSE in the project root for license information.
+-->
+<UserControl x:Class="TerminalApp.AdminWarningPlaceholder"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:local="using:TerminalApp"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:mux="using:Microsoft.UI.Xaml.Controls"
+             AutomationProperties.AccessibilityView="Content"
+             AutomationProperties.IsDialog="True"
+             AutomationProperties.Name="{x:Bind ControlName, Mode=OneWay}"
+             PreviewKeyUp="_keyUpHandler"
+             mc:Ignorable="d">
+
+    <!--
+        We have to use two grids to be tricky here:
+        - The outer grid will get its background from the control it hosts, and
+        expands to fit its container. This will make it look like the background
+        fills the space available.
+        - The inner grid is set to Center,Center, so that the "dialog" appears
+        centered
+    -->
+
+    <Grid x:Name="RootGrid"
+          HorizontalAlignment="Stretch"
+          VerticalAlignment="Stretch">
+        <Grid HorizontalAlignment="Center"
+              VerticalAlignment="Center">
+            <Border Margin="8,8,8,8"
+                    Padding="16,8,16,8"
+                    AllowFocusOnInteraction="True"
+                    AutomationProperties.AccessibilityView="Raw"
+                    AutomationProperties.IsDialog="True"
+                    Background="{ThemeResource SystemControlBackgroundAltHighBrush}"
+                    BorderBrush="{ThemeResource SystemAccentColor}"
+                    BorderThickness="2,2,2,2"
+                    CornerRadius="{ThemeResource OverlayCornerRadius}">
+                <StackPanel Orientation="Vertical">
+                    <TextBlock x:Name="ApproveCommandlineWarningTitle"
+                               x:Uid="ApproveCommandlineWarningTitle"
+                               Padding="0,0,0,16"
+                               HorizontalAlignment="Left"
+                               FontSize="20"
+                               FontWeight="Normal"
+                               IsTextSelectionEnabled="True"
+                               TextWrapping="WrapWholeWords" />
+
+                    <TextBlock x:Name="PrefixTextBlock"
+                               x:Uid="ApproveCommandlineWarningPrefixTextBlock"
+                               HorizontalAlignment="Left"
+                               IsTextSelectionEnabled="True"
+                               TextWrapping="WrapWholeWords" />
+
+                    <TextBlock x:Name="CommandlineText"
+                               Margin="0,16,0,16"
+                               HorizontalAlignment="Left"
+                               FontFamily="Cascadia Mono"
+                               IsTextSelectionEnabled="True"
+                               Text="{x:Bind Commandline, Mode=OneWay}"
+                               TextWrapping="WrapWholeWords" />
+
+                    <TextBlock x:Name="SuffixTextBlock"
+                               x:Uid="ApproveCommandlineWarningSuffixTextBlock"
+                               HorizontalAlignment="Left"
+                               IsTextSelectionEnabled="True"
+                               TextWrapping="WrapWholeWords" />
+                    <Grid Margin="0,8,0,8"
+                          HorizontalAlignment="Stretch"
+                          XYFocusKeyboardNavigation="Enabled">
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="*" />
+                            <ColumnDefinition Width="*" />
+                        </Grid.ColumnDefinitions>
+                        <Button x:Name="PrimaryButton"
+                                x:Uid="ApproveCommandlineWarning_PrimaryButton"
+                                Grid.Column="0"
+                                Margin="0,0,8,0"
+                                HorizontalAlignment="Stretch"
+                                Click="_primaryButtonClick"
+                                IsTabStop="True"
+                                Style="{StaticResource AccentButtonStyle}" />
+                        <Button x:Name="CancelButton"
+                                x:Uid="ApproveCommandlineWarning_CancelButton"
+                                Grid.Column="1"
+                                HorizontalAlignment="Stretch"
+                                Click="_cancelButtonClick"
+                                IsTabStop="True" />
+                    </Grid>
+                </StackPanel>
+            </Border>
+        </Grid>
+    </Grid>
+
+</UserControl>

src/cascadia/TerminalApp/AppActionHandlers.cpp

@@ -451,28 +451,7 @@ namespace winrt::TerminalApp::implementation
             if (const auto scheme = _settings.GlobalSettings().ColorSchemes().TryLookup(realArgs.SchemeName()))
             {
                 const auto res = _ApplyToActiveControls([&](auto& control) {
-                    // Start by getting the current settings of the control
-                    auto controlSettings = control.Settings().as<TerminalSettings>();
-                    auto parentSettings = controlSettings;
-                    // Those are the _runtime_ settings however. What we
-                    // need to do is:
-                    //
-                    //   1. Blow away any colors set in the runtime settings.
-                    //   2. Apply the color scheme to the parent settings.
-                    //
-                    // 1 is important to make sure that the effects of
-                    // something like `colortool` are cleared when setting
-                    // the scheme.
-                    if (controlSettings.GetParent() != nullptr)
-                    {
-                        parentSettings = controlSettings.GetParent();
-                    }
-
-                    // ApplyColorScheme(nullptr) will clear the old color scheme.
-                    controlSettings.ApplyColorScheme(nullptr);
-                    parentSettings.ApplyColorScheme(scheme);
-
-                    control.UpdateSettings();
+                    control.ColorScheme(scheme.ToCoreScheme());
                 });
                 args.Handled(res);
             }

src/cascadia/TerminalApp/MinMaxCloseControl.cpp

@@ -1,25 +1,67 @@
-// Copyright (c) Microsoft Corporation.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
-//
-// MinMaxCloseControl.xaml.cpp
-// Implementation of the MinMaxCloseControl class
-//
 
 #include "pch.h"
 
 #include "MinMaxCloseControl.h"
-
 #include "MinMaxCloseControl.g.cpp"
-
 #include <LibraryResources.h>
 
 using namespace winrt::Windows::UI::Xaml;
 
 namespace winrt::TerminalApp::implementation
 {
+    static void closeToolTipForButton(const Controls::Button& button)
+    {
+        if (auto tt{ Controls::ToolTipService::GetToolTip(button) })
+        {
+            if (auto tooltip{ tt.try_as<Controls::ToolTip>() })
+            {
+                tooltip.IsOpen(false);
+            }
+        }
+    }
+
     MinMaxCloseControl::MinMaxCloseControl()
     {
+        // Get our dispatcher. This will get us the same dispatcher as
+        // Dispatcher(), but it's a DispatcherQueue, so we can use it with
+        // ThrottledFunc
+        auto dispatcher = winrt::Windows::System::DispatcherQueue::GetForCurrentThread();
+
         InitializeComponent();
+
+        // Get the tooltip hover time from the system, or default to 400ms
+        // (which should be the default, see:
+        // https://docs.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-trackmouseevent#remarks)
+        unsigned int hoverTimeoutMillis{ 400 };
+        LOG_IF_WIN32_BOOL_FALSE(SystemParametersInfoW(SPI_GETMOUSEHOVERTIME, 0, &hoverTimeoutMillis, 0));
+        const auto toolTipInterval = std::chrono::milliseconds(hoverTimeoutMillis);
+
+        // Create a ThrottledFunc for opening the tooltip after the hover
+        // timeout. If we hover another button, we should make sure to call
+        // Run() with the new button. Calling `_displayToolTip.Run(nullptr)`,
+        // which will cause us to not display a tooltip, which is used when we
+        // leave the control entirely.
+        _displayToolTip = std::make_shared<ThrottledFuncTrailing<Controls::Button>>(
+            dispatcher,
+            toolTipInterval,
+            [weakThis = get_weak()](Controls::Button button) {
+                // If we provide a button, then open the tooltip on that button.
+                // We can "dismiss" this throttled func by calling it with null,
+                // which will cause us to do nothing at the end of the timeout
+                // instead.
+                if (button)
+                {
+                    if (auto tt{ Controls::ToolTipService::GetToolTip(button) })
+                    {
+                        if (auto tooltip{ tt.try_as<Controls::ToolTip>() })
+                        {
+                            tooltip.IsOpen(true);
+                        }
+                    }
+                }
+            });
     }
 
     // These event handlers simply forward each buttons click events up to the
@@ -95,4 +137,104 @@ namespace winrt::TerminalApp::implementation
             break;
         }
     }
+
+    // Method Description:
+    // - Called when the mouse hovers a button.
+    //   - Transition that button to `PointerOver`
+    //   - run the throttled func with this button, to display the tooltip after
+    //     a timeout
+    //   - dismiss any open tooltips on other buttons.
+    // Arguments:
+    // - button: the button that was hovered
+    void MinMaxCloseControl::HoverButton(CaptionButton button)
+    {
+        // Keep track of the button that's been pressed. we get a mouse move
+        // message when we open the tooltip. If we move the mouse on top of this
+        // button, that we've already pressed, then no need to move to the
+        // "hovered" state, we should stay in the pressed state.
+        if (_lastPressedButton && _lastPressedButton.value() == button)
+        {
+            return;
+        }
+
+        switch (button)
+        {
+            // Make sure to use true for the useTransitions parameter, to
+            // animate the fade in/out transition between colors.
+        case CaptionButton::Minimize:
+            VisualStateManager::GoToState(MinimizeButton(), L"PointerOver", true);
+            VisualStateManager::GoToState(MaximizeButton(), L"Normal", true);
+            VisualStateManager::GoToState(CloseButton(), L"Normal", true);
+
+            _displayToolTip->Run(MinimizeButton());
+            closeToolTipForButton(MaximizeButton());
+            closeToolTipForButton(CloseButton());
+            break;
+        case CaptionButton::Maximize:
+            VisualStateManager::GoToState(MinimizeButton(), L"Normal", true);
+            VisualStateManager::GoToState(MaximizeButton(), L"PointerOver", true);
+            VisualStateManager::GoToState(CloseButton(), L"Normal", true);
+
+            closeToolTipForButton(MinimizeButton());
+            _displayToolTip->Run(MaximizeButton());
+            closeToolTipForButton(CloseButton());
+            break;
+        case CaptionButton::Close:
+            VisualStateManager::GoToState(MinimizeButton(), L"Normal", true);
+            VisualStateManager::GoToState(MaximizeButton(), L"Normal", true);
+            VisualStateManager::GoToState(CloseButton(), L"PointerOver", true);
+
+            closeToolTipForButton(MinimizeButton());
+            closeToolTipForButton(MaximizeButton());
+            _displayToolTip->Run(CloseButton());
+            break;
+        }
+    }
+
+    // Method Description:
+    // - Called when the mouse presses down on a button. NOT when it is
+    //   released. That's handled one level above, in
+    //   TitleBarControl::ReleaseButtons
+    //   - Transition that button to `Pressed`
+    // Arguments:
+    // - button: the button that was pressed
+    void MinMaxCloseControl::PressButton(CaptionButton button)
+    {
+        switch (button)
+        {
+        case CaptionButton::Minimize:
+            VisualStateManager::GoToState(MinimizeButton(), L"Pressed", true);
+            VisualStateManager::GoToState(MaximizeButton(), L"Normal", true);
+            VisualStateManager::GoToState(CloseButton(), L"Normal", true);
+            break;
+        case CaptionButton::Maximize:
+            VisualStateManager::GoToState(MinimizeButton(), L"Normal", true);
+            VisualStateManager::GoToState(MaximizeButton(), L"Pressed", true);
+            VisualStateManager::GoToState(CloseButton(), L"Normal", true);
+            break;
+        case CaptionButton::Close:
+            VisualStateManager::GoToState(MinimizeButton(), L"Normal", true);
+            VisualStateManager::GoToState(MaximizeButton(), L"Normal", true);
+            VisualStateManager::GoToState(CloseButton(), L"Pressed", true);
+            break;
+        }
+        _lastPressedButton = button;
+    }
+
+    // Method Description:
+    // - Called when buttons are no longer hovered or pressed. Return them all
+    //   to the normal state, and dismiss the tooltips.
+    void MinMaxCloseControl::ReleaseButtons()
+    {
+        _displayToolTip->Run(nullptr);
+        VisualStateManager::GoToState(MinimizeButton(), L"Normal", true);
+        VisualStateManager::GoToState(MaximizeButton(), L"Normal", true);
+        VisualStateManager::GoToState(CloseButton(), L"Normal", true);
+
+        closeToolTipForButton(MinimizeButton());
+        closeToolTipForButton(MaximizeButton());
+        closeToolTipForButton(CloseButton());
+
+        _lastPressedButton = std::nullopt;
+    }
 }

src/cascadia/TerminalApp/MinMaxCloseControl.h

@@ -6,11 +6,9 @@
 
 #pragma once
 
-#include "winrt/Windows.UI.Xaml.h"
-#include "winrt/Windows.UI.Xaml.Markup.h"
-#include "winrt/Windows.UI.Xaml.Interop.h"
 #include "MinMaxCloseControl.g.h"
 #include "../../cascadia/inc/cppwinrt_utils.h"
+#include <ThrottledFunc.h>
 
 namespace winrt::TerminalApp::implementation
 {
@@ -20,6 +18,10 @@ namespace winrt::TerminalApp::implementation
 
         void SetWindowVisualState(WindowVisualState visualState);
 
+        void HoverButton(CaptionButton button);
+        void PressButton(CaptionButton button);
+        void ReleaseButtons();
+
         void _MinimizeClick(winrt::Windows::Foundation::IInspectable const& sender,
                             winrt::Windows::UI::Xaml::RoutedEventArgs const& e);
         void _MaximizeClick(winrt::Windows::Foundation::IInspectable const& sender,
@@ -30,6 +32,9 @@ namespace winrt::TerminalApp::implementation
         TYPED_EVENT(MinimizeClick, TerminalApp::MinMaxCloseControl, winrt::Windows::UI::Xaml::RoutedEventArgs);
         TYPED_EVENT(MaximizeClick, TerminalApp::MinMaxCloseControl, winrt::Windows::UI::Xaml::RoutedEventArgs);
         TYPED_EVENT(CloseClick, TerminalApp::MinMaxCloseControl, winrt::Windows::UI::Xaml::RoutedEventArgs);
+
+        std::shared_ptr<ThrottledFuncTrailing<winrt::Windows::UI::Xaml::Controls::Button>> _displayToolTip{ nullptr };
+        std::optional<CaptionButton> _lastPressedButton{ std::nullopt };
     };
 }
 

src/cascadia/TerminalApp/MinMaxCloseControl.idl

@@ -11,6 +11,10 @@ namespace TerminalApp
 
         void SetWindowVisualState(WindowVisualState visualState);
 
+        void HoverButton(CaptionButton button);
+        void PressButton(CaptionButton button);
+        void ReleaseButtons();
+
         event Windows.Foundation.TypedEventHandler<MinMaxCloseControl, Windows.UI.Xaml.RoutedEventArgs> MinimizeClick;
         event Windows.Foundation.TypedEventHandler<MinMaxCloseControl, Windows.UI.Xaml.RoutedEventArgs> MaximizeClick;
         event Windows.Foundation.TypedEventHandler<MinMaxCloseControl, Windows.UI.Xaml.RoutedEventArgs> CloseClick;

src/cascadia/TerminalApp/MinMaxCloseControl.xaml

@@ -220,7 +220,7 @@
     </StackPanel.Resources>
 
     <Button x:Name="MinimizeButton"
-            x:Uid="WindowMinimizeButton"
+            x:Uid="MinimizeButton"
             Width="46.0"
             Height="{StaticResource CaptionButtonHeightWindowed}"
             MinWidth="46.0"
@@ -232,9 +232,14 @@
                 <x:String x:Key="CaptionButtonPath">M 0 0 H 10</x:String>
             </ResourceDictionary>
         </Button.Resources>
+        <ToolTipService.ToolTip>
+            <ToolTip>
+                <TextBlock x:Uid="WindowMinimizeButtonToolTip" />
+            </ToolTip>
+        </ToolTipService.ToolTip>
     </Button>
     <Button x:Name="MaximizeButton"
-            x:Uid="WindowMaximizeButton"
+            x:Uid="MaximizeButton"
             Width="46.0"
             Height="{StaticResource CaptionButtonHeightWindowed}"
             MinWidth="46.0"
@@ -256,7 +261,7 @@
         </ToolTipService.ToolTip>
     </Button>
     <Button x:Name="CloseButton"
-            x:Uid="WindowCloseButton"
+            x:Uid="CloseButton"
             Width="46.0"
             Height="{StaticResource CaptionButtonHeightWindowed}"
             MinWidth="46.0"
@@ -309,5 +314,10 @@
                 <x:String x:Key="CaptionButtonPath">M 0 0 L 10 10 M 10 0 L 0 10</x:String>
             </ResourceDictionary>
         </Button.Resources>
+        <ToolTipService.ToolTip>
+            <ToolTip>
+                <TextBlock x:Uid="WindowCloseButtonToolTip" />
+            </ToolTip>
+        </ToolTipService.ToolTip>
     </Button>
 </StackPanel>

src/cascadia/TerminalApp/Pane.cpp

@@ -34,7 +34,7 @@ static const Duration AnimationDuration = DurationHelper::FromTimeSpan(winrt::Wi
 winrt::Windows::UI::Xaml::Media::SolidColorBrush Pane::s_focusedBorderBrush = { nullptr };
 winrt::Windows::UI::Xaml::Media::SolidColorBrush Pane::s_unfocusedBorderBrush = { nullptr };
 
-Pane::Pane(const Profile& profile, const TermControl& control, const bool lastFocused) :
+Pane::Pane(const Profile& profile, const Controls::UserControl& control, const bool lastFocused) :
     _control{ control },
     _lastActive{ lastFocused },
     _profile{ profile }
@@ -42,8 +42,11 @@ Pane::Pane(const Profile& profile, const TermControl& control, const bool lastFo
     _root.Children().Append(_borderFirst);
     _borderFirst.Child(_control);
 
-    _connectionStateChangedToken = _control.ConnectionStateChanged({ this, &Pane::_ControlConnectionStateChangedHandler });
-    _warningBellToken = _control.WarningBell({ this, &Pane::_ControlWarningBellHandler });
+    if (const auto& termControl{ _control.try_as<TermControl>() })
+    {
+        _connectionStateChangedToken = termControl.ConnectionStateChanged({ this, &Pane::_ControlConnectionStateChangedHandler });
+        _warningBellToken = termControl.WarningBell({ this, &Pane::_ControlWarningBellHandler });
+    }
 
     // On the first Pane's creation, lookup resources we'll use to theme the
     // Pane, including the brushed to use for the focused/unfocused border
@@ -125,11 +128,23 @@ NewTerminalArgs Pane::GetTerminalArgsForPane() const
     assert(_IsLeaf());
 
     NewTerminalArgs args{};
-    auto controlSettings = _control.Settings().as<TerminalSettings>();
+    auto termControl{ _control.try_as<TermControl>() };
+    if (!termControl)
+    {
+        if (auto adminWarning{ _control.try_as<AdminWarningPlaceholder>() })
+        {
+            termControl = adminWarning.Content().try_as<TermControl>();
+        }
+    }
+    if (!termControl)
+    {
+        return nullptr;
+    }
+    auto controlSettings = termControl.Settings();
 
     args.Profile(controlSettings.ProfileName());
     // If we know the user's working directory use it instead of the profile.
-    if (const auto dir = _control.WorkingDirectory(); !dir.empty())
+    if (const auto dir = termControl.WorkingDirectory(); !dir.empty())
     {
         args.StartingDirectory(dir);
     }
@@ -156,16 +171,13 @@ NewTerminalArgs Pane::GetTerminalArgsForPane() const
         args.TabColor(winrt::Windows::Foundation::IReference<winrt::Windows::UI::Color>(c));
     }
 
-    if (controlSettings.AppliedColorScheme())
-    {
-        auto name = controlSettings.AppliedColorScheme().Name();
-        // Only save the color scheme if it is different than the profile color
-        // scheme to not override any other profile appearance choices.
-        if (_profile.DefaultAppearance().ColorSchemeName() != name)
-        {
-            args.ColorScheme(name);
-        }
-    }
+    // TODO:GH#9800 - we used to be able to persist the color scheme that a
+    // TermControl was initialized with, by name. With the change to having the
+    // control own its own copy of its settings, this isn't possible anymore.
+    //
+    // We may be able to get around this by storing the Name in the Core::Scheme
+    // object. That would work for schemes set by the Terminal, but not ones set
+    // by VT, but that seems good enough.
 
     return args;
 }
@@ -832,6 +844,40 @@ bool Pane::SwapPanes(std::shared_ptr<Pane> first, std::shared_ptr<Pane> second)
     return false;
 }
 
+Controls::UserControl Pane::ReplaceControl(const Controls::UserControl& control)
+{
+    if (!_IsLeaf())
+    {
+        return nullptr;
+    }
+
+    // Remove old control's event handlers
+    const auto& oldControl = _control;
+    _gotFocusRevoker.revoke();
+    _lostFocusRevoker.revoke();
+    if (const auto& oldTermControl{ _control.try_as<TermControl>() })
+    {
+        oldTermControl.ConnectionStateChanged(_connectionStateChangedToken);
+        oldTermControl.WarningBell(_warningBellToken);
+    }
+
+    _control = control;
+
+    _borderFirst.Child(_control);
+
+    // Register an event with the control to have it inform us when it gains focus.
+    _gotFocusRevoker = _control.GotFocus(winrt::auto_revoke, { this, &Pane::_ControlGotFocusHandler });
+    _lostFocusRevoker = _control.LostFocus(winrt::auto_revoke, { this, &Pane::_ControlLostFocusHandler });
+
+    if (const auto& termControl{ _control.try_as<TermControl>() })
+    {
+        _connectionStateChangedToken = termControl.ConnectionStateChanged({ this, &Pane::_ControlConnectionStateChangedHandler });
+        _warningBellToken = termControl.WarningBell({ this, &Pane::_ControlWarningBellHandler });
+    }
+
+    return oldControl;
+}
+
 // Method Description:
 // - Given two panes' offsets, test whether the `direction` side of first is adjacent to second.
 // Arguments:
@@ -1079,8 +1125,12 @@ void Pane::_ControlConnectionStateChangedHandler(const winrt::Windows::Foundatio
     {
         return;
     }
-
-    const auto newConnectionState = _control.ConnectionState();
+    const auto& termControl{ _control.try_as<TermControl>() };
+    if (!termControl)
+    {
+        return;
+    }
+    const auto newConnectionState = termControl.ConnectionState();
     const auto previousConnectionState = std::exchange(_connectionState, newConnectionState);
 
     if (newConnectionState < ConnectionState::Closed)
@@ -1123,7 +1173,9 @@ void Pane::_ControlWarningBellHandler(const winrt::Windows::Foundation::IInspect
     {
         return;
     }
-    if (_profile)
+
+    const auto& termControl{ _control.try_as<TermControl>() };
+    if (_profile && termControl)
     {
         // We don't want to do anything if nothing is set, so check for that first
         if (static_cast<int>(_profile.BellStyle()) != 0)
@@ -1137,7 +1189,7 @@ void Pane::_ControlWarningBellHandler(const winrt::Windows::Foundation::IInspect
 
             if (WI_IsFlagSet(_profile.BellStyle(), winrt::Microsoft::Terminal::Settings::Model::BellStyle::Window))
             {
-                _control.BellLightOn();
+                termControl.BellLightOn();
             }
 
             // raise the event with the bool value corresponding to the taskbar flag
@@ -1197,7 +1249,11 @@ void Pane::Shutdown()
     std::unique_lock lock{ _createCloseLock };
     if (_IsLeaf())
     {
-        _control.Close();
+        const auto& termControl{ _control.try_as<TermControl>() };
+        if (termControl)
+        {
+            termControl.Close();
+        }
     }
     else
     {
@@ -1207,7 +1263,7 @@ void Pane::Shutdown()
 }
 
 // Method Description:
-// - Get the root UIElement of this pane. There may be a single TermControl as a
+// - Get the root UIElement of this pane. There may be a single UserControl as a
 //   child, or an entire tree of grids and panes as children of this element.
 // Arguments:
 // - <none>
@@ -1266,7 +1322,7 @@ TermControl Pane::GetLastFocusedTerminalControl()
             {
                 if (p->_IsLeaf())
                 {
-                    return p->_control;
+                    return p->GetTerminalControl();
                 }
                 pane = p;
             }
@@ -1274,7 +1330,7 @@ TermControl Pane::GetLastFocusedTerminalControl()
         }
         return _firstChild->GetLastFocusedTerminalControl();
     }
-    return _control;
+    return GetTerminalControl();
 }
 
 // Method Description:
@@ -1283,8 +1339,15 @@ TermControl Pane::GetLastFocusedTerminalControl()
 // Arguments:
 // - <none>
 // Return Value:
-// - nullptr if this Pane is a parent, otherwise the TermControl of this Pane.
-TermControl Pane::GetTerminalControl()
+// - nullptr if this Pane is a parent or isn't hosting a Terminal, otherwise the
+//   TermControl of this Pane.
+TermControl Pane::GetTerminalControl() const
+{
+    auto control{ GetUserControl() };
+    return control ? control.try_as<TermControl>() : nullptr;
+}
+
+Controls::UserControl Pane::GetUserControl() const
 {
     return _IsLeaf() ? _control : nullptr;
 }
@@ -1457,23 +1520,13 @@ void Pane::_FocusFirstChild()
 void Pane::UpdateSettings(const TerminalSettingsCreateResult& settings, const Profile& profile)
 {
     assert(_IsLeaf());
-
-    _profile = profile;
-    auto controlSettings = _control.Settings().as<TerminalSettings>();
-    // Update the parent of the control's settings object (and not the object itself) so
-    // that any overrides made by the control don't get affected by the reload
-    controlSettings.SetParent(settings.DefaultSettings());
-    auto unfocusedSettings{ settings.UnfocusedSettings() };
-    if (unfocusedSettings)
+    const auto& termControl{ _control.try_as<TermControl>() };
+    if (!termControl)
     {
-        // Note: the unfocused settings needs to be entirely unchanged _except_ we need to
-        // set its parent to the settings object that lives in the control. This is because
-        // the overrides made by the control live in that settings object, so we want to make
-        // sure the unfocused settings inherit from that.
-        unfocusedSettings.SetParent(controlSettings);
+        return;
     }
-    _control.UnfocusedAppearance(unfocusedSettings);
-    _control.UpdateSettings();
+    _profile = profile;
+    termControl.UpdateControlSettings(settings.DefaultSettings(), settings.UnfocusedSettings());
 }
 
 // Method Description:
@@ -1614,8 +1667,12 @@ void Pane::_CloseChild(const bool closeFirst, const bool isDetaching)
         _id = remainingChild->Id();
 
         // Add our new event handler before revoking the old one.
-        _connectionStateChangedToken = _control.ConnectionStateChanged({ this, &Pane::_ControlConnectionStateChangedHandler });
-        _warningBellToken = _control.WarningBell({ this, &Pane::_ControlWarningBellHandler });
+        const auto& termControl{ _control.try_as<TermControl>() };
+        if (termControl)
+        {
+            _connectionStateChangedToken = termControl.ConnectionStateChanged({ this, &Pane::_ControlConnectionStateChangedHandler });
+            _warningBellToken = termControl.WarningBell({ this, &Pane::_ControlWarningBellHandler });
+        }
 
         // Revoke the old event handlers. Remove both the handlers for the panes
         // themselves closing, and remove their handlers for their controls
@@ -1629,8 +1686,11 @@ void Pane::_CloseChild(const bool closeFirst, const bool isDetaching)
             closedChild->WalkTree([](auto p) {
                 if (p->_IsLeaf())
                 {
-                    p->_control.ConnectionStateChanged(p->_connectionStateChangedToken);
-                    p->_control.WarningBell(p->_warningBellToken);
+                    if (const auto& closedControl{ p->_control.try_as<TermControl>() })
+                    {
+                        closedControl.ConnectionStateChanged(p->_connectionStateChangedToken);
+                        closedControl.WarningBell(p->_warningBellToken);
+                    }
                 }
                 return false;
             });
@@ -1638,15 +1698,19 @@ void Pane::_CloseChild(const bool closeFirst, const bool isDetaching)
 
         closedChild->Closed(closedChildClosedToken);
         remainingChild->Closed(remainingChildClosedToken);
-        remainingChild->_control.ConnectionStateChanged(remainingChild->_connectionStateChangedToken);
-        remainingChild->_control.WarningBell(remainingChild->_warningBellToken);
+
+        if (const auto& remainingControl{ remainingChild->_control.try_as<TermControl>() })
+        {
+            remainingControl.ConnectionStateChanged(remainingChild->_connectionStateChangedToken);
+            remainingControl.WarningBell(remainingChild->_warningBellToken);
+        }
 
         // If we or either of our children was focused, we want to take that
         // focus from them.
         _lastActive = _lastActive || _firstChild->_lastActive || _secondChild->_lastActive;
 
         // Remove all the ui elements of the remaining child. This'll make sure
-        // we can re-attach the TermControl to our Grid.
+        // we can re-attach the UserControl to our Grid.
         remainingChild->_root.Children().Clear();
         remainingChild->_borderFirst.Child(nullptr);
 
@@ -1657,7 +1721,7 @@ void Pane::_CloseChild(const bool closeFirst, const bool isDetaching)
         _root.ColumnDefinitions().Clear();
         _root.RowDefinitions().Clear();
 
-        // Reattach the TermControl to our grid.
+        // Reattach the UserControl to our grid.
         _root.Children().Append(_borderFirst);
         _borderFirst.Child(_control);
 
@@ -1719,8 +1783,11 @@ void Pane::_CloseChild(const bool closeFirst, const bool isDetaching)
             closedChild->WalkTree([](auto p) {
                 if (p->_IsLeaf())
                 {
-                    p->_control.ConnectionStateChanged(p->_connectionStateChangedToken);
-                    p->_control.WarningBell(p->_warningBellToken);
+                    if (const auto& closedControl{ p->_control.try_as<TermControl>() })
+                    {
+                        closedControl.ConnectionStateChanged(p->_connectionStateChangedToken);
+                        closedControl.WarningBell(p->_warningBellToken);
+                    }
                 }
                 return false;
             });
@@ -2468,11 +2535,14 @@ std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Pane::_Split(SplitDirect
 
     if (_IsLeaf())
     {
-        // revoke our handler - the child will take care of the control now.
-        _control.ConnectionStateChanged(_connectionStateChangedToken);
-        _connectionStateChangedToken.value = 0;
-        _control.WarningBell(_warningBellToken);
-        _warningBellToken.value = 0;
+        if (const auto& termControl{ _control.try_as<TermControl>() })
+        {
+            // revoke our handler - the child will take care of the control now.
+            termControl.ConnectionStateChanged(_connectionStateChangedToken);
+            termControl.WarningBell(_warningBellToken);
+            _connectionStateChangedToken.value = 0;
+            _warningBellToken.value = 0;
+        }
 
         // Remove our old GotFocus handler from the control. We don't want the
         // control telling us that it's now focused, we want it telling its new
@@ -2482,7 +2552,7 @@ std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Pane::_Split(SplitDirect
     }
 
     // Remove any children we currently have. We can't add the existing
-    // TermControl to a new grid until we do this.
+    // UserControl to a new grid until we do this.
     _root.Children().Clear();
     _borderFirst.Child(nullptr);
     _borderSecond.Child(nullptr);
@@ -2860,8 +2930,13 @@ float Pane::CalcSnappedDimension(const bool widthOrHeight, const float dimension
 //   If requested size is already snapped, then both returned values equal this value.
 Pane::SnapSizeResult Pane::_CalcSnappedDimension(const bool widthOrHeight, const float dimension) const
 {
+    const auto& termControl{ _control.try_as<TermControl>() };
     if (_IsLeaf())
     {
+        if (!termControl)
+        {
+            return { dimension, dimension };
+        }
         // If we're a leaf pane, align to the grid of controlling terminal
 
         const auto minSize = _GetMinSize();
@@ -2872,7 +2947,7 @@ Pane::SnapSizeResult Pane::_CalcSnappedDimension(const bool widthOrHeight, const
             return { minDimension, minDimension };
         }
 
-        float lower = _control.SnapDimensionToGrid(widthOrHeight, dimension);
+        float lower = termControl.SnapDimensionToGrid(widthOrHeight, dimension);
         if (widthOrHeight)
         {
             lower += WI_IsFlagSet(_borders, Borders::Left) ? PaneBorderSize : 0;
@@ -2892,7 +2967,7 @@ Pane::SnapSizeResult Pane::_CalcSnappedDimension(const bool widthOrHeight, const
         }
         else
         {
-            const auto cellSize = _control.CharacterDimensions();
+            const auto cellSize = termControl.CharacterDimensions();
             const auto higher = lower + (widthOrHeight ? cellSize.Width : cellSize.Height);
             return { lower, higher };
         }
@@ -2937,26 +3012,39 @@ Pane::SnapSizeResult Pane::_CalcSnappedDimension(const bool widthOrHeight, const
 // - <none>
 void Pane::_AdvanceSnappedDimension(const bool widthOrHeight, LayoutSizeNode& sizeNode) const
 {
+    const auto& termControl{ _control.try_as<TermControl>() };
     if (_IsLeaf())
     {
-        // We're a leaf pane, so just add one more row or column (unless isMinimumSize
-        // is true, see below).
-
-        if (sizeNode.isMinimumSize)
+        if (termControl)
         {
-            // If the node is of its minimum size, this size might not be snapped (it might
-            // be, say, half a character, or fixed 10 pixels), so snap it upward. It might
-            // however be already snapped, so add 1 to make sure it really increases
-            // (not strictly necessary but to avoid surprises).
-            sizeNode.size = _CalcSnappedDimension(widthOrHeight, sizeNode.size + 1).higher;
+            // We're a leaf pane, so just add one more row or column (unless isMinimumSize
+            // is true, see below).
+
+            if (sizeNode.isMinimumSize)
+            {
+                // If the node is of its minimum size, this size might not be snapped (it might
+                // be, say, half a character, or fixed 10 pixels), so snap it upward. It might
+                // however be already snapped, so add 1 to make sure it really increases
+                // (not strictly necessary but to avoid surprises).
+                sizeNode.size = _CalcSnappedDimension(widthOrHeight, sizeNode.size + 1).higher;
+            }
+            else
+            {
+                const auto cellSize = termControl.CharacterDimensions();
+                sizeNode.size += widthOrHeight ? cellSize.Width : cellSize.Height;
+            }
         }
         else
         {
-            const auto cellSize = _control.CharacterDimensions();
-            sizeNode.size += widthOrHeight ? cellSize.Width : cellSize.Height;
+            // If we're a leaf that didn't have a TermControl, then just increment
+            // by one. We have to increment by _some_ value, because this is used in
+            // a while() loop to find the next bigger size we can snap to. But since
+            // a non-terminal control doesn't really care what size it's snapped to,
+            // we can just say "one pixel larger is the next snap point"
+            sizeNode.size += 1;
         }
     }
-    else
+    else // !_IsLeaf()
     {
         // We're a parent pane, so we have to advance dimension of our children panes. In
         // fact, we advance only one child (chosen later) to keep the growth fine-grained.
@@ -3058,7 +3146,8 @@ Size Pane::_GetMinSize() const
 {
     if (_IsLeaf())
     {
-        auto controlSize = _control.MinimumSize();
+        const auto& termControl{ _control.try_as<TermControl>() };
+        auto controlSize = termControl ? termControl.MinimumSize() : Size{ 1, 1 };
         auto newWidth = controlSize.Width;
         auto newHeight = controlSize.Height;
 
@@ -3244,7 +3333,10 @@ std::optional<SplitDirection> Pane::PreCalculateAutoSplit(const std::shared_ptr<
 // - Returns true if the pane or one of its descendants is read-only
 bool Pane::ContainsReadOnly() const
 {
-    return _IsLeaf() ? _control.ReadOnly() : (_firstChild->ContainsReadOnly() || _secondChild->ContainsReadOnly());
+    const auto& termControl{ GetTerminalControl() };
+    return termControl ?
+               termControl.ReadOnly() :
+               (_IsLeaf() ? false : (_firstChild->ContainsReadOnly() || _secondChild->ContainsReadOnly()));
 }
 
 // Method Description:
@@ -3257,13 +3349,14 @@ bool Pane::ContainsReadOnly() const
 // - <none>
 void Pane::CollectTaskbarStates(std::vector<winrt::TerminalApp::TaskbarState>& states)
 {
-    if (_IsLeaf())
+    const auto& termControl{ GetTerminalControl() };
+    if (termControl)
     {
-        auto tbState{ winrt::make<winrt::TerminalApp::implementation::TaskbarState>(_control.TaskbarState(),
-                                                                                    _control.TaskbarProgress()) };
+        auto tbState{ winrt::make<winrt::TerminalApp::implementation::TaskbarState>(termControl.TaskbarState(),
+                                                                                    termControl.TaskbarProgress()) };
         states.push_back(tbState);
     }
-    else
+    else if (!_IsLeaf())
     {
         _firstChild->CollectTaskbarStates(states);
         _secondChild->CollectTaskbarStates(states);

src/cascadia/TerminalApp/Pane.h

@@ -56,7 +56,7 @@ class Pane : public std::enable_shared_from_this<Pane>
 {
 public:
     Pane(const winrt::Microsoft::Terminal::Settings::Model::Profile& profile,
-         const winrt::Microsoft::Terminal::Control::TermControl& control,
+         const winrt::Windows::UI::Xaml::Controls::UserControl& control,
          const bool lastFocused = false);
 
     Pane(std::shared_ptr<Pane> first,
@@ -66,8 +66,9 @@ public:
          const bool lastFocused = false);
 
     std::shared_ptr<Pane> GetActivePane();
+    winrt::Windows::UI::Xaml::Controls::UserControl GetUserControl() const;
     winrt::Microsoft::Terminal::Control::TermControl GetLastFocusedTerminalControl();
-    winrt::Microsoft::Terminal::Control::TermControl GetTerminalControl();
+    winrt::Microsoft::Terminal::Control::TermControl GetTerminalControl() const;
     winrt::Microsoft::Terminal::Settings::Model::Profile GetFocusedProfile();
 
     // Method Description:
@@ -126,6 +127,8 @@ public:
                                      winrt::Microsoft::Terminal::Settings::Model::SplitDirection splitType);
     std::shared_ptr<Pane> DetachPane(std::shared_ptr<Pane> pane);
 
+    winrt::Windows::UI::Xaml::Controls::UserControl ReplaceControl(const winrt::Windows::UI::Xaml::Controls::UserControl& control);
+
     int GetLeafPaneCount() const noexcept;
 
     void Maximize(std::shared_ptr<Pane> zoomedPane);
@@ -200,7 +203,8 @@ private:
     winrt::Windows::UI::Xaml::Controls::Grid _root{};
     winrt::Windows::UI::Xaml::Controls::Border _borderFirst{};
     winrt::Windows::UI::Xaml::Controls::Border _borderSecond{};
-    winrt::Microsoft::Terminal::Control::TermControl _control{ nullptr };
+    winrt::Windows::UI::Xaml::Controls::UserControl _control{ nullptr };
+
     winrt::Microsoft::Terminal::TerminalConnection::ConnectionState _connectionState{ winrt::Microsoft::Terminal::TerminalConnection::ConnectionState::NotConnected };
     static winrt::Windows::UI::Xaml::Media::SolidColorBrush s_focusedBorderBrush;
     static winrt::Windows::UI::Xaml::Media::SolidColorBrush s_unfocusedBorderBrush;

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

@@ -411,6 +411,9 @@
   <data name="WindowCloseButton.[using:Windows.UI.Xaml.Controls]ToolTipService.ToolTip" xml:space="preserve">
     <value>Close</value>
   </data>
+  <data name="WindowCloseButtonToolTip.Text" xml:space="preserve">
+    <value>Close</value>
+  </data>
   <data name="WindowMaximizeButton.[using:Windows.UI.Xaml.Automation]AutomationProperties.Name" xml:space="preserve">
     <value>Maximize</value>
   </data>
@@ -420,6 +423,9 @@
   <data name="WindowMinimizeButton.[using:Windows.UI.Xaml.Controls]ToolTipService.ToolTip" xml:space="preserve">
     <value>Minimize</value>
   </data>
+  <data name="WindowMinimizeButtonToolTip.Text" xml:space="preserve">
+    <value>Minimize</value>
+  </data>
   <data name="AboutDialog.Title" xml:space="preserve">
     <value>About</value>
   </data>
@@ -504,6 +510,24 @@
   <data name="MultiLinePasteDialog.Title" xml:space="preserve">
     <value>Warning</value>
   </data>
+  <data name="ApproveCommandlineWarningPrefixTextBlock.Text" xml:space="preserve">
+    <value>You are about to execute the following command-line:</value>
+  </data>
+  <data name="ApproveCommandlineWarningSuffixTextBlock.Text" xml:space="preserve">
+    <value>Do you wish to continue?</value>
+  </data>
+  <data name="ApproveCommandlineWarning_PrimaryButton.Content" xml:space="preserve">
+    <value>Allow command-line</value>
+  </data>
+  <data name="ApproveCommandlineWarning_CancelButton.Content" xml:space="preserve">
+    <value>Cancel</value>
+  </data>
+  <data name="ApproveCommandlineWarningTitle.Text" xml:space="preserve">
+    <value>Warning</value>
+  </data>
+  <data name="AdminWarningPlaceholderName" xml:space="preserve">
+    <value>Elevated command-line warning</value>
+  </data>
   <data name="CommandPalette_SearchBox.PlaceholderText" xml:space="preserve">
     <value>Type a command name...</value>
   </data>

src/cascadia/TerminalApp/TabManagement.cpp

@@ -16,6 +16,7 @@
 #include <LibraryResources.h>
 
 #include "TabRowControl.h"
+#include "AdminWarningPlaceholder.h"
 #include "ColorHelper.h"
 #include "DebugTapConnection.h"
 #include "SettingsTab.h"

src/cascadia/TerminalApp/TerminalAppLib.vcxproj

@@ -63,6 +63,9 @@
     <Page Include="CommandPalette.xaml">
       <SubType>Designer</SubType>
     </Page>
+    <Page Include="AdminWarningPlaceholder.xaml">
+      <SubType>Designer</SubType>
+    </Page>
   </ItemGroup>
   <!-- ========================= Headers ======================== -->
   <ItemGroup>
@@ -141,6 +144,9 @@
     <ClInclude Include="AppLogic.h">
       <DependentUpon>AppLogic.idl</DependentUpon>
     </ClInclude>
+    <ClInclude Include="AdminWarningPlaceholder.h">
+      <DependentUpon>AdminWarningPlaceholder.xaml</DependentUpon>
+    </ClInclude>
     <ClInclude Include="Toast.h" />
   </ItemGroup>
   <!-- ========================= Cpp Files ======================== -->
@@ -234,6 +240,9 @@
     <ClCompile Include="AppLogic.cpp">
       <DependentUpon>AppLogic.idl</DependentUpon>
     </ClCompile>
+    <ClCompile Include="AdminWarningPlaceholder.cpp">
+      <DependentUpon>AdminWarningPlaceholder.xaml</DependentUpon>
+    </ClCompile>
     <ClCompile Include="$(GeneratedFilesDir)module.g.cpp" />
     <ClCompile Include="Toast.cpp" />
   </ItemGroup>
@@ -295,6 +304,10 @@
       <DependentUpon>CommandPalette.xaml</DependentUpon>
       <SubType>Code</SubType>
     </Midl>
+    <Midl Include="AdminWarningPlaceholder.idl">
+      <DependentUpon>AdminWarningPlaceholder.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </Midl>
     <Midl Include="FilteredCommand.idl" />
     <Midl Include="EmptyStringVisibilityConverter.idl" />
   </ItemGroup>

src/cascadia/TerminalApp/TerminalPage.cpp

@@ -17,6 +17,7 @@
 #include "DebugTapConnection.h"
 #include "SettingsTab.h"
 #include "RenameWindowRequestedArgs.g.cpp"
+#include "AdminWarningPlaceholder.h"
 #include "../inc/WindowingBehavior.h"
 
 #include <til/latch.h>
@@ -1415,21 +1416,24 @@ namespace winrt::TerminalApp::implementation
     {
         if (const auto terminalTab{ _GetFocusedTabImpl() })
         {
-            uint32_t realRowsToScroll;
-            if (rowsToScroll == nullptr)
+            if (const auto& termControl{ terminalTab->GetActiveTerminalControl() })
             {
-                // The magic value of WHEEL_PAGESCROLL indicates that we need to scroll the entire page
-                realRowsToScroll = _systemRowsToScroll == WHEEL_PAGESCROLL ?
-                                       terminalTab->GetActiveTerminalControl().ViewHeight() :
-                                       _systemRowsToScroll;
+                uint32_t realRowsToScroll;
+                if (rowsToScroll == nullptr)
+                {
+                    // The magic value of WHEEL_PAGESCROLL indicates that we need to scroll the entire page
+                    realRowsToScroll = _systemRowsToScroll == WHEEL_PAGESCROLL ?
+                                           termControl.ViewHeight() :
+                                           _systemRowsToScroll;
+                }
+                else
+                {
+                    // use the custom value specified in the command
+                    realRowsToScroll = rowsToScroll.Value();
+                }
+                auto scrollDelta = _ComputeScrollDelta(scrollDirection, realRowsToScroll);
+                terminalTab->Scroll(scrollDelta);
             }
-            else
-            {
-                // use the custom value specified in the command
-                realRowsToScroll = rowsToScroll.Value();
-            }
-            auto scrollDelta = _ComputeScrollDelta(scrollDirection, realRowsToScroll);
-            terminalTab->Scroll(scrollDelta);
         }
     }
 
@@ -1483,6 +1487,246 @@ namespace winrt::TerminalApp::implementation
         return true;
     }
 
+    // Function Description:
+    // - Returns true if this commandline is a commandline that we know is safe.
+    //   Generally, this is true for any executables in system32. We can use
+    //   this to bypass the elevated state check, because we're confident that
+    //   executables in that path won't have been hijacked.
+    //   - TECHNICALLY a user can take ownership of a file in system32 and
+    //     replace it as the system administrator. You could say it's OK though
+    //     because you'd already have to have had admin rights to mess that
+    //     folder up or something.
+    // - Will attempt to resolve environment strings.
+    // - Will also manually allow commandlines as generated for the default WSL
+    //   distros.
+    // - Will also trust %ProgramFiles%\Powershell\...\pwsh.exe paths, for
+    //   PowerShell Core.
+    // Arguments:
+    // - commandLine: the command to check.
+    // Return Value (example):
+    // - C:\windows\system32\cmd.exe -> returns true
+    // - cmd.exe -> returns false
+    // - C:\windows\system32\cmd.exe /k echo sneaky sneak -> returns false
+    // - %SystemRoot%\System32\cmd.exe -> returns true
+    // - %SystemRoot%\System32\wsl.exe -d <distro name> -> returns true
+    bool TerminalPage::_isTrustedCommandline(std::wstring_view commandLine)
+    {
+        // use C++11 magic statics to make sure we only do this once.
+        static std::wstring systemDirectory = []() -> std::wstring {
+            // *** THIS IS A SINGLETON ***
+            static std::wstring sys32{};
+            if (FAILED(wil::GetSystemDirectoryW(sys32)))
+            {
+                // we couldn't look up where system32 is?? Then it's definitely not
+                // in System32
+                return {};
+            }
+            return sys32;
+        }();
+
+        if (systemDirectory.empty())
+        {
+            return false;
+        }
+
+        const std::wstring fullCommandline{
+            wil::ExpandEnvironmentStringsW<std::wstring>(commandLine.data())
+        };
+
+        if (fullCommandline.size() > systemDirectory.size())
+        {
+            // Get the first part of the executable path
+            const auto start = fullCommandline.substr(0, systemDirectory.size());
+            // Doing this as an ASCII only check might be wrong, but I'm
+            // guessing if system32 isn't at X:\windows\system32... this isn't
+            // the only thing that is going to be sad in Windows.
+            const auto pathEquals = til::equals_insensitive_ascii(start, systemDirectory);
+            if (pathEquals && std::filesystem::exists(std::filesystem::path{ fullCommandline }))
+            {
+                return true;
+            }
+        }
+
+        // We're explicitly not auto-allowing wsl.exe -d <distro name>. It's
+        // trivial to insert some malicious stuff into WSL, via .bash_profile,
+        // so we're not giving them the (y)
+
+        // But we do want to allow `pwsh.exe` profiles in the expected place to
+        // work.
+        const std::vector<std::filesystem::path> powershellCoreRoots
+        {
+            // Always look in "%LOCALAPPDATA%\Microsoft\WindowsApps", which is
+            // where the pwsh.exe execution alias lives.
+            { wil::ExpandEnvironmentStringsW<std::wstring>(L"%LOCALAPPDATA%\\Microsoft\\WindowsApps") },
+
+                // Always look in "%ProgramFiles%\PowerShell"
+                { wil::ExpandEnvironmentStringsW<std::wstring>(L"%ProgramFiles%\\PowerShell") },
+
+#if defined(_M_AMD64) || defined(_M_ARM64) // No point in looking for WOW if we're not somewhere it exists
+                { wil::ExpandEnvironmentStringsW<std::wstring>(L"%ProgramFiles(x86)%\\PowerShell") },
+#endif
+
+#if defined(_M_ARM64) // same with ARM
+            {
+                wil::ExpandEnvironmentStringsW<std::wstring>(L"%ProgramFiles(Arm)%\\PowerShell")
+            }
+#endif
+        };
+
+        // Is the filename for this commandline `pwsh.exe`?
+        const std::filesystem::path exePath{ fullCommandline };
+        const auto endsWithPwsh{ exePath.filename() == L"pwsh.exe" };
+        // We'll also need to check the parent path, so make sure it has one here.
+
+        if (endsWithPwsh && exePath.has_parent_path())
+        {
+            const auto parentPath{ exePath.parent_path() };
+            for (const auto& pwshRoot : powershellCoreRoots)
+            {
+                // Does the commandline start with this root, and end with pwsh.exe?
+                const auto startsWithRoot{ til::starts_with(fullCommandline, pwshRoot.c_str()) };
+
+                // Is either the immediate parent, or the grandparent, this root exactly?
+                //
+                // We need to check the grandparent for the
+                // `%ProgramFiles%\\PowerShell\\7\\pwsh.exe` case.
+                const auto parentIsCorrect = (parentPath == pwshRoot) ||
+                                             (parentPath.has_parent_path() && parentPath.parent_path() == pwshRoot);
+
+                if (startsWithRoot && parentIsCorrect)
+                {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    // Method Description:
+    // - For a given commandline, determines if we should prompt the user for
+    //   approval. We only do this check when elevated. This will check the
+    //   AllowedCommandlines in `elevated-state.json`, to see if the commandline
+    //   already exists in that list.
+    // Arguments:
+    // - cmdline: The commandline to check
+    // Return Value:
+    // - true if we should prompt the user for approval.
+    bool TerminalPage::_shouldPromptForCommandline(const winrt::hstring& cmdline) const
+    {
+        // NOTE: For debugging purposes, changing this to `true || IsElevated()`
+        // is a handy way of forcing the elevation logic, even when unelevated.
+        if (IsElevated())
+        {
+            // If the cmdline is EXACTLY an executable in
+            // `C:\WINDOWS\System32`, then ignore this check.
+            if (_isTrustedCommandline(cmdline))
+            {
+                return false;
+            }
+
+            if (const auto& allowedCommandlines{ ApplicationState::SharedInstance().AllowedCommandlines() })
+            {
+                for (const auto& approved : allowedCommandlines)
+                {
+                    if (approved == cmdline)
+                    {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+
+        return false;
+    }
+
+    void TerminalPage::_adminWarningPrimaryClicked(const TerminalApp::AdminWarningPlaceholder& sender,
+                                                   const winrt::Windows::UI::Xaml::RoutedEventArgs& /*args*/)
+    {
+        auto warningControl{ winrt::get_self<AdminWarningPlaceholder>(sender) };
+        const auto& cmdline{ warningControl->Commandline() };
+        // Look through the tabs and panes to look for us. Whichever pane had us
+        // as content - replace their content with the TermControl we were
+        // holding on to.
+        for (const auto& tab : _tabs)
+        {
+            if (const auto& tabImpl{ _GetTerminalTabImpl(tab) })
+            {
+                tabImpl->GetRootPane()->WalkTree([warningControl, cmdline, tabImpl](std::shared_ptr<Pane> pane) -> bool {
+                    const auto& projectedWarningControl{ pane->GetUserControl().try_as<TerminalApp::AdminWarningPlaceholder>() };
+                    // If it was a warning control, then get our implementation
+                    // type out of it.
+                    if (const auto& otherWarning{ winrt::get_self<AdminWarningPlaceholder>(projectedWarningControl) })
+                    {
+                        // This pane had a warning in it.
+                        // Was it a warning for the same commandline that we
+                        // just approved?
+                        if (otherWarning->Commandline() == cmdline)
+                        {
+                            // Go ahead and allow them. Swap the control into
+                            // the pane, which will initialize and start it.
+                            tabImpl->ReplaceControl(pane, otherWarning->Control());
+                        }
+                        // Don't return true here. We want to make sure to check
+                        // all the panes for the same commandline we just
+                        // approved.
+                    }
+                    // return false so we make sure to iterate on every leaf.
+                    return false;
+                });
+            }
+        }
+
+        // Update the list of approved commandlines.
+        auto allowedCommandlines{ ApplicationState::SharedInstance().AllowedCommandlines() };
+        if (!allowedCommandlines)
+        {
+            allowedCommandlines = winrt::single_threaded_vector<winrt::hstring>();
+        }
+
+        // But of course, we don't need to add this commandline if it's already
+        // in the list of approved commandlines.
+        bool foundCopy = false;
+        for (const auto& approved : allowedCommandlines)
+        {
+            if (approved == cmdline)
+            {
+                foundCopy = true;
+                break;
+            }
+        }
+        if (!foundCopy)
+        {
+            allowedCommandlines.Append(cmdline);
+        }
+        ApplicationState::SharedInstance().AllowedCommandlines(allowedCommandlines);
+    }
+
+    void TerminalPage::_adminWarningCancelClicked(const TerminalApp::AdminWarningPlaceholder& sender,
+                                                  const winrt::Windows::UI::Xaml::RoutedEventArgs& /*args*/)
+    {
+        auto warningControl{ winrt::get_self<AdminWarningPlaceholder>(sender) };
+
+        for (const auto& tab : _tabs)
+        {
+            if (const auto& tabImpl{ _GetTerminalTabImpl(tab) })
+            {
+                tabImpl->GetRootPane()->WalkTree([warningControl](std::shared_ptr<Pane> pane) -> bool {
+                    if (pane->GetUserControl() == *warningControl)
+                    {
+                        pane->Close();
+                        return true;
+                    }
+                    // We're not going to auto-close all the other panes with
+                    // the same commandline warning, akin to what we're doing in
+                    // the approve handler. If they want to reject one pane, but
+                    // accept the next one, that's okay.
+                    return false;
+                });
+            }
+        }
+    }
+
     // Method Description:
     // - Split the focused pane either horizontally or vertically, and place the
     //   given pane accordingly in the tree
@@ -1852,8 +2096,10 @@ namespace winrt::TerminalApp::implementation
                 if (warnMultiLine)
                 {
                     const auto focusedTab = _GetFocusedTabImpl();
+                    const auto& termControl{ focusedTab->GetActiveTerminalControl() };
                     // Do not warn about multi line pasting if the current tab has bracketed paste enabled.
-                    warnMultiLine = warnMultiLine && !focusedTab->GetActiveTerminalControl().BracketedPasteEnabled();
+                    warnMultiLine = warnMultiLine &&
+                                    (termControl && !termControl.BracketedPasteEnabled());
                 }
 
                 // We have to initialize the dialog here to be able to change the text of the text block within it
@@ -2123,13 +2369,10 @@ namespace winrt::TerminalApp::implementation
 
     TermControl TerminalPage::_InitControl(const TerminalSettingsCreateResult& settings, const ITerminalConnection& connection)
     {
-        // Give term control a child of the settings so that any overrides go in the child
-        // This way, when we do a settings reload we just update the parent and the overrides remain
-        const auto child = TerminalSettings::CreateWithParent(settings);
-        TermControl term{ child.DefaultSettings(), connection };
-
-        term.UnfocusedAppearance(child.UnfocusedSettings()); // It is okay for the unfocused settings to be null
-
+        // Do any initialization that needs to apply to _every_ TermControl we
+        // create here.
+        // TermControl will copy the settings out of the settings passed to it.
+        TermControl term{ settings.DefaultSettings(), settings.UnfocusedSettings(), connection };
         return term;
     }
 
@@ -2161,11 +2404,14 @@ namespace winrt::TerminalApp::implementation
                     // TODO GH#5047 If we cache the NewTerminalArgs, we no longer need to do this.
                     profile = GetClosestProfileForDuplicationOfProfile(profile);
                     controlSettings = TerminalSettings::CreateWithProfile(_settings, profile, *_bindings);
-                    const auto workingDirectory = focusedTab->GetActiveTerminalControl().WorkingDirectory();
-                    const auto validWorkingDirectory = !workingDirectory.empty();
-                    if (validWorkingDirectory)
+                    if (const auto& control{ focusedTab->GetActiveTerminalControl() })
                     {
-                        controlSettings.DefaultSettings().StartingDirectory(workingDirectory);
+                        const auto workingDirectory = control.WorkingDirectory();
+                        const auto validWorkingDirectory = !workingDirectory.empty();
+                        if (validWorkingDirectory)
+                        {
+                            controlSettings.DefaultSettings().StartingDirectory(workingDirectory);
+                        }
                     }
                 }
             }
@@ -2199,7 +2445,21 @@ namespace winrt::TerminalApp::implementation
         const auto control = _InitControl(controlSettings, connection);
         _RegisterTerminalEvents(control);
 
-        auto resultPane = std::make_shared<Pane>(profile, control);
+        WUX::Controls::UserControl controlToAdd{ control };
+
+        // Check if we should warn the user about running a new unelevated
+        // commandline.
+        const auto& cmdline{ controlSettings.DefaultSettings().Commandline() };
+        const auto doAdminWarning{ _shouldPromptForCommandline(cmdline) };
+        if (doAdminWarning)
+        {
+            auto warningControl{ winrt::make_self<implementation::AdminWarningPlaceholder>(control, cmdline) };
+            warningControl->PrimaryButtonClicked({ get_weak(), &TerminalPage::_adminWarningPrimaryClicked });
+            warningControl->CancelButtonClicked({ get_weak(), &TerminalPage::_adminWarningCancelClicked });
+            controlToAdd = *warningControl;
+        }
+
+        auto resultPane = std::make_shared<Pane>(profile, controlToAdd);
 
         if (debugConnection) // this will only be set if global debugging is on and tap is active
         {
@@ -2220,6 +2480,17 @@ namespace winrt::TerminalApp::implementation
             original->SetActive();
         }
 
+        if (doAdminWarning)
+        {
+            // We know this is safe - we literally just added the
+            // AdminWarningPlaceholder as the controlToAdd like 20 lines up.
+            //
+            // Focus the warning here. The LayoutUpdated within the dialog
+            // itself isn't good enough. That, for some reason, fires _before_
+            // the dialog is in the UI tree, which is useless for us.
+            controlToAdd.try_as<implementation::AdminWarningPlaceholder>()->FocusOnLaunch();
+        }
+
         return resultPane;
     }
 

src/cascadia/TerminalApp/TerminalPage.h

@@ -19,6 +19,7 @@ namespace TerminalAppLocalTests
 {
     class TabTests;
     class SettingsTests;
+    class TrustCommandlineTests;
 };
 
 namespace winrt::TerminalApp::implementation
@@ -207,6 +208,7 @@ namespace winrt::TerminalApp::implementation
         winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::UI::Xaml::Controls::ContentDialogResult> _ShowCloseReadOnlyDialog();
         winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::UI::Xaml::Controls::ContentDialogResult> _ShowMultiLinePasteWarningDialog();
         winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::UI::Xaml::Controls::ContentDialogResult> _ShowLargePasteWarningDialog();
+        winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::UI::Xaml::Controls::ContentDialogResult> _ShowCommandlineApproveWarning();
 
         void _CreateNewTabFlyout();
         void _OpenNewTabDropdown();
@@ -403,6 +405,12 @@ namespace winrt::TerminalApp::implementation
 
         winrt::Microsoft::Terminal::Settings::Model::Profile GetClosestProfileForDuplicationOfProfile(const winrt::Microsoft::Terminal::Settings::Model::Profile& profile) const noexcept;
 
+        bool _shouldPromptForCommandline(const winrt::hstring& cmdline) const;
+        void _adminWarningPrimaryClicked(const winrt::TerminalApp::AdminWarningPlaceholder& sender,
+                                         const winrt::Windows::UI::Xaml::RoutedEventArgs& args);
+        void _adminWarningCancelClicked(const winrt::TerminalApp::AdminWarningPlaceholder& sender,
+                                        const winrt::Windows::UI::Xaml::RoutedEventArgs& args);
+
         winrt::fire_and_forget _ConnectionStateChangedHandler(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::Foundation::IInspectable& args) const;
         void _CloseOnExitInfoDismissHandler(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::Foundation::IInspectable& args) const;
         void _KeyboardServiceWarningInfoDismissHandler(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::Foundation::IInspectable& args) const;
@@ -410,6 +418,7 @@ namespace winrt::TerminalApp::implementation
         void _SetAsDefaultOpenSettingsHandler(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::Foundation::IInspectable& args);
         static bool _IsMessageDismissed(const winrt::Microsoft::Terminal::Settings::Model::InfoBarMessage& message);
         static void _DismissMessage(const winrt::Microsoft::Terminal::Settings::Model::InfoBarMessage& message);
+        static bool _isTrustedCommandline(std::wstring_view commandLine);
 
 #pragma region ActionHandlers
         // These are all defined in AppActionHandlers.cpp
@@ -420,6 +429,7 @@ namespace winrt::TerminalApp::implementation
 
         friend class TerminalAppLocalTests::TabTests;
         friend class TerminalAppLocalTests::SettingsTests;
+        friend class TerminalAppLocalTests::TrustCommandlineTests;
     };
 }
 

src/cascadia/TerminalApp/TerminalTab.cpp

@@ -426,7 +426,10 @@ namespace winrt::TerminalApp::implementation
     winrt::fire_and_forget TerminalTab::Scroll(const int delta)
     {
         auto control = GetActiveTerminalControl();
-
+        if (!control)
+        {
+            co_return;
+        }
         co_await winrt::resume_foreground(control.Dispatcher());
 
         const auto currentOffset = control.ScrollOffset();
@@ -511,7 +514,11 @@ namespace winrt::TerminalApp::implementation
             if (p->_IsLeaf())
             {
                 p->Id(_nextPaneId);
-                _AttachEventHandlersToControl(p->Id().value(), p->_control);
+                if (auto termControl{ p->_control.try_as<TermControl>() })
+                {
+                    _AttachEventHandlersToControl(p->Id().value(), termControl);
+                }
+
                 _nextPaneId++;
             }
             return false;
@@ -856,6 +863,10 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     void TerminalTab::_AttachEventHandlersToControl(const uint32_t paneId, const TermControl& control)
     {
+        if (!control)
+        {
+            return;
+        }
         auto weakThis{ get_weak() };
         auto dispatcher = TabViewItem().Dispatcher();
         ControlEventTokens events{};
@@ -1744,6 +1755,19 @@ namespace winrt::TerminalApp::implementation
         return Title();
     }
 
+    void TerminalTab::ReplaceControl(std::shared_ptr<Pane> pane, const Controls::UserControl& control)
+    {
+        pane->ReplaceControl(control);
+
+        if (auto termControl{ pane->_control.try_as<TermControl>() })
+        {
+            _AttachEventHandlersToControl(pane->Id().value(), termControl);
+        }
+
+        // Update the title manually.
+        UpdateTitle();
+    }
+
     DEFINE_EVENT(TerminalTab, ActivePaneChanged, _ActivePaneChangedHandlers, winrt::delegate<>);
     DEFINE_EVENT(TerminalTab, ColorSelected, _colorSelected, winrt::delegate<winrt::Windows::UI::Color>);
     DEFINE_EVENT(TerminalTab, ColorCleared, _colorCleared, winrt::delegate<>);

src/cascadia/TerminalApp/TerminalTab.h

@@ -93,6 +93,9 @@ namespace winrt::TerminalApp::implementation
 
         std::shared_ptr<Pane> GetRootPane() const { return _rootPane; }
 
+        void ReplaceControl(std::shared_ptr<Pane> pane,
+                            const winrt::Windows::UI::Xaml::Controls::UserControl& control);
+
         winrt::TerminalApp::TerminalTabStatus TabStatus()
         {
             return _tabStatus;

src/cascadia/TerminalApp/TitlebarControl.cpp

@@ -1,7 +1,6 @@
-// Copyright (c) Microsoft Corporation.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 //
-// TitlebarControl.xaml.cpp
 // Implementation of the TitlebarControl class
 //
 
@@ -24,6 +23,14 @@ namespace winrt::TerminalApp::implementation
         MinMaxCloseControl().CloseClick({ this, &TitlebarControl::Close_Click });
     }
 
+    double TitlebarControl::CaptionButtonWidth()
+    {
+        // Divide by three, since we know there are only three buttons. When
+        // Windows 12 comes along and adds another, we can update this /s
+        static double width{ MinMaxCloseControl().ActualWidth() / 3.0 };
+        return width;
+    }
+
     IInspectable TitlebarControl::Content()
     {
         return ContentRoot().Content();
@@ -93,4 +100,48 @@ namespace winrt::TerminalApp::implementation
     {
         MinMaxCloseControl().SetWindowVisualState(visualState);
     }
+
+    // GH#9443: HoverButton, PressButton, ClickButton and ReleaseButtons are all
+    // used to manually interact with the buttons, in the same way that XAML
+    // would normally send events.
+
+    void TitlebarControl::HoverButton(CaptionButton button)
+    {
+        MinMaxCloseControl().HoverButton(button);
+    }
+    void TitlebarControl::PressButton(CaptionButton button)
+    {
+        MinMaxCloseControl().PressButton(button);
+    }
+    winrt::fire_and_forget TitlebarControl::ClickButton(CaptionButton button)
+    {
+        // GH#8587: Handle this on the _next_ pass of the UI thread. If we
+        // handle this immediately, then we'll accidentally leave the button in
+        // the "Hovered" state when we minimize. This will leave the button
+        // visibly hovered in the taskbar preview for our window.
+        auto weakThis{ get_weak() };
+        co_await MinMaxCloseControl().Dispatcher();
+        if (auto self{ weakThis.get() })
+        {
+            // Just handle this in the same way we would if the button were
+            // clicked normally.
+            switch (button)
+            {
+            case CaptionButton::Minimize:
+                Minimize_Click(nullptr, nullptr);
+                break;
+            case CaptionButton::Maximize:
+                Maximize_Click(nullptr, nullptr);
+                break;
+            case CaptionButton::Close:
+                Close_Click(nullptr, nullptr);
+                break;
+            }
+        }
+    }
+    void TitlebarControl::ReleaseButtons()
+    {
+        MinMaxCloseControl().ReleaseButtons();
+    }
+
 }

src/cascadia/TerminalApp/TitlebarControl.h

@@ -1,14 +1,8 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
-//
-// Declaration of the MainUserControl class.
-//
 
 #pragma once
 
-#include "winrt/Windows.UI.Xaml.h"
-#include "winrt/Windows.UI.Xaml.Markup.h"
-#include "winrt/Windows.UI.Xaml.Interop.h"
 #include "TitlebarControl.g.h"
 
 namespace winrt::TerminalApp::implementation
@@ -17,6 +11,12 @@ namespace winrt::TerminalApp::implementation
     {
         TitlebarControl(uint64_t handle);
 
+        void HoverButton(CaptionButton button);
+        void PressButton(CaptionButton button);
+        winrt::fire_and_forget ClickButton(CaptionButton button);
+        void ReleaseButtons();
+        double CaptionButtonWidth();
+
         IInspectable Content();
         void Content(IInspectable content);
 

src/cascadia/TerminalApp/TitlebarControl.idl

@@ -10,11 +10,25 @@ namespace TerminalApp
         WindowVisualStateIconified
     };
 
+    // For simplicity, make sure that these are the same values as the ones used
+    // by messages like WM_NCHITTEST
+    enum CaptionButton {
+        Minimize = 8, // HTMINBUTTON
+        Maximize = 9, // HTMAXBUTTON
+        Close = 20 // HTCLOSE
+    };
+
     [default_interface] runtimeclass TitlebarControl : Windows.UI.Xaml.Controls.Grid
     {
         TitlebarControl(UInt64 parentWindowHandle);
         void SetWindowVisualState(WindowVisualState visualState);
 
+        void HoverButton(CaptionButton button);
+        void PressButton(CaptionButton button);
+        void ClickButton(CaptionButton button);
+        void ReleaseButtons();
+        Double CaptionButtonWidth { get; };
+
         IInspectable Content;
         Windows.UI.Xaml.Controls.Border DragBar { get; };
     }

src/cascadia/TerminalControl/ControlAppearance.h

@@ -0,0 +1,49 @@
+/*++
+Copyright (c) Microsoft Corporation
+Licensed under the MIT license.
+--*/
+#pragma once
+#include "../../inc/cppwinrt_utils.h"
+#include "../../inc/ControlProperties.h"
+
+#include <DefaultSettings.h>
+#include <conattrs.hpp>
+
+namespace winrt::Microsoft::Terminal::Control::implementation
+{
+    struct ControlAppearance : public winrt::implements<ControlAppearance, Microsoft::Terminal::Core::ICoreAppearance, Microsoft::Terminal::Control::IControlAppearance>
+    {
+#define SETTINGS_GEN(type, name, ...) WINRT_PROPERTY(type, name, __VA_ARGS__);
+        CORE_APPEARANCE_SETTINGS(SETTINGS_GEN)
+        CONTROL_APPEARANCE_SETTINGS(SETTINGS_GEN)
+#undef SETTINGS_GEN
+
+    private:
+        // Color Table is special because it's an array
+        std::array<winrt::Microsoft::Terminal::Core::Color, COLOR_TABLE_SIZE> _ColorTable;
+
+    public:
+        winrt::Microsoft::Terminal::Core::Color GetColorTableEntry(int32_t index) noexcept
+        {
+            return _ColorTable.at(index);
+        }
+        void SetColorTableEntry(int32_t index,
+                                winrt::Microsoft::Terminal::Core::Color color) noexcept
+        {
+            _ColorTable.at(index) = color;
+        }
+
+        ControlAppearance(Control::IControlAppearance appearance)
+        {
+#define COPY_SETTING(type, name, ...) _##name = appearance.name();
+            CORE_APPEARANCE_SETTINGS(COPY_SETTING)
+            CONTROL_APPEARANCE_SETTINGS(COPY_SETTING)
+#undef COPY_SETTING
+
+            for (size_t i = 0; i < _ColorTable.size(); i++)
+            {
+                _ColorTable[i] = appearance.GetColorTableEntry(static_cast<int32_t>(i));
+            }
+        }
+    };
+}

src/cascadia/TerminalControl/ControlCore.cpp

@@ -56,15 +56,17 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         return initialized;
     }
 
-    ControlCore::ControlCore(IControlSettings settings,
+    ControlCore::ControlCore(Control::IControlSettings settings,
+                             Control::IControlAppearance unfocusedAppearance,
                              TerminalConnection::ITerminalConnection connection) :
         _connection{ connection },
-        _settings{ settings },
         _desiredFont{ DEFAULT_FONT_FACE, 0, DEFAULT_FONT_WEIGHT, { 0, DEFAULT_FONT_SIZE }, CP_UTF8 },
         _actualFont{ DEFAULT_FONT_FACE, 0, DEFAULT_FONT_WEIGHT, { 0, DEFAULT_FONT_SIZE }, CP_UTF8, false }
     {
         _EnsureStaticInitialization();
 
+        _settings = winrt::make_self<implementation::ControlSettings>(settings, unfocusedAppearance);
+
         _terminal = std::make_unique<::Microsoft::Terminal::Core::Terminal>();
 
         // Subscribe to the connection's disconnected event and call our connection closed handlers.
@@ -80,7 +82,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         });
 
         // GH#8969: pre-seed working directory to prevent potential races
-        _terminal->SetWorkingDirectory(_settings.StartingDirectory());
+        _terminal->SetWorkingDirectory(_settings->StartingDirectory());
 
         auto pfnCopyToClipboard = std::bind(&ControlCore::_terminalCopyToClipboard, this, std::placeholders::_1);
         _terminal->SetCopyToClipboardCallback(pfnCopyToClipboard);
@@ -187,7 +189,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                 }
             });
 
-        UpdateSettings(settings);
+        UpdateSettings(settings, unfocusedAppearance);
     }
 
     ControlCore::~ControlCore()
@@ -226,7 +228,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                 return false;
             }
 
-            if (Feature_AtlasEngine::IsEnabled() && _settings.UseAtlasEngine())
+            if (Feature_AtlasEngine::IsEnabled() && _settings->UseAtlasEngine())
             {
                 _renderEngine = std::make_unique<::Microsoft::Console::Render::AtlasEngine>();
             }
@@ -252,7 +254,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             LOG_IF_FAILED(_renderEngine->SetWindowSize({ viewInPixels.Width(), viewInPixels.Height() }));
 
             // Update DxEngine's SelectionBackground
-            _renderEngine->SetSelectionBackground(til::color{ _settings.SelectionBackground() });
+            _renderEngine->SetSelectionBackground(til::color{ _settings->SelectionBackground() });
 
             const auto vp = _renderEngine->GetViewportInCharacters(viewInPixels);
             const auto width = vp.Width();
@@ -260,10 +262,10 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             _connection.Resize(height, width);
 
             // Override the default width and height to match the size of the swapChainPanel
-            _settings.InitialCols(width);
-            _settings.InitialRows(height);
+            _settings->InitialCols(width);
+            _settings->InitialRows(height);
 
-            _terminal->CreateFromSettings(_settings, *_renderer);
+            _terminal->CreateFromSettings(*_settings, *_renderer);
 
             // IMPORTANT! Set this callback up sooner than later. If we do it
             // after Enable, then it'll be possible to paint the frame once
@@ -275,18 +277,17 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             // We do this after we initially set the swapchain so as to avoid unnecessary callbacks (and locking problems)
             _renderEngine->SetCallback(std::bind(&ControlCore::_renderEngineSwapChainChanged, this));
 
-            _renderEngine->SetRetroTerminalEffect(_settings.RetroTerminalEffect());
-            _renderEngine->SetPixelShaderPath(_settings.PixelShaderPath());
-            _renderEngine->SetForceFullRepaintRendering(_settings.ForceFullRepaintRendering());
-            _renderEngine->SetSoftwareRendering(_settings.SoftwareRendering());
-            _renderEngine->SetIntenseIsBold(_settings.IntenseIsBold());
+            _renderEngine->SetRetroTerminalEffect(_settings->RetroTerminalEffect());
+            _renderEngine->SetPixelShaderPath(_settings->PixelShaderPath());
+            _renderEngine->SetForceFullRepaintRendering(_settings->ForceFullRepaintRendering());
+            _renderEngine->SetSoftwareRendering(_settings->SoftwareRendering());
+            _renderEngine->SetIntenseIsBold(_settings->IntenseIsBold());
 
             _updateAntiAliasingMode();
 
             // GH#5098: Inform the engine of the opacity of the default text background.
             // GH#11315: Always do this, even if they don't have acrylic on.
-            const auto backgroundIsOpaque = _settings.Opacity() == 1.0 && _settings.BackgroundImage().empty();
-            _renderEngine->SetDefaultTextBackgroundOpacity(static_cast<float>(backgroundIsOpaque));
+            _renderEngine->EnableTransparentBackground(_isBackgroundTransparent());
 
             THROW_IF_FAILED(_renderEngine->Enable());
 
@@ -444,14 +445,13 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             return;
         }
 
-        auto newOpacity = std::clamp(_settings.Opacity() + adjustment,
+        auto newOpacity = std::clamp(Opacity() + adjustment,
                                      0.0,
                                      1.0);
 
-        // GH#5098: Inform the engine of the new opacity of the default text background.
-        SetBackgroundOpacity(::base::saturated_cast<float>(newOpacity));
-
-        _settings.Opacity(newOpacity);
+        auto lock = _terminal->LockForWriting();
+        // Update our runtime opacity value
+        Opacity(newOpacity);
 
         // GH#11285 - If the user is on Windows 10, and they changed the
         // transparency of the control s.t. it should be partially opaque, then
@@ -461,7 +461,14 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         // is what the Terminal did prior to 1.12.
         if (!IsVintageOpacityAvailable())
         {
-            _settings.UseAcrylic(newOpacity < 1.0);
+            _runtimeUseAcrylic = newOpacity < 1.0;
+        }
+
+        // Update the renderer as well. It might need to fall back from
+        // cleartype -> grayscale if the BG is transparent / acrylic.
+        if (_renderEngine)
+        {
+            _renderEngine->EnableTransparentBackground(_isBackgroundTransparent());
         }
 
         auto eventArgs = winrt::make_self<TransparencyChangedEventArgs>(newOpacity);
@@ -476,7 +483,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         // specify a custom pixel shader, manually enable the legacy retro
         // effect first. This will ensure that a toggle off->on will still work,
         // even if they currently have retro effect off.
-        if (_settings.PixelShaderPath().empty() && !_renderEngine->GetRetroTerminalEffect())
+        if (_settings->PixelShaderPath().empty() && !_renderEngine->GetRetroTerminalEffect())
         {
             // SetRetroTerminalEffect to true will enable the effect. In this
             // case, the shader effect will already be disabled (because neither
@@ -586,24 +593,27 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     // Method Description:
     // - Updates the settings of the current terminal.
     // - INVARIANT: This method can only be called if the caller DOES NOT HAVE writing lock on the terminal.
-    void ControlCore::UpdateSettings(const IControlSettings& settings)
+    void ControlCore::UpdateSettings(const IControlSettings& settings, const IControlAppearance& newAppearance)
     {
+        _settings = winrt::make_self<implementation::ControlSettings>(settings, newAppearance);
+
         auto lock = _terminal->LockForWriting();
 
-        _settings = settings;
+        _runtimeOpacity = std::nullopt;
+        _runtimeUseAcrylic = std::nullopt;
 
         // GH#11285 - If the user is on Windows 10, and they wanted opacity, but
         // didn't explicitly request acrylic, then opt them in to acrylic.
         // On Windows 11+, this isn't needed, because we can have vintage opacity.
-        if (!IsVintageOpacityAvailable() && _settings.Opacity() < 1.0 && !_settings.UseAcrylic())
+        if (!IsVintageOpacityAvailable() && _settings->Opacity() < 1.0 && !_settings->UseAcrylic())
         {
-            _settings.UseAcrylic(true);
+            _runtimeUseAcrylic = true;
         }
 
         // Initialize our font information.
-        const auto fontFace = _settings.FontFace();
-        const short fontHeight = ::base::saturated_cast<short>(_settings.FontSize());
-        const auto fontWeight = _settings.FontWeight();
+        const auto fontFace = _settings->FontFace();
+        const short fontHeight = ::base::saturated_cast<short>(_settings->FontSize());
+        const auto fontWeight = _settings->FontWeight();
         // The font width doesn't terribly matter, we'll only be using the
         //      height to look it up
         // The other params here also largely don't matter.
@@ -615,7 +625,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         _desiredFont = { _actualFont };
 
         // Update the terminal core with its new Core settings
-        _terminal->UpdateSettings(_settings);
+        _terminal->UpdateSettings(*_settings);
 
         if (!_initializedTerminal)
         {
@@ -624,8 +634,10 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             return;
         }
 
-        _renderEngine->SetForceFullRepaintRendering(_settings.ForceFullRepaintRendering());
-        _renderEngine->SetSoftwareRendering(_settings.SoftwareRendering());
+        _renderEngine->SetForceFullRepaintRendering(_settings->ForceFullRepaintRendering());
+        _renderEngine->SetSoftwareRendering(_settings->SoftwareRendering());
+        // Inform the renderer of our opacity
+        _renderEngine->EnableTransparentBackground(_isBackgroundTransparent());
 
         _updateAntiAliasingMode();
 
@@ -642,21 +654,21 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     // Method Description:
     // - Updates the appearance of the current terminal.
     // - INVARIANT: This method can only be called if the caller DOES NOT HAVE writing lock on the terminal.
-    void ControlCore::UpdateAppearance(const IControlAppearance& newAppearance)
+    void ControlCore::ApplyAppearance(const bool& focused)
     {
         auto lock = _terminal->LockForWriting();
-
+        const auto& newAppearance{ focused ? _settings->FocusedAppearance() : _settings->UnfocusedAppearance() };
         // Update the terminal core with its new Core settings
-        _terminal->UpdateAppearance(newAppearance);
+        _terminal->UpdateAppearance(*newAppearance);
 
         // Update DxEngine settings under the lock
         if (_renderEngine)
         {
             // Update DxEngine settings under the lock
-            _renderEngine->SetSelectionBackground(til::color{ newAppearance.SelectionBackground() });
-            _renderEngine->SetRetroTerminalEffect(newAppearance.RetroTerminalEffect());
-            _renderEngine->SetPixelShaderPath(newAppearance.PixelShaderPath());
-            _renderEngine->SetIntenseIsBold(_settings.IntenseIsBold());
+            _renderEngine->SetSelectionBackground(til::color{ newAppearance->SelectionBackground() });
+            _renderEngine->SetRetroTerminalEffect(newAppearance->RetroTerminalEffect());
+            _renderEngine->SetPixelShaderPath(newAppearance->PixelShaderPath());
+            _renderEngine->SetIntenseIsBold(_settings->IntenseIsBold());
             _renderer->TriggerRedrawAll();
         }
     }
@@ -664,8 +676,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     void ControlCore::_updateAntiAliasingMode()
     {
         D2D1_TEXT_ANTIALIAS_MODE mode;
-
-        switch (_settings.AntialiasingMode())
+        // Update DxEngine's AntialiasingMode
+        switch (_settings->AntialiasingMode())
         {
         case TextAntialiasingMode::Cleartype:
             mode = D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE;
@@ -701,7 +713,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         if (_renderEngine)
         {
             std::unordered_map<std::wstring_view, uint32_t> featureMap;
-            if (const auto fontFeatures = _settings.FontFeatures())
+            if (const auto fontFeatures = _settings->FontFeatures())
             {
                 featureMap.reserve(fontFeatures.Size());
 
@@ -711,7 +723,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                 }
             }
             std::unordered_map<std::wstring_view, float> axesMap;
-            if (const auto fontAxes = _settings.FontAxes())
+            if (const auto fontAxes = _settings->FontAxes())
             {
                 axesMap.reserve(fontAxes.Size());
 
@@ -753,8 +765,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         {
             // Make sure we have a non-zero font size
             const auto newSize = std::max<short>(gsl::narrow_cast<short>(fontSize), 1);
-            const auto fontFace = _settings.FontFace();
-            const auto fontWeight = _settings.FontWeight();
+            const auto fontFace = _settings->FontFace();
+            const auto fontWeight = _settings->FontWeight();
             _actualFont = { fontFace, 0, fontWeight.Weight, { 0, newSize }, CP_UTF8, false };
             _actualFontFaceName = { fontFace };
             _desiredFont = { _actualFont };
@@ -779,7 +791,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     // - none
     void ControlCore::ResetFontSize()
     {
-        _setFontSize(_settings.FontSize());
+        _setFontSize(_settings->FontSize());
     }
 
     // Method Description:
@@ -991,7 +1003,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                                   TextBuffer::GenHTML(bufferData,
                                                       _actualFont.GetUnscaledSize().Y,
                                                       _actualFont.GetFaceName(),
-                                                      til::color{ _settings.DefaultBackground() }) :
+                                                      til::color{ _settings->DefaultBackground() }) :
                                   "";
 
         // convert to RTF format
@@ -999,10 +1011,10 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                                  TextBuffer::GenRTF(bufferData,
                                                     _actualFont.GetUnscaledSize().Y,
                                                     _actualFont.GetFaceName(),
-                                                    til::color{ _settings.DefaultBackground() }) :
+                                                    til::color{ _settings->DefaultBackground() }) :
                                  "";
 
-        if (!_settings.CopyOnSelect())
+        if (!_settings->CopyOnSelect())
         {
             _terminal->ClearSelection();
             _renderer->TriggerSelection();
@@ -1089,7 +1101,10 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
     til::color ControlCore::BackgroundColor() const
     {
-        return _terminal->GetDefaultBackground();
+        // The Terminal internally stores it's BG with 0 opacity, so as to allow
+        // DX to paint the BG color transparently. We however don't want to leak
+        // that implementation detail.
+        return _terminal->GetDefaultBackground().with_alpha(0xff);
     }
 
     // Method Description:
@@ -1246,7 +1261,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
     bool ControlCore::CopyOnSelect() const
     {
-        return _settings.CopyOnSelect();
+        return _settings->CopyOnSelect();
     }
 
     Windows::Foundation::Collections::IVector<winrt::hstring> ControlCore::SelectedText(bool trimTrailingWhitespace) const
@@ -1304,16 +1319,6 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         }
     }
 
-    void ControlCore::SetBackgroundOpacity(const double opacity)
-    {
-        if (_renderEngine)
-        {
-            auto lock = _terminal->LockForWriting();
-            const auto backgroundIsOpaque = opacity == 1.0 && _settings.BackgroundImage().empty();
-            _renderEngine->SetDefaultTextBackgroundOpacity(static_cast<float>(backgroundIsOpaque));
-        }
-    }
-
     // Method Description:
     // - Asynchronously close our connection. The Connection will likely wait
     //   until the attached process terminates before Close returns. If that's
@@ -1599,4 +1604,125 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         return VerifyVersionInfoW(&osver, VER_BUILDNUMBER, dwlConditionMask) != FALSE;
     }
+
+    Core::Scheme ControlCore::ColorScheme() const noexcept
+    {
+        Core::Scheme s;
+
+        // This part is definitely a hack.
+        //
+        // This function is usually used by the "Preview Color Scheme"
+        // functionality in TerminalPage. If we've got an unfocused appearance,
+        // then we've applied that appearance before this is even getting called
+        // (because the command palette is open with focus on top of us). If we
+        // return the _current_ colors now, we'll return out the _unfocused_
+        // colors. If we do that, and the user dismisses the command palette,
+        // then the scheme that will get restored is the _unfocused_ one, which
+        // is not what we want.
+        //
+        // So if that's the case, then let's grab the colors from the focused
+        // appearance as the scheme instead. We'll lose any current runtime
+        // changes to the color table, but those were already blown away when we
+        // switched to an unfocused appearance.
+        //
+        // IF WE DON'T HAVE AN UNFOCUSED APPEARANCE: then just ask the Terminal
+        // for it's current color table. That way, we can restore those colors
+        // back.
+        if (HasUnfocusedAppearance())
+        {
+            s.Foreground = _settings->FocusedAppearance()->DefaultForeground();
+            s.Background = _settings->FocusedAppearance()->DefaultBackground();
+
+            s.CursorColor = _settings->FocusedAppearance()->CursorColor();
+
+            s.Black = _settings->FocusedAppearance()->GetColorTableEntry(0);
+            s.Red = _settings->FocusedAppearance()->GetColorTableEntry(1);
+            s.Green = _settings->FocusedAppearance()->GetColorTableEntry(2);
+            s.Yellow = _settings->FocusedAppearance()->GetColorTableEntry(3);
+            s.Blue = _settings->FocusedAppearance()->GetColorTableEntry(4);
+            s.Purple = _settings->FocusedAppearance()->GetColorTableEntry(5);
+            s.Cyan = _settings->FocusedAppearance()->GetColorTableEntry(6);
+            s.White = _settings->FocusedAppearance()->GetColorTableEntry(7);
+            s.BrightBlack = _settings->FocusedAppearance()->GetColorTableEntry(8);
+            s.BrightRed = _settings->FocusedAppearance()->GetColorTableEntry(9);
+            s.BrightGreen = _settings->FocusedAppearance()->GetColorTableEntry(10);
+            s.BrightYellow = _settings->FocusedAppearance()->GetColorTableEntry(11);
+            s.BrightBlue = _settings->FocusedAppearance()->GetColorTableEntry(12);
+            s.BrightPurple = _settings->FocusedAppearance()->GetColorTableEntry(13);
+            s.BrightCyan = _settings->FocusedAppearance()->GetColorTableEntry(14);
+            s.BrightWhite = _settings->FocusedAppearance()->GetColorTableEntry(15);
+        }
+        else
+        {
+            s = _terminal->GetColorScheme();
+        }
+
+        // This might be a tad bit of a hack. This event only gets called by set
+        // color scheme / preview color scheme, and in that case, we know the
+        // control _is_ focused.
+        s.SelectionBackground = _settings->FocusedAppearance()->SelectionBackground();
+
+        return s;
+    }
+
+    // Method Description:
+    // - Apply the given color scheme to this control. We'll take the colors out
+    //   of it and apply them to our focused appearance, and update the terminal
+    //   buffer with the new color table.
+    // - This is here to support the Set Color Scheme action, and the ability to
+    //   preview schemes in the control.
+    // Arguments:
+    // - scheme: the collection of colors to apply.
+    // Return Value:
+    // - <none>
+    void ControlCore::ColorScheme(const Core::Scheme& scheme)
+    {
+        auto l{ _terminal->LockForWriting() };
+
+        _settings->FocusedAppearance()->DefaultForeground(scheme.Foreground);
+        _settings->FocusedAppearance()->DefaultBackground(scheme.Background);
+        _settings->FocusedAppearance()->CursorColor(scheme.CursorColor);
+        _settings->FocusedAppearance()->SelectionBackground(scheme.SelectionBackground);
+
+        _settings->FocusedAppearance()->SetColorTableEntry(0, scheme.Black);
+        _settings->FocusedAppearance()->SetColorTableEntry(1, scheme.Red);
+        _settings->FocusedAppearance()->SetColorTableEntry(2, scheme.Green);
+        _settings->FocusedAppearance()->SetColorTableEntry(3, scheme.Yellow);
+        _settings->FocusedAppearance()->SetColorTableEntry(4, scheme.Blue);
+        _settings->FocusedAppearance()->SetColorTableEntry(5, scheme.Purple);
+        _settings->FocusedAppearance()->SetColorTableEntry(6, scheme.Cyan);
+        _settings->FocusedAppearance()->SetColorTableEntry(7, scheme.White);
+        _settings->FocusedAppearance()->SetColorTableEntry(8, scheme.BrightBlack);
+        _settings->FocusedAppearance()->SetColorTableEntry(9, scheme.BrightRed);
+        _settings->FocusedAppearance()->SetColorTableEntry(10, scheme.BrightGreen);
+        _settings->FocusedAppearance()->SetColorTableEntry(11, scheme.BrightYellow);
+        _settings->FocusedAppearance()->SetColorTableEntry(12, scheme.BrightBlue);
+        _settings->FocusedAppearance()->SetColorTableEntry(13, scheme.BrightPurple);
+        _settings->FocusedAppearance()->SetColorTableEntry(14, scheme.BrightCyan);
+        _settings->FocusedAppearance()->SetColorTableEntry(15, scheme.BrightWhite);
+
+        _terminal->ApplyScheme(scheme);
+        _renderEngine->SetSelectionBackground(til::color{ _settings->SelectionBackground() });
+
+        _renderer->TriggerRedrawAll();
+        _BackgroundColorChangedHandlers(*this, nullptr);
+    }
+
+    bool ControlCore::HasUnfocusedAppearance() const
+    {
+        return _settings->HasUnfocusedAppearance();
+    }
+
+    bool ControlCore::_isBackgroundTransparent()
+    {
+        // If we're:
+        // * Not fully opaque
+        // * On an acrylic background (of any opacity)
+        // * rendering on top of an image
+        //
+        // then the renderer should not render "default background" text with a
+        // fully opaque background. Doing that would cover up our nice
+        // transparency, or our acrylic, or our image.
+        return Opacity() < 1.0f || UseAcrylic() || !_settings->BackgroundImage().empty();
+    }
 }

src/cascadia/TerminalControl/ControlCore.h

@@ -16,23 +16,35 @@
 #pragma once
 
 #include "ControlCore.g.h"
+#include "ControlSettings.h"
 #include "../../renderer/base/Renderer.hpp"
 #include "../../cascadia/TerminalCore/Terminal.hpp"
 #include "../buffer/out/search.h"
 #include "cppwinrt_utils.h"
 
+#include <til/ticket_lock.h>
+
 namespace ControlUnitTests
 {
     class ControlCoreTests;
     class ControlInteractivityTests;
 };
 
+#define RUNTIME_SETTING(type, name, setting)                      \
+private:                                                          \
+    std::optional<type> _runtime##name{ std::nullopt };           \
+    void name(const type newValue) { _runtime##name = newValue; } \
+                                                                  \
+public:                                                           \
+    type name() const { return til::coalesce_value(_runtime##name, setting); }
+
 namespace winrt::Microsoft::Terminal::Control::implementation
 {
     struct ControlCore : ControlCoreT<ControlCore>
     {
     public:
-        ControlCore(IControlSettings settings,
+        ControlCore(Control::IControlSettings settings,
+                    Control::IControlAppearance unfocusedAppearance,
                     TerminalConnection::ITerminalConnection connection);
         ~ControlCore();
 
@@ -41,8 +53,16 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                         const double compositionScale);
         void EnablePainting();
 
-        void UpdateSettings(const IControlSettings& settings);
-        void UpdateAppearance(const IControlAppearance& newAppearance);
+        void UpdateSettings(const Control::IControlSettings& settings, const IControlAppearance& newAppearance);
+        void ApplyAppearance(const bool& focused);
+        Control::IControlSettings Settings() { return *_settings; };
+        Control::IControlAppearance FocusedAppearance() const { return *_settings->FocusedAppearance(); };
+        Control::IControlAppearance UnfocusedAppearance() const { return *_settings->UnfocusedAppearance(); };
+        bool HasUnfocusedAppearance() const;
+
+        winrt::Microsoft::Terminal::Core::Scheme ColorScheme() const noexcept;
+        void ColorScheme(const winrt::Microsoft::Terminal::Core::Scheme& scheme);
+
         void SizeChanged(const double width, const double height);
         void ScaleChanged(const double scale);
         uint64_t SwapChainHandle() const;
@@ -57,7 +77,6 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         uint16_t FontWeight() const noexcept;
 
         til::color BackgroundColor() const;
-        void SetBackgroundOpacity(const double opacity);
 
         void SendInput(const winrt::hstring& wstr);
         void PasteText(const winrt::hstring& hstr);
@@ -148,6 +167,9 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         static bool IsVintageOpacityAvailable() noexcept;
 
+        RUNTIME_SETTING(double, Opacity, _settings->Opacity());
+        RUNTIME_SETTING(bool, UseAcrylic, _settings->UseAcrylic());
+
         // -------------------------------- WinRT Events ---------------------------------
         // clang-format off
         WINRT_CALLBACK(FontSizeChanged, Control::FontSizeChangedEventArgs);
@@ -178,6 +200,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         event_token _connectionOutputEventToken;
         TerminalConnection::ITerminalConnection::StateChanged_revoker _connectionStateChangedRevoker;
 
+        winrt::com_ptr<ControlSettings> _settings{ nullptr };
+
         std::unique_ptr<::Microsoft::Terminal::Core::Terminal> _terminal{ nullptr };
 
         // NOTE: _renderEngine must be ordered before _renderer.
@@ -188,8 +212,6 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         std::unique_ptr<::Microsoft::Console::Render::IRenderEngine> _renderEngine{ nullptr };
         std::unique_ptr<::Microsoft::Console::Render::Renderer> _renderer{ nullptr };
 
-        IControlSettings _settings{ nullptr };
-
         FontInfoDesired _desiredFont;
         FontInfo _actualFont;
         winrt::hstring _actualFontFaceName;
@@ -249,6 +271,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         void _connectionOutputHandler(const hstring& hstr);
         void _updateHoveredCell(const std::optional<til::point> terminalPosition);
 
+        bool _isBackgroundTransparent();
+
         inline bool _IsClosing() const noexcept
         {
 #ifndef NDEBUG

src/cascadia/TerminalControl/ControlCore.idl

@@ -33,20 +33,27 @@ namespace Microsoft.Terminal.Control
     [default_interface] runtimeclass ControlCore : ICoreState
     {
         ControlCore(IControlSettings settings,
+                    IControlAppearance unfocusedAppearance,
                     Microsoft.Terminal.TerminalConnection.ITerminalConnection connection);
 
         Boolean Initialize(Double actualWidth,
                            Double actualHeight,
                            Double compositionScale);
 
-        void UpdateSettings(IControlSettings settings);
-        void UpdateAppearance(IControlAppearance appearance);
+        void UpdateSettings(IControlSettings settings, IControlAppearance appearance);
+        void ApplyAppearance(Boolean focused);
+
+        IControlSettings Settings { get; };
+        IControlAppearance FocusedAppearance { get; };
+        IControlAppearance UnfocusedAppearance { get; };
+        Boolean HasUnfocusedAppearance();
 
         UInt64 SwapChainHandle { get; };
 
         Windows.Foundation.Size FontSize { get; };
         String FontFaceName { get; };
         UInt16 FontWeight { get; };
+        Double Opacity { get; };
 
         Boolean TrySendKeyEvent(Int16 vkey,
                              Int16 scanCode,
@@ -75,7 +82,6 @@ namespace Microsoft.Terminal.Control
         void BlinkAttributeTick();
         void UpdatePatternLocations();
         void Search(String text, Boolean goForward, Boolean caseSensitive);
-        void SetBackgroundOpacity(Double opacity);
         Microsoft.Terminal.Core.Color BackgroundColor { get; };
 
         Boolean HasSelection { get; };

src/cascadia/TerminalControl/ControlInteractivity.cpp

@@ -39,13 +39,14 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     }
 
     ControlInteractivity::ControlInteractivity(IControlSettings settings,
+                                               Control::IControlAppearance unfocusedAppearance,
                                                TerminalConnection::ITerminalConnection connection) :
         _touchAnchor{ std::nullopt },
         _lastMouseClickTimestamp{},
         _lastMouseClickPos{},
         _selectionNeedsToBeCopied{ false }
     {
-        _core = winrt::make_self<ControlCore>(settings, connection);
+        _core = winrt::make_self<ControlCore>(settings, unfocusedAppearance, connection);
     }
 
     // Method Description:
@@ -641,4 +642,15 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         return _core->GetUiaData();
     }
 
+    // Method Description:
+    // - Used by the TermControl to know if it should translate drag-dropped
+    //   paths into WSL-friendly paths.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - true if the connection we were created with was a WSL profile.
+    bool ControlInteractivity::ManglePathsForWsl()
+    {
+        return _core->Settings().ProfileSource() == L"Windows.Terminal.Wsl";
+    }
 }

src/cascadia/TerminalControl/ControlInteractivity.h

@@ -36,6 +36,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     {
     public:
         ControlInteractivity(IControlSettings settings,
+                             Control::IControlAppearance unfocusedAppearance,
                              TerminalConnection::ITerminalConnection connection);
 
         void GotFocus();
@@ -83,6 +84,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                                       const Windows::Foundation::IReference<CopyFormat>& formats);
         void RequestPasteTextFromClipboard();
         void SetEndSelectionPoint(const til::point pixelPosition);
+        bool ManglePathsForWsl();
 
         TYPED_EVENT(OpenHyperlink, IInspectable, Control::OpenHyperlinkEventArgs);
         TYPED_EVENT(PasteFromClipboard, IInspectable, Control::PasteFromClipboardEventArgs);

src/cascadia/TerminalControl/ControlInteractivity.idl

@@ -14,6 +14,7 @@ namespace Microsoft.Terminal.Control
     [default_interface] runtimeclass ControlInteractivity
     {
         ControlInteractivity(IControlSettings settings,
+                             IControlAppearance unfocusedAppearance,
                              Microsoft.Terminal.TerminalConnection.ITerminalConnection connection);
 
         ControlCore Core { get; };
@@ -58,6 +59,8 @@ namespace Microsoft.Terminal.Control
 
         void UpdateScrollbar(Double newValue);
 
+        Boolean ManglePathsForWsl { get; };
+
         event Windows.Foundation.TypedEventHandler<Object, OpenHyperlinkEventArgs> OpenHyperlink;
         event Windows.Foundation.TypedEventHandler<Object, ScrollPositionChangedArgs> ScrollPositionChanged;
         event Windows.Foundation.TypedEventHandler<Object, PasteFromClipboardEventArgs> PasteFromClipboard;

src/cascadia/TerminalControl/ControlSettings.h

@@ -0,0 +1,81 @@
+/*++
+Copyright (c) Microsoft Corporation
+Licensed under the MIT license.
+--*/
+#pragma once
+#include "../../inc/cppwinrt_utils.h"
+#include "../../inc/ControlProperties.h"
+
+#include <DefaultSettings.h>
+#include <conattrs.hpp>
+#include "ControlAppearance.h"
+
+using IFontFeatureMap = winrt::Windows::Foundation::Collections::IMap<winrt::hstring, uint32_t>;
+using IFontAxesMap = winrt::Windows::Foundation::Collections::IMap<winrt::hstring, float>;
+
+namespace winrt::Microsoft::Terminal::Control::implementation
+{
+    struct ControlSettings : public winrt::implements<ControlSettings, Microsoft::Terminal::Control::IControlSettings, Microsoft::Terminal::Control::IControlAppearance, Microsoft::Terminal::Core::ICoreSettings, Microsoft::Terminal::Core::ICoreAppearance>
+    {
+        // Getters and setters for each *Setting member. We're not using
+        // WINRT_PROPERTY for these, because they actually exist inside the
+        // _focusedAppearance member. We don't need to reserve another member to
+        // hold them.
+#define SETTINGS_GEN(type, name, ...) WINRT_PROPERTY(type, name, __VA_ARGS__);
+        CORE_SETTINGS(SETTINGS_GEN)
+        CONTROL_SETTINGS(SETTINGS_GEN)
+#undef SETTINGS_GEN
+
+    private:
+        winrt::com_ptr<ControlAppearance> _unfocusedAppearance{ nullptr };
+        winrt::com_ptr<ControlAppearance> _focusedAppearance{ nullptr };
+        bool _hasUnfocusedAppearance{ false };
+
+    public:
+        ControlSettings(const Control::IControlSettings& settings,
+                        const Control::IControlAppearance& unfocusedAppearance)
+        {
+            _hasUnfocusedAppearance = unfocusedAppearance != nullptr;
+
+            _focusedAppearance = winrt::make_self<implementation::ControlAppearance>(settings);
+            _unfocusedAppearance = unfocusedAppearance ?
+                                       winrt::make_self<implementation::ControlAppearance>(unfocusedAppearance) :
+                                       _focusedAppearance;
+
+            // Copy every value from the passed in settings, into us.
+#define COPY_SETTING(type, name, ...) _##name = settings.name();
+            CORE_SETTINGS(COPY_SETTING)
+            CONTROL_SETTINGS(COPY_SETTING)
+#undef COPY_SETTING
+        }
+
+        winrt::com_ptr<ControlAppearance> UnfocusedAppearance() { return _unfocusedAppearance; }
+        winrt::com_ptr<ControlAppearance> FocusedAppearance() { return _focusedAppearance; }
+        bool HasUnfocusedAppearance() { return _hasUnfocusedAppearance; }
+
+        // Getters and setters for each Appearance member. We're not using
+        // WINRT_PROPERTY for these, because they actually exist inside the
+        // _focusedAppearance member. We don't need to reserve another member to
+        // hold them.
+        //
+        // The Appearance members (including GetColorTableEntry below) are used
+        // when this ControlSettings is cast to a IControlAppearance or
+        // ICoreAppearance. In those cases, we'll always return the Focused
+        // appearance's version of the member. Callers who care about which
+        // appearance is being used should be more careful. Fortunately, this
+        // situation is generally only used when a control is first created, or
+        // when calling UpdateSettings.
+#define APPEARANCE_GEN(type, name, ...)                               \
+    type name() const noexcept { return _focusedAppearance->name(); } \
+    void name(const type& value) noexcept { _focusedAppearance->name(value); }
+
+        CORE_APPEARANCE_SETTINGS(APPEARANCE_GEN)
+        CONTROL_APPEARANCE_SETTINGS(APPEARANCE_GEN)
+#undef APPEARANCE_GEN
+
+        winrt::Microsoft::Terminal::Core::Color GetColorTableEntry(int32_t index) noexcept
+        {
+            return _focusedAppearance->GetColorTableEntry(index);
+        }
+    };
+}

src/cascadia/TerminalControl/IControlAppearance.idl

@@ -5,18 +5,18 @@ namespace Microsoft.Terminal.Control
 {
     interface IControlAppearance requires Microsoft.Terminal.Core.ICoreAppearance
     {
-        Microsoft.Terminal.Core.Color SelectionBackground;
-        String BackgroundImage;
-        Double BackgroundImageOpacity;
-        Windows.UI.Xaml.Media.Stretch BackgroundImageStretchMode;
-        Windows.UI.Xaml.HorizontalAlignment BackgroundImageHorizontalAlignment;
-        Windows.UI.Xaml.VerticalAlignment BackgroundImageVerticalAlignment;
-        Boolean IntenseIsBold;
+        Microsoft.Terminal.Core.Color SelectionBackground { get; };
+        String BackgroundImage { get; };
+        Double BackgroundImageOpacity { get; };
+        Windows.UI.Xaml.Media.Stretch BackgroundImageStretchMode { get; };
+        Windows.UI.Xaml.HorizontalAlignment BackgroundImageHorizontalAlignment { get; };
+        Windows.UI.Xaml.VerticalAlignment BackgroundImageVerticalAlignment { get; };
+        Boolean IntenseIsBold { get; };
         // IntenseIsBright is in Core Appearance
-        Double Opacity;
+        Double Opacity { get; };
 
         // Experimental settings
-        Boolean RetroTerminalEffect;
-        String PixelShaderPath;
+        Boolean RetroTerminalEffect { get; };
+        String PixelShaderPath { get; };
     };
 }

src/cascadia/TerminalControl/IControlSettings.idl

@@ -24,34 +24,37 @@ namespace Microsoft.Terminal.Control
     //      TermControl's behavior. In these settings there is both the entirety
     //      of the Core ITerminalSettings interface, and any additional settings
     //      for specifically the control.
-    interface IControlSettings requires Microsoft.Terminal.Core.ICoreSettings, Microsoft.Terminal.Control.IControlAppearance
+    interface IControlSettings requires Microsoft.Terminal.Core.ICoreSettings,
+                               Microsoft.Terminal.Control.IControlAppearance
     {
         String ProfileName;
         String ProfileSource;
 
-        Boolean UseAcrylic;
-        ScrollbarState ScrollState;
-        Boolean UseAtlasEngine;
-        String FontFace;
-        Int32 FontSize;
-        Windows.UI.Text.FontWeight FontWeight;
-        String Padding;
-        Windows.Foundation.Collections.IMap<String, UInt32> FontFeatures;
-        Windows.Foundation.Collections.IMap<String, Single> FontAxes;
+        Boolean UseAcrylic { get; };
+        ScrollbarState ScrollState { get; };
 
-        Microsoft.Terminal.Control.IKeyBindings KeyBindings;
+        Boolean UseAtlasEngine { get; };
 
-        Boolean CopyOnSelect;
-        Boolean FocusFollowMouse;
+        String FontFace { get; };
+        Int32 FontSize { get; };
+        Windows.UI.Text.FontWeight FontWeight { get; };
+        String Padding { get; };
+        Windows.Foundation.Collections.IMap<String, UInt32> FontFeatures { get; };
+        Windows.Foundation.Collections.IMap<String, Single> FontAxes { get; };
 
-        String Commandline;
-        String StartingDirectory;
-        String EnvironmentVariables;
+        Microsoft.Terminal.Control.IKeyBindings KeyBindings { get; };
 
-        TextAntialiasingMode AntialiasingMode;
+        Boolean CopyOnSelect { get; };
+        Boolean FocusFollowMouse { get; };
+
+        String Commandline { get; };
+        String StartingDirectory { get; };
+        String EnvironmentVariables { get; };
+
+        TextAntialiasingMode AntialiasingMode { get; };
 
         // Experimental Settings
-        Boolean ForceFullRepaintRendering;
-        Boolean SoftwareRendering;
+        Boolean ForceFullRepaintRendering { get; };
+        Boolean SoftwareRendering { get; };
     };
 }

src/cascadia/TerminalControl/ICoreState.idl

@@ -22,5 +22,7 @@ namespace Microsoft.Terminal.Control
         Boolean BracketedPasteEnabled { get; };
 
         Microsoft.Terminal.TerminalConnection.ConnectionState ConnectionState { get; };
+
+        Microsoft.Terminal.Core.Scheme ColorScheme { get; set; };
     };
 }

src/cascadia/TerminalControl/TermControl.cpp

@@ -48,8 +48,8 @@ DEFINE_ENUM_FLAG_OPERATORS(winrt::Microsoft::Terminal::Control::MouseButtonState
 namespace winrt::Microsoft::Terminal::Control::implementation
 {
     TermControl::TermControl(IControlSettings settings,
+                             Control::IControlAppearance unfocusedAppearance,
                              TerminalConnection::ITerminalConnection connection) :
-        _settings{ settings },
         _isInternalScrollBarUpdate{ false },
         _autoScrollVelocity{ 0 },
         _autoScrollingPointerPoint{ std::nullopt },
@@ -61,7 +61,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     {
         InitializeComponent();
 
-        _interactivity = winrt::make<implementation::ControlInteractivity>(settings, connection);
+        _interactivity = winrt::make<implementation::ControlInteractivity>(settings, unfocusedAppearance, connection);
         _core = _interactivity.Core();
 
         // These events might all be triggered by the connection, but that
@@ -77,7 +77,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         // These callbacks can only really be triggered by UI interactions. So
         // they don't need weak refs - they can't be triggered unless we're
         // alive.
-        _core.BackgroundColorChanged({ this, &TermControl::_BackgroundColorChangedHandler });
+        _core.BackgroundColorChanged({ this, &TermControl::_coreBackgroundColorChanged });
         _core.FontSizeChanged({ this, &TermControl::_coreFontSizeChanged });
         _core.TransparencyChanged({ this, &TermControl::_coreTransparencyChanged });
         _core.RaiseNotice({ this, &TermControl::_coreRaisedNotice });
@@ -144,7 +144,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         _autoScrollTimer.Interval(AutoScrollUpdateInterval);
         _autoScrollTimer.Tick({ this, &TermControl::_UpdateAutoScroll });
 
-        _ApplyUISettings(_settings);
+        _ApplyUISettings();
     }
 
     // Method Description:
@@ -229,11 +229,15 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         this->Focus(FocusState::Programmatic);
     }
 
+    winrt::fire_and_forget TermControl::UpdateControlSettings(IControlSettings settings)
+    {
+        return UpdateControlSettings(settings, _core.UnfocusedAppearance());
+    }
     // Method Description:
     // - Given Settings having been updated, applies the settings to the current terminal.
     // Return Value:
     // - <none>
-    winrt::fire_and_forget TermControl::UpdateSettings()
+    winrt::fire_and_forget TermControl::UpdateControlSettings(IControlSettings settings, IControlAppearance unfocusedAppearance)
     {
         auto weakThis{ get_weak() };
 
@@ -241,21 +245,18 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         // terminal.
         co_await winrt::resume_foreground(Dispatcher());
 
-        _UpdateSettingsFromUIThread(_settings);
+        _core.UpdateSettings(settings, unfocusedAppearance);
 
-        auto appearance = _settings.try_as<IControlAppearance>();
-        if (!_focused && _UnfocusedAppearance)
-        {
-            appearance = _UnfocusedAppearance;
-        }
-        _UpdateAppearanceFromUIThread(appearance);
+        _UpdateSettingsFromUIThread();
+
+        _UpdateAppearanceFromUIThread(_focused ? _core.FocusedAppearance() : _core.UnfocusedAppearance());
     }
 
     // Method Description:
     // - Dispatches a call to the UI thread and updates the appearance
     // Arguments:
     // - newAppearance: the new appearance to set
-    winrt::fire_and_forget TermControl::UpdateAppearance(const IControlAppearance newAppearance)
+    winrt::fire_and_forget TermControl::UpdateAppearance(IControlAppearance newAppearance)
     {
         // Dispatch a call to the UI thread
         co_await winrt::resume_foreground(Dispatcher());
@@ -271,17 +272,15 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     // - INVARIANT: This method must be called from the UI thread.
     // Arguments:
     // - newSettings: the new settings to set
-    void TermControl::_UpdateSettingsFromUIThread(IControlSettings newSettings)
+    void TermControl::_UpdateSettingsFromUIThread()
     {
         if (_IsClosing())
         {
             return;
         }
 
-        _core.UpdateSettings(_settings);
-
         // Update our control settings
-        _ApplyUISettings(_settings);
+        _ApplyUISettings();
     }
 
     // Method Description:
@@ -289,7 +288,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     // - INVARIANT: This method must be called from the UI thread.
     // Arguments:
     // - newAppearance: the new appearance to set
-    void TermControl::_UpdateAppearanceFromUIThread(IControlAppearance newAppearance)
+    void TermControl::_UpdateAppearanceFromUIThread(Control::IControlAppearance newAppearance)
     {
         if (_IsClosing())
         {
@@ -300,6 +299,10 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         // Update our control settings
         const auto bg = newAppearance.DefaultBackground();
+
+        // In the future, this might need to be changed to a
+        // _InitializeBackgroundBrush call instead, because we may need to
+        // switch from a solid color brush to an acrylic one.
         _changeBackgroundColor(bg);
 
         // Set TSF Foreground
@@ -307,7 +310,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         foregroundBrush.Color(static_cast<til::color>(newAppearance.DefaultForeground()));
         TSFInputControl().Foreground(foregroundBrush);
 
-        _core.UpdateAppearance(newAppearance);
+        _core.ApplyAppearance(_focused);
     }
 
     // Method Description:
@@ -331,7 +334,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     }
 
     // Method Description:
-    // - Style our UI elements based on the values in our _settings, and set up
+    // - Style our UI elements based on the values in our settings, and set up
     //   other control-specific settings. This method will be called whenever
     //   the settings are reloaded.
     //   * Calls _InitializeBackgroundBrush to set up the Xaml brush responsible
@@ -342,21 +345,21 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     // - <none>
     // Return Value:
     // - <none>
-    void TermControl::_ApplyUISettings(const IControlSettings& newSettings)
+    void TermControl::_ApplyUISettings()
     {
         _InitializeBackgroundBrush();
 
-        const auto bg = newSettings.DefaultBackground();
-        _changeBackgroundColor(bg);
+        // settings might be out-of-proc in the future
+        auto settings{ _core.Settings() };
 
         // Apply padding as swapChainPanel's margin
-        const auto newMargin = ParseThicknessFromPadding(newSettings.Padding());
+        const auto newMargin = ParseThicknessFromPadding(settings.Padding());
         SwapChainPanel().Margin(newMargin);
 
         TSFInputControl().Margin(newMargin);
 
         // Apply settings for scrollbar
-        if (newSettings.ScrollState() == ScrollbarState::Hidden)
+        if (settings.ScrollState() == ScrollbarState::Hidden)
         {
             // In the scenario where the user has turned off the OS setting to automatically hide scrollbars, the
             // Terminal scrollbar would still be visible; so, we need to set the control's visibility accordingly to
@@ -440,16 +443,15 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     //       use bgcolor as acrylic's tint
     // - Avoids image flickering and acrylic brush redraw if settings are changed
     //   but the appropriate brush is still in place.
-    // - Does not apply background color outside of acrylic mode;
-    //   _BackgroundColorChanged must be called to do so.
     // Arguments:
     // - <none>
     // Return Value:
     // - <none>
     void TermControl::_InitializeBackgroundBrush()
     {
-        auto appearance = _settings.try_as<IControlAppearance>();
-        if (_settings.UseAcrylic())
+        auto settings{ _core.Settings() };
+        auto bgColor = til::color{ _core.FocusedAppearance().DefaultBackground() }.with_alpha(0xff);
+        if (settings.UseAcrylic())
         {
             // See if we've already got an acrylic background brush
             // to avoid the flicker when setting up a new one
@@ -464,65 +466,83 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
             // see GH#1082: Initialize background color so we don't get a
             // fade/flash when _BackgroundColorChanged is called
-            auto bgColor = til::color{ _settings.DefaultBackground() }.with_alpha(0xff);
-
             acrylic.FallbackColor(bgColor);
             acrylic.TintColor(bgColor);
 
             // Apply brush settings
-            acrylic.TintOpacity(appearance.Opacity());
+            acrylic.TintOpacity(_core.Opacity());
 
             // Apply brush to control if it's not already there
             if (RootGrid().Background() != acrylic)
             {
                 RootGrid().Background(acrylic);
             }
-
-            // GH#5098: Inform the engine of the new opacity of the default text background.
-            _core.SetBackgroundOpacity(appearance.Opacity());
         }
         else
         {
             Media::SolidColorBrush solidColor{};
-            solidColor.Opacity(_settings.Opacity());
-            RootGrid().Background(solidColor);
+            solidColor.Opacity(_core.Opacity());
+            solidColor.Color(bgColor);
 
-            // GH#5098: Inform the engine of the new opacity of the default text background.
-            _core.SetBackgroundOpacity(appearance.Opacity());
+            RootGrid().Background(solidColor);
         }
     }
 
     // Method Description:
-    // - Style the background of the control with the provided background color
+    // - Handler for the core's BackgroundColorChanged event. Updates the color
+    //   of our background brush to match.
+    // - Hops over to the UI thread to do this work.
     // Arguments:
-    // - color: The background color to use as a uint32 (aka DWORD COLORREF)
+    // <unused>
     // Return Value:
     // - <none>
-    void TermControl::_BackgroundColorChangedHandler(const IInspectable& /*sender*/,
-                                                     const IInspectable& /*args*/)
-    {
-        til::color newBgColor{ _core.BackgroundColor() };
-        _changeBackgroundColor(newBgColor);
-    }
-
-    winrt::fire_and_forget TermControl::_changeBackgroundColor(const til::color bg)
+    winrt::fire_and_forget TermControl::_coreBackgroundColorChanged(const IInspectable& /*sender*/,
+                                                                    const IInspectable& /*args*/)
     {
         auto weakThis{ get_weak() };
         co_await winrt::resume_foreground(Dispatcher());
-
         if (auto control{ weakThis.get() })
         {
-            if (auto acrylic = RootGrid().Background().try_as<Media::AcrylicBrush>())
-            {
-                acrylic.FallbackColor(bg);
-                acrylic.TintColor(bg);
-            }
-            else if (auto solidColor = RootGrid().Background().try_as<Media::SolidColorBrush>())
-            {
-                const auto originalOpacity = solidColor.Opacity();
-                solidColor.Color(bg);
-                solidColor.Opacity(originalOpacity);
-            }
+            til::color newBgColor{ _core.BackgroundColor() };
+            _changeBackgroundColor(newBgColor);
+        }
+    }
+
+    // Method Description:
+    // - Update the color of the background brush we're using. This does _not_
+    //   update the opacity, or what type of brush it is.
+    // - INVARIANT: This needs to be called on the UI thread.
+    // Arguments:
+    // - bg: the new color to use as the background color.
+    void TermControl::_changeBackgroundColor(const til::color bg)
+    {
+        if (auto acrylic = RootGrid().Background().try_as<Media::AcrylicBrush>())
+        {
+            acrylic.FallbackColor(bg);
+            acrylic.TintColor(bg);
+        }
+        else if (auto solidColor = RootGrid().Background().try_as<Media::SolidColorBrush>())
+        {
+            const auto originalOpacity = solidColor.Opacity();
+            solidColor.Color(bg);
+            solidColor.Opacity(originalOpacity);
+        }
+    }
+
+    // Method Description:
+    // - Update the opacity of the background brush we're using. This does _not_
+    //   update the color, or what type of brush it is.
+    // - INVARIANT: This needs to be called on the UI thread.
+    void TermControl::_changeBackgroundOpacity()
+    {
+        const auto opacity{ _core.Opacity() };
+        if (auto acrylic = RootGrid().Background().try_as<Media::AcrylicBrush>())
+        {
+            acrylic.TintOpacity(opacity);
+        }
+        else if (auto solidColor = RootGrid().Background().try_as<Media::SolidColorBrush>())
+        {
+            solidColor.Opacity(opacity);
         }
     }
 
@@ -618,7 +638,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                 HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) == hr)
             {
                 message = { fmt::format(std::wstring_view{ RS_(L"PixelShaderNotFound") },
-                                        _settings.PixelShaderPath()) };
+                                        (_focused ? _core.FocusedAppearance() : _core.UnfocusedAppearance()).PixelShaderPath()) };
             }
             else if (D2DERR_SHADER_COMPILE_FAILED == hr)
             {
@@ -740,7 +760,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         }
 
         // Now that the renderer is set up, update the appearance for initialization
-        _UpdateAppearanceFromUIThread(_settings);
+        _UpdateAppearanceFromUIThread(_core.FocusedAppearance());
 
         _initializedTerminal = true;
 
@@ -812,7 +832,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             //   This is required as part of GH#638.
             // Or do so for alt+space; only send to terminal when explicitly unbound
             //  That is part of #GH7125
-            auto bindings{ _settings.KeyBindings() };
+            auto bindings{ _core.Settings().KeyBindings() };
             bool isUnbound = false;
             const KeyChord kc = {
                 modifiers.IsCtrlPressed(),
@@ -957,7 +977,13 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     // - modifiers: The ControlKeyStates representing the modifier key states.
     bool TermControl::_TryHandleKeyBinding(const WORD vkey, const WORD scanCode, ::Microsoft::Terminal::Core::ControlKeyStates modifiers) const
     {
-        auto bindings = _settings.KeyBindings();
+        // TODO: GH#5000
+        // The Core owning the keybindings is weird. That's for sure. In the
+        // future, we may want to pass the keybindings into the control
+        // separately, so the control can have a pointer to an in-proc
+        // Keybindings object, rather than routing through the ControlCore.
+        // (see GH#5000)
+        auto bindings = _core.Settings().KeyBindings();
         if (!bindings)
         {
             return false;
@@ -1136,7 +1162,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         const auto pixelPosition = _toTerminalOrigin(cursorPosition);
         const auto type = ptr.PointerDeviceType();
 
-        if (!_focused && _settings.FocusFollowMouse())
+        if (!_focused && _core.Settings().FocusFollowMouse())
         {
             _FocusFollowMouseRequestedHandlers(*this, nullptr);
         }
@@ -1304,7 +1330,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     // - Called in response to the core's TransparencyChanged event. We'll use
     //   this to update our background brush.
     // - The Core should have already updated the TintOpacity and UseAcrylic
-    //   properties in the _settings.
+    //   properties in the _settings->
     // Arguments:
     // - <unused>
     // Return Value:
@@ -1315,9 +1341,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         co_await resume_foreground(Dispatcher());
         try
         {
-            _InitializeBackgroundBrush();
-            const auto bg = _settings.DefaultBackground();
-            _changeBackgroundColor(bg);
+            _changeBackgroundOpacity();
         }
         CATCH_LOG();
     }
@@ -1524,12 +1548,13 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             _blinkTimer->Start();
         }
 
-        // Only update the appearance here if an unfocused config exists -
-        // if an unfocused config does not exist then we never would have switched
-        // appearances anyway so there's no need to switch back upon gaining focus
-        if (_UnfocusedAppearance)
+        // Only update the appearance here if an unfocused config exists - if an
+        // unfocused config does not exist then we never would have switched
+        // appearances anyway so there's no need to switch back upon gaining
+        // focus
+        if (_core.HasUnfocusedAppearance())
         {
-            UpdateAppearance(_settings);
+            UpdateAppearance(_core.FocusedAppearance());
         }
     }
 
@@ -1571,9 +1596,9 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         // Check if there is an unfocused config we should set the appearance to
         // upon losing focus
-        if (_UnfocusedAppearance)
+        if (_core.HasUnfocusedAppearance())
         {
-            UpdateAppearance(_UnfocusedAppearance);
+            UpdateAppearance(_core.UnfocusedAppearance());
         }
     }
 
@@ -1722,7 +1747,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
     hstring TermControl::GetProfileName() const
     {
-        return _settings.ProfileName();
+        return _core.Settings().ProfileName();
     }
 
     hstring TermControl::WorkingDirectory() const
@@ -1944,7 +1969,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             double width = fontSize.Width;
             double height = fontSize.Height;
             // Reserve additional space if scrollbar is intended to be visible
-            if (_settings.ScrollState() == ScrollbarState::Visible)
+            if (_core.Settings().ScrollState() == ScrollbarState::Visible)
             {
                 width += ScrollBar().ActualWidth();
             }
@@ -1965,7 +1990,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             const winrt::Windows::Foundation::Size minSize{ 1, 1 };
             const double scaleFactor = DisplayInformation::GetForCurrentView().RawPixelsPerViewPixel();
             const auto dpi = ::base::saturated_cast<uint32_t>(USER_DEFAULT_SCREEN_DPI * scaleFactor);
-            return GetProposedDimensions(_settings, dpi, minSize);
+
+            return GetProposedDimensions(_core.Settings(), dpi, minSize);
         }
     }
 
@@ -1987,7 +2013,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                                                            padding.Left + padding.Right :
                                                            padding.Top + padding.Bottom);
 
-        if (widthOrHeight && _settings.ScrollState() == ScrollbarState::Visible)
+        if (widthOrHeight && _core.Settings().ScrollState() == ScrollbarState::Visible)
         {
             nonTerminalArea += gsl::narrow_cast<float>(ScrollBar().ActualWidth());
         }
@@ -2270,7 +2296,16 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                     std::wstring fullPath{ item.Path() };
 
                     // Fix path for WSL
-                    if (_settings.ProfileSource() == L"Windows.Terminal.Wsl")
+                    // In the fullness of time, we should likely plumb this up
+                    // to the TerminalApp layer, and have it make the decision
+                    // if this control should have it's path mangled (and do the
+                    // mangling), rather than exposing the source concept to the
+                    // Control layer.
+                    //
+                    // However, it's likely that the control layer may need to
+                    // know about the source anyways in the future, to support
+                    // GH#3158
+                    if (_interactivity.ManglePathsForWsl())
                     {
                         std::replace(fullPath.begin(), fullPath.end(), L'\\', L'/');
 
@@ -2417,12 +2452,19 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
     IControlSettings TermControl::Settings() const
     {
-        return _settings;
-    }
-
-    void TermControl::Settings(IControlSettings newSettings)
-    {
-        _settings = newSettings;
+        // TODO: GH#5000
+        // We still need this in a couple places:
+        // - Pane.cpp uses this for parsing out the StartingTitle, Commandline,
+        //   etc for Pane::GetTerminalArgsForPane.
+        // - TerminalTab::_CreateToolTipTitle uses the ProfileName for the
+        //   tooltip for the tab.
+        //
+        // These both happen on the UI thread right now. In the future, when we
+        // have to hop across the process boundary to get at the core settings,
+        // it may make sense to cache these values inside the TermControl
+        // itself, so it can do the hop once when it's first setup, rather than
+        // when it's needed by the UI thread.
+        return _core.Settings();
     }
 
     Windows::Foundation::IReference<winrt::Windows::UI::Color> TermControl::TabColor() noexcept
@@ -2645,4 +2687,19 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     {
         return _core.ReadEntireBuffer();
     }
+
+    Core::Scheme TermControl::ColorScheme() const noexcept
+    {
+        return _core.ColorScheme();
+    }
+
+    void TermControl::ColorScheme(const Core::Scheme& scheme) const noexcept
+    {
+        _core.ColorScheme(scheme);
+    }
+
+    Media::Brush TermControl::BackgroundBrush()
+    {
+        return RootGrid().Background();
+    }
 }

src/cascadia/TerminalControl/TermControl.h

@@ -25,10 +25,13 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 {
     struct TermControl : TermControlT<TermControl>
     {
-        TermControl(IControlSettings settings, TerminalConnection::ITerminalConnection connection);
+        TermControl(IControlSettings settings,
+                    Control::IControlAppearance unfocusedAppearance,
+                    TerminalConnection::ITerminalConnection connection);
 
-        winrt::fire_and_forget UpdateSettings();
-        winrt::fire_and_forget UpdateAppearance(const IControlAppearance newAppearance);
+        winrt::fire_and_forget UpdateControlSettings(Control::IControlSettings settings);
+        winrt::fire_and_forget UpdateControlSettings(Control::IControlSettings settings, Control::IControlAppearance unfocusedAppearance);
+        IControlSettings Settings() const;
 
         hstring GetProfileName() const;
 
@@ -88,9 +91,6 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         Windows::UI::Xaml::Automation::Peers::AutomationPeer OnCreateAutomationPeer();
         const Windows::UI::Xaml::Thickness GetPadding();
 
-        IControlSettings Settings() const;
-        void Settings(IControlSettings newSettings);
-
         static Windows::Foundation::Size GetProposedDimensions(IControlSettings const& settings, const uint32_t dpi);
         static Windows::Foundation::Size GetProposedDimensions(IControlSettings const& settings, const uint32_t dpi, const winrt::Windows::Foundation::Size& initialSizeInChars);
 
@@ -105,6 +105,10 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         hstring ReadEntireBuffer() const;
 
+        winrt::Microsoft::Terminal::Core::Scheme ColorScheme() const noexcept;
+        void ColorScheme(const winrt::Microsoft::Terminal::Core::Scheme& scheme) const noexcept;
+        Windows::UI::Xaml::Media::Brush BackgroundBrush();
+
         // -------------------------------- WinRT Events ---------------------------------
         // clang-format off
         WINRT_CALLBACK(FontSizeChanged, Control::FontSizeChangedEventArgs);
@@ -127,8 +131,6 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         TYPED_EVENT(WarningBell,               IInspectable, IInspectable);
         // clang-format on
 
-        WINRT_PROPERTY(IControlAppearance, UnfocusedAppearance);
-
     private:
         friend struct TermControlT<TermControl>; // friend our parent so it can bind private event handlers
 
@@ -146,7 +148,6 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         winrt::com_ptr<SearchBoxControl> _searchBox;
 
-        IControlSettings _settings;
         bool _closing{ false };
         bool _focused{ false };
         bool _initializedTerminal{ false };
@@ -193,14 +194,16 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             return _closing;
         }
 
-        void _UpdateSettingsFromUIThread(IControlSettings newSettings);
-        void _UpdateAppearanceFromUIThread(IControlAppearance newAppearance);
-        void _ApplyUISettings(const IControlSettings&);
+        void _UpdateSettingsFromUIThread();
+        void _UpdateAppearanceFromUIThread(Control::IControlAppearance newAppearance);
+        void _ApplyUISettings();
+        winrt::fire_and_forget UpdateAppearance(Control::IControlAppearance newAppearance);
         void _SetBackgroundImage(const IControlAppearance& newAppearance);
 
         void _InitializeBackgroundBrush();
-        void _BackgroundColorChangedHandler(const IInspectable& sender, const IInspectable& args);
-        winrt::fire_and_forget _changeBackgroundColor(const til::color bg);
+        winrt::fire_and_forget _coreBackgroundColorChanged(const IInspectable& sender, const IInspectable& args);
+        void _changeBackgroundColor(const til::color bg);
+        void _changeBackgroundOpacity();
 
         bool _InitializeTerminal();
         void _SetFontSize(int fontSize);

src/cascadia/TerminalControl/TermControl.idl

@@ -17,14 +17,15 @@ namespace Microsoft.Terminal.Control
                                                    ICoreState
     {
         TermControl(IControlSettings settings,
+                    IControlAppearance unfocusedAppearance,
                     Microsoft.Terminal.TerminalConnection.ITerminalConnection connection);
 
         static Windows.Foundation.Size GetProposedDimensions(IControlSettings settings, UInt32 dpi);
 
-        void UpdateSettings();
+        void UpdateControlSettings(IControlSettings settings);
+        void UpdateControlSettings(IControlSettings settings, IControlAppearance unfocusedAppearance);
 
-        Microsoft.Terminal.Control.IControlSettings Settings;
-        Microsoft.Terminal.Control.IControlAppearance UnfocusedAppearance;
+        Microsoft.Terminal.Control.IControlSettings Settings { get; };
 
         event FontSizeChangedEventArgs FontSizeChanged;
         event Windows.Foundation.TypedEventHandler<Object, TitleChangedEventArgs> TitleChanged;
@@ -71,5 +72,7 @@ namespace Microsoft.Terminal.Control
         void ToggleReadOnly();
 
         String ReadEntireBuffer();
+
+        Windows.UI.Xaml.Media.Brush BackgroundBrush { get; };
     }
 }

src/cascadia/TerminalCore/ICoreAppearance.idl

@@ -50,6 +50,37 @@ namespace Microsoft.Terminal.Core
         UInt32 Value;
     };
 
+    struct Scheme
+    {
+        Microsoft.Terminal.Core.Color Foreground;
+        Microsoft.Terminal.Core.Color Background;
+
+        Microsoft.Terminal.Core.Color SelectionBackground;
+
+        Microsoft.Terminal.Core.Color CursorColor;
+
+        // Table: A WinRT struct doesn't allow pointers (READ: doesn't allow
+        // array members) in structs, but we very much would like this object to
+        // be a struct. So we'll call out each color individually. There's only
+        // 16, it's not that bad.
+        Microsoft.Terminal.Core.Color Black;
+        Microsoft.Terminal.Core.Color Red;
+        Microsoft.Terminal.Core.Color Green;
+        Microsoft.Terminal.Core.Color Yellow;
+        Microsoft.Terminal.Core.Color Blue;
+        Microsoft.Terminal.Core.Color Purple;
+        Microsoft.Terminal.Core.Color Cyan;
+        Microsoft.Terminal.Core.Color White;
+        Microsoft.Terminal.Core.Color BrightBlack;
+        Microsoft.Terminal.Core.Color BrightRed;
+        Microsoft.Terminal.Core.Color BrightGreen;
+        Microsoft.Terminal.Core.Color BrightYellow;
+        Microsoft.Terminal.Core.Color BrightBlue;
+        Microsoft.Terminal.Core.Color BrightPurple;
+        Microsoft.Terminal.Core.Color BrightCyan;
+        Microsoft.Terminal.Core.Color BrightWhite;
+    };
+
     declare
     {
         // Forward declare this parameterized specialization so that it lives

src/cascadia/TerminalCore/Terminal.cpp

@@ -178,13 +178,14 @@ void Terminal::UpdateSettings(ICoreSettings settings)
 // - appearance: an ICoreAppearance with new settings values for us to use.
 void Terminal::UpdateAppearance(const ICoreAppearance& appearance)
 {
+    _intenseIsBright = appearance.IntenseIsBright();
+    _adjustIndistinguishableColors = appearance.AdjustIndistinguishableColors();
+
     // Set the default background as transparent to prevent the
     // DX layer from overwriting the background image or acrylic effect
     til::color newBackgroundColor{ appearance.DefaultBackground() };
     _defaultBg = newBackgroundColor.with_alpha(0);
     _defaultFg = appearance.DefaultForeground();
-    _intenseIsBright = appearance.IntenseIsBright();
-    _adjustIndistinguishableColors = appearance.AdjustIndistinguishableColors();
 
     for (int i = 0; i < 16; i++)
     {
@@ -1298,3 +1299,67 @@ const size_t Microsoft::Terminal::Core::Terminal::GetTaskbarProgress() const noe
 {
     return _taskbarProgress;
 }
+
+Scheme Terminal::GetColorScheme() const noexcept
+{
+    Scheme s;
+
+    s.Foreground = til::color{ _defaultFg };
+    // Don't leak the implementation detail that our _defaultBg is stored
+    // internally without alpha.
+    s.Background = til::color{ _defaultBg.with_alpha(0xff) };
+
+    // SelectionBackground is stored in the ControlAppearance
+    s.CursorColor = til::color{ _buffer->GetCursor().GetColor() };
+
+    s.Black = til::color{ _colorTable[0] };
+    s.Red = til::color{ _colorTable[1] };
+    s.Green = til::color{ _colorTable[2] };
+    s.Yellow = til::color{ _colorTable[3] };
+    s.Blue = til::color{ _colorTable[4] };
+    s.Purple = til::color{ _colorTable[5] };
+    s.Cyan = til::color{ _colorTable[6] };
+    s.White = til::color{ _colorTable[7] };
+    s.BrightBlack = til::color{ _colorTable[8] };
+    s.BrightRed = til::color{ _colorTable[9] };
+    s.BrightGreen = til::color{ _colorTable[10] };
+    s.BrightYellow = til::color{ _colorTable[11] };
+    s.BrightBlue = til::color{ _colorTable[12] };
+    s.BrightPurple = til::color{ _colorTable[13] };
+    s.BrightCyan = til::color{ _colorTable[14] };
+    s.BrightWhite = til::color{ _colorTable[15] };
+    return s;
+}
+
+void Terminal::ApplyScheme(const Scheme& colorScheme)
+{
+    _defaultFg = colorScheme.Foreground;
+    // Set the default background as transparent to prevent the
+    // DX layer from overwriting the background image or acrylic effect
+    til::color newBackgroundColor{ colorScheme.Background };
+    _defaultBg = newBackgroundColor.with_alpha(0);
+
+    _colorTable[0] = til::color{ colorScheme.Black };
+    _colorTable[1] = til::color{ colorScheme.Red };
+    _colorTable[2] = til::color{ colorScheme.Green };
+    _colorTable[3] = til::color{ colorScheme.Yellow };
+    _colorTable[4] = til::color{ colorScheme.Blue };
+    _colorTable[5] = til::color{ colorScheme.Purple };
+    _colorTable[6] = til::color{ colorScheme.Cyan };
+    _colorTable[7] = til::color{ colorScheme.White };
+    _colorTable[8] = til::color{ colorScheme.BrightBlack };
+    _colorTable[9] = til::color{ colorScheme.BrightRed };
+    _colorTable[10] = til::color{ colorScheme.BrightGreen };
+    _colorTable[11] = til::color{ colorScheme.BrightYellow };
+    _colorTable[12] = til::color{ colorScheme.BrightBlue };
+    _colorTable[13] = til::color{ colorScheme.BrightPurple };
+    _colorTable[14] = til::color{ colorScheme.BrightCyan };
+    _colorTable[15] = til::color{ colorScheme.BrightWhite };
+
+    _buffer->GetCursor().SetColor(til::color{ colorScheme.CursorColor });
+
+    if (_adjustIndistinguishableColors)
+    {
+        _MakeAdjustedColorArray();
+    }
+}

src/cascadia/TerminalCore/Terminal.hpp

@@ -30,6 +30,7 @@ namespace winrt::Microsoft::Terminal::Core
 {
     struct ICoreSettings;
     struct ICoreAppearance;
+    struct Scheme;
 }
 
 namespace Microsoft::Terminal::Core
@@ -214,6 +215,9 @@ public:
     const std::optional<til::color> GetTabColor() const noexcept;
     til::color GetDefaultBackground() const noexcept;
 
+    winrt::Microsoft::Terminal::Core::Scheme GetColorScheme() const noexcept;
+    void ApplyScheme(const winrt::Microsoft::Terminal::Core::Scheme& scheme);
+
     Microsoft::Console::Render::BlinkingState& GetBlinkingState() const noexcept;
 
     const size_t GetTaskbarState() const noexcept;

src/cascadia/TerminalSettingsEditor/Profiles.cpp

@@ -398,7 +398,7 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation
     }
 
     Profiles::Profiles() :
-        _previewControl{ Control::TermControl(Model::TerminalSettings{}, make<PreviewConnection>()) }
+        _previewControl{ Control::TermControl(Model::TerminalSettings{}, nullptr, make<PreviewConnection>()) }
     {
         InitializeComponent();
 
@@ -453,26 +453,23 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation
             {
                 _PropertyChangedHandlers(*this, PropertyChangedEventArgs{ L"CurrentScrollState" });
             }
-            _previewControl.Settings(_State.Profile().TermSettings());
-            _previewControl.UpdateSettings();
+            _previewControl.UpdateControlSettings(_State.Profile().TermSettings());
         });
 
         // The Appearances object handles updating the values in the settings UI, but
         // we still need to listen to the changes here just to update the preview control
         _AppearanceViewModelChangedRevoker = _State.Profile().DefaultAppearance().PropertyChanged(winrt::auto_revoke, [=](auto&&, const PropertyChangedEventArgs& /*args*/) {
-            _previewControl.Settings(_State.Profile().TermSettings());
-            _previewControl.UpdateSettings();
+            _previewControl.UpdateControlSettings(_State.Profile().TermSettings());
         });
 
         // Navigate to the pivot in the provided navigation state
         ProfilesPivot().SelectedIndex(static_cast<int>(_State.LastActivePivot()));
 
-        _previewControl.Settings(_State.Profile().TermSettings());
         // There is a possibility that the control has not fully initialized yet,
         // so wait for it to initialize before updating the settings (so we know
         // that the renderer is set up)
         _previewControl.Initialized([&](auto&& /*s*/, auto&& /*e*/) {
-            _previewControl.UpdateSettings();
+            _previewControl.UpdateControlSettings(_State.Profile().TermSettings());
         });
     }
 

src/cascadia/TerminalSettingsModel/ColorScheme.cpp

@@ -147,3 +147,30 @@ void ColorScheme::SetColorTableEntry(uint8_t index, const Core::Color& value) no
     THROW_HR_IF(E_INVALIDARG, index >= _table.size());
     _table[index] = value;
 }
+
+winrt::Microsoft::Terminal::Core::Scheme ColorScheme::ToCoreScheme() const noexcept
+{
+    winrt::Microsoft::Terminal::Core::Scheme coreScheme{};
+
+    coreScheme.Foreground = Foreground();
+    coreScheme.Background = Background();
+    coreScheme.CursorColor = CursorColor();
+    coreScheme.SelectionBackground = SelectionBackground();
+    coreScheme.Black = Table()[0];
+    coreScheme.Red = Table()[1];
+    coreScheme.Green = Table()[2];
+    coreScheme.Yellow = Table()[3];
+    coreScheme.Blue = Table()[4];
+    coreScheme.Purple = Table()[5];
+    coreScheme.Cyan = Table()[6];
+    coreScheme.White = Table()[7];
+    coreScheme.BrightBlack = Table()[8];
+    coreScheme.BrightRed = Table()[9];
+    coreScheme.BrightGreen = Table()[10];
+    coreScheme.BrightYellow = Table()[11];
+    coreScheme.BrightBlue = Table()[12];
+    coreScheme.BrightPurple = Table()[13];
+    coreScheme.BrightCyan = Table()[14];
+    coreScheme.BrightWhite = Table()[15];
+    return coreScheme;
+}

src/cascadia/TerminalSettingsModel/ColorScheme.h

@@ -47,6 +47,8 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
         static com_ptr<ColorScheme> FromJson(const Json::Value& json);
         Json::Value ToJson() const;
 
+        winrt::Microsoft::Terminal::Core::Scheme ToCoreScheme() const noexcept;
+
         com_array<Core::Color> Table() const noexcept;
         void SetColorTableEntry(uint8_t index, const Core::Color& value) noexcept;
 

src/cascadia/TerminalSettingsModel/ColorScheme.idl

@@ -19,5 +19,7 @@ namespace Microsoft.Terminal.Settings.Model
         // we expose the getter as a function.
         Microsoft.Terminal.Core.Color[] Table();
         void SetColorTableEntry(UInt8 index, Microsoft.Terminal.Core.Color value);
+
+        Microsoft.Terminal.Core.Scheme ToCoreScheme();
     }
 }

src/cascadia/TerminalSettingsModel/TerminalSettings.cpp

@@ -206,59 +206,6 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
         _Opacity = appearance.Opacity();
     }
 
-    // Method Description:
-    // - Creates a TerminalSettingsCreateResult from a parent TerminalSettingsCreateResult
-    // - The returned defaultSettings inherits from the parent's defaultSettings, and the
-    //   returned unfocusedSettings inherits from the returned defaultSettings
-    // - Note that the unfocused settings needs to be entirely unchanged _except_ we need to
-    //   set its parent to the other settings object that we return. This is because the overrides
-    //   made by the control will live in that other settings object, so we want to make
-    //   sure the unfocused settings inherit from that.
-    // - Another way to think about this is that initially we have UnfocusedSettings inherit
-    //   from DefaultSettings. This function simply adds another TerminalSettings object
-    //   in the middle of these two, so UnfocusedSettings now inherits from the new object
-    //   and the new object inherits from the DefaultSettings. And this new object is what
-    //   the control can put overrides in.
-    // Arguments:
-    // - parent: the TerminalSettingsCreateResult that we create a new one from
-    // Return Value:
-    // - A TerminalSettingsCreateResult object that contains a defaultSettings that inherits
-    //   from parent's defaultSettings, and contains an unfocusedSettings that inherits from
-    //   its defaultSettings
-    Model::TerminalSettingsCreateResult TerminalSettings::CreateWithParent(const Model::TerminalSettingsCreateResult& parent)
-    {
-        THROW_HR_IF_NULL(E_INVALIDARG, parent);
-
-        auto defaultImpl{ get_self<TerminalSettings>(parent.DefaultSettings()) };
-        auto defaultChild = defaultImpl->CreateChild();
-        if (parent.UnfocusedSettings())
-        {
-            parent.UnfocusedSettings().SetParent(*defaultChild);
-        }
-        return winrt::make<TerminalSettingsCreateResult>(*defaultChild, parent.UnfocusedSettings());
-    }
-
-    // Method Description:
-    // - Sets our parent to the provided TerminalSettings
-    // Arguments:
-    // - parent: our new parent
-    void TerminalSettings::SetParent(const Model::TerminalSettings& parent)
-    {
-        ClearParents();
-        com_ptr<TerminalSettings> parentImpl;
-        parentImpl.copy_from(get_self<TerminalSettings>(parent));
-        InsertParent(parentImpl);
-    }
-
-    Model::TerminalSettings TerminalSettings::GetParent()
-    {
-        if (_parents.size() > 0)
-        {
-            return *_parents.at(0);
-        }
-        return nullptr;
-    }
-
     // Method Description:
     // - Apply Profile settings, as well as any colors from our color scheme, if we have one.
     // Arguments:

src/cascadia/TerminalSettingsModel/TerminalSettings.h

@@ -64,12 +64,6 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
                                                                              const Model::NewTerminalArgs& newTerminalArgs,
                                                                              const Control::IKeyBindings& keybindings);
 
-        static Model::TerminalSettingsCreateResult CreateWithParent(const Model::TerminalSettingsCreateResult& parent);
-
-        Model::TerminalSettings GetParent();
-
-        void SetParent(const Model::TerminalSettings& parent);
-
         void ApplyColorScheme(const Model::ColorScheme& scheme);
 
         // --------------------------- Core Settings ---------------------------
@@ -95,7 +89,6 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
         INHERITABLE_SETTING(Model::TerminalSettings, uint32_t, CursorHeight, DEFAULT_CURSOR_HEIGHT);
         INHERITABLE_SETTING(Model::TerminalSettings, hstring, WordDelimiters, DEFAULT_WORD_DELIMITERS);
         INHERITABLE_SETTING(Model::TerminalSettings, bool, CopyOnSelect, false);
-        INHERITABLE_SETTING(Model::TerminalSettings, bool, InputServiceWarning, true);
         INHERITABLE_SETTING(Model::TerminalSettings, bool, FocusFollowMouse, false);
         INHERITABLE_SETTING(Model::TerminalSettings, bool, TrimBlockSelection, false);
         INHERITABLE_SETTING(Model::TerminalSettings, bool, DetectURLs, true);

src/cascadia/TerminalSettingsModel/TerminalSettings.idl

@@ -28,12 +28,16 @@ namespace Microsoft.Terminal.Settings.Model
 
         static TerminalSettingsCreateResult CreateWithProfile(CascadiaSettings appSettings, Profile profile, Microsoft.Terminal.Control.IKeyBindings keybindings);
         static TerminalSettingsCreateResult CreateWithNewTerminalArgs(CascadiaSettings appSettings, NewTerminalArgs newTerminalArgs, Microsoft.Terminal.Control.IKeyBindings keybindings);
-        static TerminalSettingsCreateResult CreateWithParent(TerminalSettingsCreateResult parent);
 
-        void SetParent(TerminalSettings parent);
-        TerminalSettings GetParent();
         void ApplyColorScheme(ColorScheme scheme);
 
         ColorScheme AppliedColorScheme;
+
+        // The getters for these are already defined in IControlSettings. So
+        // we're just adding the setters here, because TerminalApp likes to be
+        // able to change these at runtime (e.g. when duplicating a pane).
+        String Commandline { set; };
+        String StartingDirectory { set; };
+        String EnvironmentVariables { set; };
     };
 }

src/cascadia/UnitTests_Control/ControlCoreTests.cpp

@@ -67,7 +67,7 @@ namespace ControlUnitTests
         {
             Log::Comment(L"Create ControlCore object");
 
-            auto core = winrt::make_self<Control::implementation::ControlCore>(settings, conn);
+            auto core = winrt::make_self<Control::implementation::ControlCore>(settings, settings, conn);
             core->_inUnitTests = true;
             return core;
         }
@@ -128,13 +128,14 @@ namespace ControlUnitTests
         double expectedOpacity = 0.5;
         auto opacityCallback = [&](auto&&, Control::TransparencyChangedEventArgs args) mutable {
             VERIFY_ARE_EQUAL(expectedOpacity, args.Opacity());
-            VERIFY_ARE_EQUAL(expectedOpacity, settings->Opacity());
-            VERIFY_ARE_EQUAL(expectedOpacity, core->_settings.Opacity());
+            VERIFY_ARE_EQUAL(expectedOpacity, core->Opacity());
+            // The Settings object's opacity shouldn't be changed
+            VERIFY_ARE_EQUAL(0.5, settings->Opacity());
 
             if (expectedOpacity < 1.0)
             {
                 VERIFY_IS_TRUE(settings->UseAcrylic());
-                VERIFY_IS_TRUE(core->_settings.UseAcrylic());
+                VERIFY_IS_TRUE(core->_settings->UseAcrylic());
             }
 
             // GH#603: Adjusting opacity shouldn't change whether or not we
@@ -142,8 +143,8 @@ namespace ControlUnitTests
 
             auto expectedUseAcrylic = winrt::Microsoft::Terminal::Control::implementation::ControlCore::IsVintageOpacityAvailable() ? true :
                                                                                                                                       (expectedOpacity < 1.0 ? true : false);
-            VERIFY_ARE_EQUAL(expectedUseAcrylic, settings->UseAcrylic());
-            VERIFY_ARE_EQUAL(expectedUseAcrylic, core->_settings.UseAcrylic());
+            VERIFY_ARE_EQUAL(expectedUseAcrylic, core->UseAcrylic());
+            VERIFY_ARE_EQUAL(true, core->_settings->UseAcrylic());
         };
         core->TransparencyChanged(opacityCallback);
 

src/cascadia/UnitTests_Control/ControlInteractivityTests.cpp

@@ -71,7 +71,7 @@ namespace ControlUnitTests
                                     TerminalConnection::ITerminalConnection conn)
         {
             Log::Comment(L"Create ControlInteractivity object");
-            auto interactivity = winrt::make_self<Control::implementation::ControlInteractivity>(settings, conn);
+            auto interactivity = winrt::make_self<Control::implementation::ControlInteractivity>(settings, settings, conn);
             VERIFY_IS_NOT_NULL(interactivity);
             auto core = interactivity->_core;
             core->_inUnitTests = true;
@@ -116,13 +116,14 @@ namespace ControlUnitTests
         double expectedOpacity = 0.5;
         auto opacityCallback = [&](auto&&, Control::TransparencyChangedEventArgs args) mutable {
             VERIFY_ARE_EQUAL(expectedOpacity, args.Opacity());
-            VERIFY_ARE_EQUAL(expectedOpacity, settings->Opacity());
-            VERIFY_ARE_EQUAL(expectedOpacity, core->_settings.Opacity());
+            VERIFY_ARE_EQUAL(expectedOpacity, core->Opacity());
+            // The Settings object's opacity shouldn't be changed
+            VERIFY_ARE_EQUAL(0.5, settings->Opacity());
 
             auto expectedUseAcrylic = winrt::Microsoft::Terminal::Control::implementation::ControlCore::IsVintageOpacityAvailable() ? useAcrylic :
                                                                                                                                       (expectedOpacity < 1.0 ? true : false);
-            VERIFY_ARE_EQUAL(expectedUseAcrylic, settings->UseAcrylic());
-            VERIFY_ARE_EQUAL(expectedUseAcrylic, core->_settings.UseAcrylic());
+            VERIFY_ARE_EQUAL(useAcrylic, settings->UseAcrylic());
+            VERIFY_ARE_EQUAL(expectedUseAcrylic, core->UseAcrylic());
         };
         core->TransparencyChanged(opacityCallback);
 

src/cascadia/UnitTests_Control/MockControlSettings.h

@@ -35,7 +35,6 @@ namespace ControlUnitTests
         WINRT_PROPERTY(uint32_t, CursorHeight, DEFAULT_CURSOR_HEIGHT);
         WINRT_PROPERTY(winrt::hstring, WordDelimiters, DEFAULT_WORD_DELIMITERS);
         WINRT_PROPERTY(bool, CopyOnSelect, false);
-        WINRT_PROPERTY(bool, InputServiceWarning, true);
         WINRT_PROPERTY(bool, FocusFollowMouse, false);
 
         WINRT_PROPERTY(winrt::Windows::Foundation::IReference<winrt::Microsoft::Terminal::Core::Color>, TabColor, nullptr);

src/cascadia/WindowsTerminal/NonClientIslandWindow.cpp

@@ -87,51 +87,203 @@ void NonClientIslandWindow::MakeWindow() noexcept
     THROW_HR_IF_NULL(E_UNEXPECTED, _dragBarWindow);
 }
 
-// Function Description:
-// - The window procedure for the drag bar forwards clicks on its client area to its parent as non-client clicks.
-LRESULT NonClientIslandWindow::_InputSinkMessageHandler(UINT const message, WPARAM const wparam, LPARAM const lparam) noexcept
+LRESULT NonClientIslandWindow::_dragBarNcHitTest(const til::point& pointer)
 {
-    std::optional<UINT> nonClientMessage{ std::nullopt };
+    RECT rcParent = GetWindowRect();
+    // The size of the buttons doesn't change over the life of the application.
+    const auto buttonWidthInDips{ _titlebar.CaptionButtonWidth() };
 
-    // translate WM_ messages on the window to WM_NC* on the top level window
+    // However, the DPI scaling might, so get the updated size of the buttons in pixels
+    const auto buttonWidthInPixels{ buttonWidthInDips * GetCurrentDpiScale() };
+
+    // make sure to account for the width of the window frame!
+    const til::rectangle nonClientFrame{ GetNonClientFrame(_currentDpi) };
+    const auto rightBorder{ rcParent.right - nonClientFrame.right<int>() };
+    // From the right to the left,
+    // * are we in the close button?
+    // * the maximize button?
+    // * the minimize button?
+    // If we're not, then we're in either the top resize border, or just
+    // generally in the titlebar.
+    if ((rightBorder - pointer.x()) < (buttonWidthInPixels))
+    {
+        return HTCLOSE;
+    }
+    else if ((rightBorder - pointer.x()) < (buttonWidthInPixels * 2))
+    {
+        return HTMAXBUTTON;
+    }
+    else if ((rightBorder - pointer.x()) < (buttonWidthInPixels * 3))
+    {
+        return HTMINBUTTON;
+    }
+    else
+    {
+        // If we're not on a caption button, then check if we're on the top
+        // border. If we're not on the top border, then we're just generally in
+        // the caption area.
+        const auto resizeBorderHeight = _GetResizeHandleHeight();
+        const auto isOnResizeBorder = pointer.y() < rcParent.top + resizeBorderHeight;
+
+        return isOnResizeBorder ? HTTOP : HTCAPTION;
+    }
+}
+
+// Function Description:
+// - The window procedure for the drag bar forwards clicks on its client area to
+//   its parent as non-client clicks.
+// - BODGY: It also _manually_ handles the caption buttons. They exist in the
+//   titlebar, and work reasonably well with just XAML, if the drag bar isn't
+//   covering them.
+// - However, to get snap layout support (GH#9443), we need to actually return
+//   HTMAXBUTTON where the maximize button is. If the drag bar doesn't cover the
+//   caption buttons, then the core input site (which takes up the entirety of
+//   the XAML island) will steal the WM_NCHITTEST before we get a chance to
+//   handle it.
+// - So, the drag bar covers the caption buttons, and manually handles hovering
+//   and pressing them when needed. This gives the impression that they're
+//   getting input as they normally would, even if they're not _really_ getting
+//   input via XAML.
+LRESULT NonClientIslandWindow::_InputSinkMessageHandler(UINT const message,
+                                                        WPARAM const wparam,
+                                                        LPARAM const lparam) noexcept
+{
     switch (message)
     {
-    case WM_LBUTTONDOWN:
-        nonClientMessage = WM_NCLBUTTONDOWN;
-        break;
-    case WM_LBUTTONDBLCLK:
-        nonClientMessage = WM_NCLBUTTONDBLCLK;
-        break;
-    case WM_LBUTTONUP:
-        nonClientMessage = WM_NCLBUTTONUP;
-        break;
-    case WM_RBUTTONDOWN:
-        nonClientMessage = WM_NCRBUTTONDOWN;
-        break;
-    case WM_RBUTTONDBLCLK:
-        nonClientMessage = WM_NCRBUTTONDBLCLK;
-        break;
-    case WM_RBUTTONUP:
-        nonClientMessage = WM_NCRBUTTONUP;
-        break;
-    }
-
-    if (nonClientMessage.has_value())
+    case WM_NCHITTEST:
     {
-        const POINT clientPt{ GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam) };
-        POINT screenPt{ clientPt };
-        if (ClientToScreen(_dragBarWindow.get(), &screenPt))
+        // Try to determine what part of the window is being hovered here. This
+        // is absolutely critical to making sure Snap Layouts (GH#9443) works!
+        return _dragBarNcHitTest(til::point{ GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam) });
+    }
+    break;
+
+    case WM_NCMOUSEMOVE:
+        // When we get this message, it's because the mouse moved when it was
+        // over somewhere we said was the non-client area.
+        //
+        // We'll use this to communicate state to the title bar control, so that
+        // it can update its visuals.
+        // - If we're over a button, hover it.
+        // - If we're over _anything else_, stop hovering the buttons.
+        switch (wparam)
         {
+        case HTTOP:
+        case HTCAPTION:
+        {
+            _titlebar.ReleaseButtons();
+
+            // Pass caption-related nonclient messages to the parent window.
+            // Make sure to do this for the HTTOP, which is the top resize
+            // border, so we can resize the window on the top.
             auto parentWindow{ GetHandle() };
-
-            const LPARAM newLparam = MAKELPARAM(screenPt.x, screenPt.y);
-            // Hit test the parent window at the screen coordinates the user clicked in the drag input sink window,
-            // then pass that click through as an NC click in that location.
-            const LRESULT hitTest{ SendMessage(parentWindow, WM_NCHITTEST, 0, newLparam) };
-            SendMessage(parentWindow, nonClientMessage.value(), hitTest, newLparam);
-
-            return 0;
+            return SendMessage(parentWindow, message, wparam, lparam);
         }
+        case HTMINBUTTON:
+        case HTMAXBUTTON:
+        case HTCLOSE:
+            _titlebar.HoverButton(static_cast<winrt::TerminalApp::CaptionButton>(wparam));
+            break;
+        default:
+            _titlebar.ReleaseButtons();
+        }
+
+        // If we haven't previously asked for mouse tracking, request mouse
+        // tracking. We need to do this so we can get the WM_NCMOUSELEAVE
+        // message when the mouse leave the titlebar. Otherwise, we won't always
+        // get that message (especially if the user moves the mouse _real
+        // fast_).
+        if (!_trackingMouse &&
+            (wparam == HTMINBUTTON || wparam == HTMAXBUTTON || wparam == HTCLOSE))
+        {
+            TRACKMOUSEEVENT ev{};
+            ev.cbSize = sizeof(TRACKMOUSEEVENT);
+            // TME_NONCLIENT is absolutely critical here. In my experimentation,
+            // we'd get WM_MOUSELEAVE messages after just a HOVER_DEFAULT
+            // timeout even though we're not requesting TME_HOVER, which kinda
+            // ruined the whole point of this.
+            ev.dwFlags = TME_LEAVE | TME_NONCLIENT;
+            ev.hwndTrack = _dragBarWindow.get();
+            ev.dwHoverTime = HOVER_DEFAULT; // we don't _really_ care about this.
+            LOG_IF_WIN32_BOOL_FALSE(TrackMouseEvent(&ev));
+            _trackingMouse = true;
+        }
+        break;
+
+    case WM_NCMOUSELEAVE:
+    case WM_MOUSELEAVE:
+        // When the mouse leaves the drag rect, make sure to dismiss any hover.
+        _titlebar.ReleaseButtons();
+        _trackingMouse = false;
+        break;
+
+    // NB: *Shouldn't be forwarding these* when they're not over the caption
+    // because they can inadvertently take action using the system's default
+    // metrics instead of our own.
+    case WM_NCLBUTTONDOWN:
+    case WM_NCLBUTTONDBLCLK:
+        // Manual handling for mouse clicks in the drag bar. If it's in a
+        // caption button, then tell the titlebar to "press" the button, which
+        // should change its visual state.
+        //
+        // If it's not in a caption button, then just forward the message along
+        // to the root HWND. Make sure to do this for the HTTOP, which is the
+        // top resize border.
+        switch (wparam)
+        {
+        case HTTOP:
+        case HTCAPTION:
+        {
+            // Pass caption-related nonclient messages to the parent window.
+            auto parentWindow{ GetHandle() };
+            return SendMessage(parentWindow, message, wparam, lparam);
+        }
+        // The buttons won't work as you'd expect; we need to handle those
+        // ourselves.
+        case HTMINBUTTON:
+        case HTMAXBUTTON:
+        case HTCLOSE:
+            _titlebar.PressButton(static_cast<winrt::TerminalApp::CaptionButton>(wparam));
+            break;
+        }
+        return 0;
+
+    case WM_NCLBUTTONUP:
+        // Manual handling for mouse RELEASES in the drag bar. If it's in a
+        // caption button, then manually handle what we'd expect for that button.
+        //
+        // If it's not in a caption button, then just forward the message along
+        // to the root HWND.
+        switch (wparam)
+        {
+        case HTTOP:
+        case HTCAPTION:
+        {
+            // Pass caption-related nonclient messages to the parent window.
+            // The buttons won't work as you'd expect; we need to handle those ourselves.
+            auto parentWindow{ GetHandle() };
+            return SendMessage(parentWindow, message, wparam, lparam);
+        }
+        break;
+
+        // If we do find a button, then tell the titlebar to raise the same
+        // event that would be raised if it were "tapped"
+        case HTMINBUTTON:
+        case HTMAXBUTTON:
+        case HTCLOSE:
+            _titlebar.ReleaseButtons();
+            _titlebar.ClickButton(static_cast<winrt::TerminalApp::CaptionButton>(wparam));
+            break;
+        }
+        return 0;
+
+    // Make sure to pass along right-clicks in this region to our parent window
+    // - we don't need to handle these.
+    case WM_NCRBUTTONDOWN:
+    case WM_NCRBUTTONDBLCLK:
+    case WM_NCRBUTTONUP:
+        auto parentWindow{ GetHandle() };
+        return SendMessage(parentWindow, message, wparam, lparam);
     }
 
     return DefWindowProc(_dragBarWindow.get(), message, wparam, lparam);
@@ -279,10 +431,17 @@ RECT NonClientIslandWindow::_GetDragAreaRect() const noexcept
     {
         const auto scale = GetCurrentDpiScale();
         const auto transform = _dragBar.TransformToVisual(_rootGrid);
+
+        // GH#9443: Previously, we'd only extend the drag bar from the left of
+        // the tabs to the right of the caption buttons. Now, we're extending it
+        // all the way to the right side of the window, covering the caption
+        // buttons. We'll manually handle input to those buttons, to make it
+        // seem like they're still getting XAML input. We do this so we can get
+        // snap layout support for the maximize button.
         const auto logicalDragBarRect = winrt::Windows::Foundation::Rect{
             0.0f,
             0.0f,
-            static_cast<float>(_dragBar.ActualWidth()),
+            static_cast<float>(_rootGrid.ActualWidth()),
             static_cast<float>(_dragBar.ActualHeight())
         };
         const auto clientDragBarRect = transform.TransformBounds(logicalDragBarRect);
@@ -550,6 +709,7 @@ int NonClientIslandWindow::_GetResizeHandleHeight() const noexcept
     // we didn't change them.
     LPARAM lParam = MAKELONG(ptMouse.x, ptMouse.y);
     const auto originalRet = DefWindowProc(_window.get(), WM_NCHITTEST, 0, lParam);
+
     if (originalRet != HTCLIENT)
     {
         // If we're the quake window, suppress resizing on any side except the

src/cascadia/WindowsTerminal/NonClientIslandWindow.h

@@ -62,6 +62,7 @@ private:
     winrt::Windows::UI::Xaml::ElementTheme _theme;
 
     bool _isMaximized;
+    bool _trackingMouse{ false };
 
     [[nodiscard]] static LRESULT __stdcall _StaticInputSinkWndProc(HWND const window, UINT const message, WPARAM const wparam, LPARAM const lparam) noexcept;
     [[nodiscard]] LRESULT _InputSinkMessageHandler(UINT const message, WPARAM const wparam, LPARAM const lparam) noexcept;
@@ -71,6 +72,7 @@ private:
     int _GetResizeHandleHeight() const noexcept;
     RECT _GetDragAreaRect() const noexcept;
     int _GetTopBorderHeight() const noexcept;
+    LRESULT _dragBarNcHitTest(const til::point& pointer);
 
     [[nodiscard]] LRESULT _OnNcCreate(WPARAM wParam, LPARAM lParam) noexcept override;
     [[nodiscard]] LRESULT _OnNcCalcSize(const WPARAM wParam, const LPARAM lParam) noexcept;

src/cascadia/inc/ControlProperties.h

@@ -0,0 +1,70 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#pragma once
+
+// --------------------------- Core Appearance ---------------------------
+//  All of these settings are defined in ICoreAppearance.
+#define CORE_APPEARANCE_SETTINGS(X)                                                                                       \
+    X(til::color, DefaultForeground, DEFAULT_FOREGROUND)                                                                  \
+    X(til::color, DefaultBackground, DEFAULT_BACKGROUND)                                                                  \
+    X(til::color, CursorColor, DEFAULT_CURSOR_COLOR)                                                                      \
+    X(winrt::Microsoft::Terminal::Core::CursorStyle, CursorShape, winrt::Microsoft::Terminal::Core::CursorStyle::Vintage) \
+    X(uint32_t, CursorHeight, DEFAULT_CURSOR_HEIGHT)                                                                      \
+    X(bool, IntenseIsBright, true)                                                                                        \
+    X(bool, AdjustIndistinguishableColors, true)
+
+// --------------------------- Control Appearance ---------------------------
+//  All of these settings are defined in IControlSettings.
+#define CONTROL_APPEARANCE_SETTINGS(X)                                                                                                          \
+    X(til::color, SelectionBackground, DEFAULT_FOREGROUND)                                                                                      \
+    X(double, Opacity, 1.0)                                                                                                                     \
+    X(winrt::hstring, BackgroundImage)                                                                                                          \
+    X(double, BackgroundImageOpacity, 1.0)                                                                                                      \
+    X(winrt::Windows::UI::Xaml::Media::Stretch, BackgroundImageStretchMode, winrt::Windows::UI::Xaml::Media::Stretch::UniformToFill)            \
+    X(winrt::Windows::UI::Xaml::HorizontalAlignment, BackgroundImageHorizontalAlignment, winrt::Windows::UI::Xaml::HorizontalAlignment::Center) \
+    X(winrt::Windows::UI::Xaml::VerticalAlignment, BackgroundImageVerticalAlignment, winrt::Windows::UI::Xaml::VerticalAlignment::Center)       \
+    X(bool, IntenseIsBold)                                                                                                                      \
+    X(bool, RetroTerminalEffect, false)                                                                                                         \
+    X(winrt::hstring, PixelShaderPath)
+
+// --------------------------- Core Settings ---------------------------
+//  All of these settings are defined in ICoreSettings.
+#define CORE_SETTINGS(X)                                                                                          \
+    X(int32_t, HistorySize, DEFAULT_HISTORY_SIZE)                                                                 \
+    X(int32_t, InitialRows, 30)                                                                                   \
+    X(int32_t, InitialCols, 80)                                                                                   \
+    X(bool, SnapOnInput, true)                                                                                    \
+    X(bool, AltGrAliasing, true)                                                                                  \
+    X(winrt::hstring, WordDelimiters, DEFAULT_WORD_DELIMITERS)                                                    \
+    X(bool, CopyOnSelect, false)                                                                                  \
+    X(bool, FocusFollowMouse, false)                                                                              \
+    X(winrt::Windows::Foundation::IReference<winrt::Microsoft::Terminal::Core::Color>, TabColor, nullptr)         \
+    X(winrt::Windows::Foundation::IReference<winrt::Microsoft::Terminal::Core::Color>, StartingTabColor, nullptr) \
+    X(bool, TrimBlockSelection, false)                                                                            \
+    X(bool, DetectURLs, true)
+
+// --------------------------- Control Settings ---------------------------
+//  All of these settings are defined in IControlSettings.
+#define CONTROL_SETTINGS(X)                                                                                                                              \
+    X(winrt::hstring, ProfileName)                                                                                                                       \
+    X(winrt::hstring, ProfileSource)                                                                                                                     \
+    X(bool, UseAcrylic, false)                                                                                                                           \
+    X(winrt::hstring, Padding, DEFAULT_PADDING)                                                                                                          \
+    X(winrt::hstring, FontFace, L"Consolas")                                                                                                             \
+    X(int32_t, FontSize, DEFAULT_FONT_SIZE)                                                                                                              \
+    X(winrt::Windows::UI::Text::FontWeight, FontWeight)                                                                                                  \
+    X(IFontFeatureMap, FontFeatures)                                                                                                                     \
+    X(IFontAxesMap, FontAxes)                                                                                                                            \
+    X(winrt::Microsoft::Terminal::Control::IKeyBindings, KeyBindings, nullptr)                                                                           \
+    X(winrt::hstring, Commandline)                                                                                                                       \
+    X(winrt::hstring, StartingDirectory)                                                                                                                 \
+    X(winrt::hstring, StartingTitle)                                                                                                                     \
+    X(bool, SuppressApplicationTitle)                                                                                                                    \
+    X(winrt::hstring, EnvironmentVariables)                                                                                                              \
+    X(winrt::Microsoft::Terminal::Control::ScrollbarState, ScrollState, winrt::Microsoft::Terminal::Control::ScrollbarState::Visible)                    \
+    X(winrt::Microsoft::Terminal::Control::TextAntialiasingMode, AntialiasingMode, winrt::Microsoft::Terminal::Control::TextAntialiasingMode::Grayscale) \
+    X(bool, ForceFullRepaintRendering, false)                                                                                                            \
+    X(bool, SoftwareRendering, false)                                                                                                                    \
+    X(bool, ForceVTInput, false)                                                                                                                         \
+    X(bool, UseAtlasEngine, false)

src/renderer/atlas/AtlasEngine.api.cpp

@@ -324,9 +324,9 @@ void AtlasEngine::SetCallback(std::function<void()> pfn) noexcept
     _api.swapChainChangedCallback = std::move(pfn);
 }
 
-void AtlasEngine::SetDefaultTextBackgroundOpacity(const float opacity) noexcept
+void AtlasEngine::EnableTransparentBackground(const bool isTransparent) noexcept
 {
-    const auto mixin = opacity == 1.0f ? 0xff000000 : 0x00000000;
+    const auto mixin = !isTransparent ? 0xff000000 : 0x00000000;
     if (_api.backgroundOpaqueMixin != mixin)
     {
         _api.backgroundOpaqueMixin = mixin;

src/renderer/atlas/AtlasEngine.h

@@ -64,7 +64,7 @@ namespace Microsoft::Console::Render
         // DxRenderer - setter
         void SetAntialiasingMode(D2D1_TEXT_ANTIALIAS_MODE antialiasingMode) noexcept override;
         void SetCallback(std::function<void()> pfn) noexcept override;
-        void SetDefaultTextBackgroundOpacity(float opacity) noexcept override;
+        void EnableTransparentBackground(const bool isTransparent) noexcept override;
         void SetForceFullRepaintRendering(bool enable) noexcept override;
         [[nodiscard]] HRESULT SetHwnd(HWND hwnd) noexcept override;
         void SetPixelShaderPath(std::wstring_view value) noexcept override;

src/renderer/dx/DxRenderer.cpp

@@ -88,7 +88,7 @@ DxEngine::DxEngine() :
     _forceFullRepaintRendering{ false },
     _softwareRendering{ false },
     _antialiasingMode{ D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE },
-    _defaultTextBackgroundOpacity{ 1.0f },
+    _defaultBackgroundIsTransparent{ true },
     _hwndTarget{ static_cast<HWND>(INVALID_HANDLE_VALUE) },
     _sizeTarget{},
     _dpi{ USER_DEFAULT_SCREEN_DPI },
@@ -911,7 +911,7 @@ void DxEngine::_ReleaseDeviceResources() noexcept
     // someone has chosen the slower ClearType antialiasing (versus the faster
     // grayscale antialiasing)
     const bool usingCleartype = _antialiasingMode == D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE;
-    const bool usingTransparency = _defaultTextBackgroundOpacity != 1.0f;
+    const bool usingTransparency = _defaultBackgroundIsTransparent;
     // Another way of naming "bgIsDefault" is "bgHasTransparency"
     const auto bgIsDefault = (_backgroundColor.a == _defaultBackgroundColor.a) &&
                              (_backgroundColor.r == _defaultBackgroundColor.r) &&
@@ -1927,20 +1927,16 @@ CATCH_RETURN()
                                                      const bool /*usingSoftFont*/,
                                                      const bool isSettingDefaultBrushes) noexcept
 {
-    // GH#5098: If we're rendering with cleartype text, we need to always render
-    // onto an opaque background. If our background's opacity is 1.0f, that's
-    // great, we can actually use cleartype in that case. In that scenario
-    // (cleartype && opacity == 1.0), we'll force the opacity bits of the
-    // COLORREF to 0xff so we draw as cleartype. In any other case, leave the
-    // opacity bits unchanged. PaintBufferLine will later do some logic to
-    // determine if we should paint the text as grayscale or not.
-    const bool usingCleartype = _antialiasingMode == D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE;
-    const bool usingTransparency = _defaultTextBackgroundOpacity != 1.0f;
-    const bool forceOpaqueBG = usingCleartype && !usingTransparency;
-
     const auto [colorForeground, colorBackground] = pData->GetAttributeColors(textAttributes);
 
+    const bool usingCleartype = _antialiasingMode == D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE;
+    const bool usingTransparency = _defaultBackgroundIsTransparent;
+    const bool forceOpaqueBG = usingCleartype && !usingTransparency;
+
     _foregroundColor = _ColorFFromColorRef(OPACITY_OPAQUE | colorForeground);
+    // October 2021: small changes were made to the way BG color interacts with
+    // grayscale AA, esp. with regards to acrylic and GH#5098. See comment in
+    // _ShouldForceGrayscaleAA for more details.
     _backgroundColor = _ColorFFromColorRef((forceOpaqueBG ? OPACITY_OPAQUE : 0) | colorBackground);
 
     _d2dBrushForeground->SetColor(_foregroundColor);
@@ -2237,14 +2233,19 @@ CATCH_LOG()
 //   rendering onto a transparent surface (like acrylic), then cleartype won't
 //   work correctly, and will actually just additively blend with the
 //   background. This is here to support GH#5098.
+// - We'll use this, along with whether cleartype was requested, to manually set
+//   the alpha channel of the background brush to 1.0. We need to do that to
+//   make cleartype work without blending. However, we don't want to do that too
+//   often - if we do that on top of a transparent BG, then the entire swap
+//   chain will be fully opaque.
 // Arguments:
-// - opacity: the new opacity of our background, on [0.0f, 1.0f]
+// - isTransparent: true if our BG is transparent (acrylic, or anything that's not fully opaque)
 // Return Value:
 // - <none>
-void DxEngine::SetDefaultTextBackgroundOpacity(const float opacity) noexcept
+void DxEngine::EnableTransparentBackground(const bool isTransparent) noexcept
 try
 {
-    _defaultTextBackgroundOpacity = opacity;
+    _defaultBackgroundIsTransparent = isTransparent;
 
     // Make sure we redraw all the cells, to update whether they're actually
     // drawn with cleartype or not.

src/renderer/dx/DxRenderer.hpp

@@ -128,7 +128,7 @@ namespace Microsoft::Console::Render
 
         void SetSelectionBackground(const COLORREF color, const float alpha = 0.5f) noexcept override;
         void SetAntialiasingMode(const D2D1_TEXT_ANTIALIAS_MODE antialiasingMode) noexcept override;
-        void SetDefaultTextBackgroundOpacity(const float opacity) noexcept override;
+        void EnableTransparentBackground(const bool isTransparent) noexcept override;
         void SetIntenseIsBold(const bool opacity) noexcept override;
 
         void UpdateHyperlinkHoveredId(const uint16_t hoveredId) noexcept override;
@@ -257,7 +257,7 @@ namespace Microsoft::Console::Render
 
         D2D1_TEXT_ANTIALIAS_MODE _antialiasingMode;
 
-        float _defaultTextBackgroundOpacity;
+        bool _defaultBackgroundIsTransparent;
         bool _intenseIsBold;
 
         // DirectX constant buffers need to be a multiple of 16; align to pad the size.

src/renderer/inc/IRenderEngine.hpp

@@ -104,7 +104,7 @@ namespace Microsoft::Console::Render
         // DxRenderer - setter
         virtual void SetAntialiasingMode(const D2D1_TEXT_ANTIALIAS_MODE antialiasingMode) noexcept {}
         virtual void SetCallback(std::function<void()> pfn) noexcept {}
-        virtual void SetDefaultTextBackgroundOpacity(const float opacity) noexcept {}
+        virtual void EnableTransparentBackground(const bool isTransparent) noexcept {}
         virtual void SetForceFullRepaintRendering(bool enable) noexcept {}
         virtual [[nodiscard]] HRESULT SetHwnd(const HWND hwnd) noexcept { return E_NOTIMPL; }
         virtual void SetPixelShaderPath(std::wstring_view value) noexcept {}