Use a dark titlebar when we've requested dark theme

src/cascadia/TerminalSettingsEditor/GlobalAppearanceViewModel.cpp

@@ -218,7 +218,7 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation
     {
         if (const auto& theme{ tag.try_as<Model::Theme>() })
         {
-            _GlobalSettings.Theme(theme.Name());
+            _GlobalSettings.Theme(Model::ThemePair{ theme.Name() });
         }
     }
 

src/cascadia/TerminalSettingsModel/CascadiaSettings.cpp

@@ -1178,14 +1178,32 @@ void CascadiaSettings::_validateThemeExists()
         auto newTheme = winrt::make_self<Theme>();
         newTheme->Name(L"system");
         _globals->AddTheme(*newTheme);
-        _globals->Theme(L"system");
+        _globals->Theme(*winrt::make_self<ThemePair>(L"system"));
     }
 
-    if (!_globals->Themes().HasKey(_globals->Theme()))
+    if (_globals->Theme().DarkName() == _globals->Theme().LightName())
     {
-        _warnings.Append(SettingsLoadWarnings::UnknownTheme);
-
-        // safely fall back to system as the theme.
-        _globals->Theme(L"system");
+        // Only one theme. We'll treat it as such.
+        if (!_globals->Themes().HasKey(_globals->Theme().DarkName()))
+        {
+            _warnings.Append(SettingsLoadWarnings::UnknownTheme);
+            // safely fall back to system as the theme.
+            _globals->Theme(*winrt::make_self<ThemePair>(L"system"));
+        }
+    }
+    else
+    {
+        // Two different themes. Check each separately, and fall back to a
+        // reasonable default contextually
+        if (!_globals->Themes().HasKey(_globals->Theme().LightName()))
+        {
+            _warnings.Append(SettingsLoadWarnings::UnknownTheme);
+            _globals->Theme().LightName(L"light");
+        }
+        if (!_globals->Themes().HasKey(_globals->Theme().DarkName()))
+        {
+            _warnings.Append(SettingsLoadWarnings::UnknownTheme);
+            _globals->Theme().DarkName(L"dark");
+        }
     }
 }

src/cascadia/TerminalSettingsModel/GlobalAppSettings.cpp

@@ -6,6 +6,7 @@
 #include "../../types/inc/Utils.hpp"
 #include "JsonUtils.h"
 #include "KeyChordSerialization.h"
+#include "SettingsUtils.h"
 
 #include "GlobalAppSettings.g.cpp"
 
@@ -212,7 +213,22 @@ Json::Value GlobalAppSettings::ToJson() const
 
 winrt::Microsoft::Terminal::Settings::Model::Theme GlobalAppSettings::CurrentTheme() noexcept
 {
-    return _themes.TryLookup(Theme());
+    auto requestedTheme = IsSystemInDarkTheme() ?
+                              winrt::Windows::UI::Xaml::ElementTheme::Dark :
+                              winrt::Windows::UI::Xaml::ElementTheme::Light;
+
+    switch (requestedTheme)
+    {
+    case winrt::Windows::UI::Xaml::ElementTheme::Light:
+        return _themes.TryLookup(Theme().LightName());
+
+    case winrt::Windows::UI::Xaml::ElementTheme::Dark:
+        return _themes.TryLookup(Theme().DarkName());
+
+    case winrt::Windows::UI::Xaml::ElementTheme::Default:
+    default:
+        return nullptr;
+    }
 }
 
 void GlobalAppSettings::AddTheme(const Model::Theme& theme)

src/cascadia/TerminalSettingsModel/GlobalAppSettings.idl

@@ -106,7 +106,7 @@ namespace Microsoft.Terminal.Settings.Model
 
         Windows.Foundation.Collections.IMapView<String, Theme> Themes();
         void AddTheme(Theme theme);
-        INHERITABLE_SETTING(String, Theme);
+        INHERITABLE_SETTING(ThemePair, Theme);
         Theme CurrentTheme { get; };
     }
 }

src/cascadia/TerminalSettingsModel/MTSMSettings.h

@@ -34,7 +34,7 @@ Author(s):
     X(Model::NewTabPosition, NewTabPosition, "newTabPosition", Model::NewTabPosition::AfterLastTab)                                                        \
     X(bool, ShowTitleInTitlebar, "showTerminalTitleInTitlebar", true)                                                                                      \
     X(bool, ConfirmCloseAllTabs, "confirmCloseAllTabs", true)                                                                                              \
-    X(hstring, Theme, "theme")                                                                                                                             \
+    X(Model::ThemePair, Theme, "theme")                                                                                                                    \
     X(hstring, Language, "language")                                                                                                                       \
     X(winrt::Microsoft::UI::Xaml::Controls::TabViewWidthMode, TabWidthMode, "tabWidthMode", winrt::Microsoft::UI::Xaml::Controls::TabViewWidthMode::Equal) \
     X(bool, UseAcrylicInTabRow, "useAcrylicInTabRow", false)                                                                                               \

src/cascadia/TerminalSettingsModel/Microsoft.Terminal.Settings.ModelLib.vcxproj

@@ -115,6 +115,7 @@
     <ClInclude Include="WslDistroGenerator.h" />
     <ClInclude Include="SshHostGenerator.h" />
     <ClInclude Include="ModelSerializationHelpers.h" />
+    <ClInclude Include="SettingsUtils.h" />
   </ItemGroup>
   <!-- ========================= Cpp Files ======================== -->
   <ItemGroup>

src/cascadia/TerminalSettingsModel/SettingsUtils.h

@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#pragma once
+
+bool IsSystemInDarkTheme();

src/cascadia/TerminalSettingsModel/TerminalSettings.cpp

@@ -7,10 +7,21 @@
 
 #include "TerminalSettings.g.cpp"
 #include "TerminalSettingsCreateResult.g.cpp"
+#include "SettingsUtils.h"
 
 using namespace winrt::Microsoft::Terminal::Control;
 using namespace Microsoft::Console::Utils;
 
+// I'm not even joking, this is the recommended way to do this:
+// https://learn.microsoft.com/en-us/windows/apps/desktop/modernize/apply-windows-themes#know-when-dark-mode-is-enabled
+bool IsSystemInDarkTheme()
+{
+    static auto isColorLight = [](const winrt::Windows::UI::Color& clr) -> bool {
+        return (((5 * clr.G) + (2 * clr.R) + clr.B) > (8 * 128));
+    };
+    return isColorLight(winrt::Windows::UI::ViewManagement::UISettings().GetColorValue(winrt::Windows::UI::ViewManagement::UIColorType::Foreground));
+};
+
 namespace winrt::Microsoft::Terminal::Settings::Model::implementation
 {
     static std::tuple<Windows::UI::Xaml::HorizontalAlignment, Windows::UI::Xaml::VerticalAlignment> ConvertConvergedAlignment(ConvergedAlignment alignment)
@@ -183,16 +194,6 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
         return settingsPair;
     }
 
-    // I'm not even joking, this is the recommended way to do this:
-    // https://learn.microsoft.com/en-us/windows/apps/desktop/modernize/apply-windows-themes#know-when-dark-mode-is-enabled
-    bool _isSystemInDarkTheme()
-    {
-        static auto isColorLight = [](const Windows::UI::Color& clr) -> bool {
-            return (((5 * clr.G) + (2 * clr.R) + clr.B) > (8 * 128));
-        };
-        return isColorLight(Windows::UI::ViewManagement::UISettings().GetColorValue(Windows::UI::ViewManagement::UIColorType::Foreground));
-    }
-
     void TerminalSettings::_ApplyAppearanceSettings(const IAppearanceConfig& appearance,
                                                     const Windows::Foundation::Collections::IMapView<winrt::hstring, ColorScheme>& schemes,
                                                     const winrt::Microsoft::Terminal::Settings::Model::Theme currentTheme)
@@ -203,7 +204,7 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
         auto requestedTheme = currentTheme.RequestedTheme();
         if (requestedTheme == winrt::Windows::UI::Xaml::ElementTheme::Default)
         {
-            requestedTheme = _isSystemInDarkTheme() ?
+            requestedTheme = IsSystemInDarkTheme() ?
                                  winrt::Windows::UI::Xaml::ElementTheme::Dark :
                                  winrt::Windows::UI::Xaml::ElementTheme::Light;
         }

src/cascadia/TerminalSettingsModel/Theme.cpp

@@ -6,13 +6,15 @@
 #include "../../types/inc/Utils.hpp"
 #include "../../types/inc/colorTable.hpp"
 #include "Utils.h"
+#include "SettingsUtils.h"
 #include "JsonUtils.h"
 #include "TerminalSettingsSerializationHelpers.h"
 
 #include "ThemeColor.g.cpp"
 #include "WindowTheme.g.cpp"
 #include "TabRowTheme.g.cpp"
 #include "TabTheme.g.cpp"
+#include "ThemePair.g.cpp"
 #include "Theme.g.cpp"
 
 using namespace ::Microsoft::Console;
@@ -27,6 +29,8 @@ namespace winrt
 }
 
 static constexpr std::string_view NameKey{ "name" };
+static constexpr std::string_view LightNameKey{ "light" };
+static constexpr std::string_view DarkNameKey{ "dark" };
 
 static constexpr wchar_t RegKeyDwm[] = L"Software\\Microsoft\\Windows\\DWM";
 static constexpr wchar_t RegKeyAccentColor[] = L"AccentColor";
@@ -320,3 +324,56 @@ winrt::WUX::ElementTheme Theme::RequestedTheme() const noexcept
 {
     return _Window ? _Window.RequestedTheme() : winrt::WUX::ElementTheme::Default;
 }
+
+bool Theme::IsActuallyDarkTheme() const
+{
+    switch (RequestedTheme())
+    {
+    case winrt::Windows::UI::Xaml::ElementTheme::Light:
+        return false;
+    case winrt::Windows::UI::Xaml::ElementTheme::Dark:
+        return true;
+    case winrt::Windows::UI::Xaml::ElementTheme::Default:
+    default:
+        return IsSystemInDarkTheme();
+    }
+}
+
+winrt::com_ptr<ThemePair> ThemePair::FromJson(const Json::Value& json)
+{
+    auto result = winrt::make_self<ThemePair>(L"dark");
+
+    if (json.isString())
+    {
+        result->_DarkName = result->_LightName = JsonUtils::GetValue<winrt::hstring>(json);
+    }
+    else if (json.isObject())
+    {
+        JsonUtils::GetValueForKey(json, DarkNameKey, result->_DarkName);
+        JsonUtils::GetValueForKey(json, LightNameKey, result->_LightName);
+    }
+    return result;
+}
+
+Json::Value ThemePair::ToJson() const
+{
+    if (DarkName() == LightName())
+    {
+        return JsonUtils::ConversionTrait<winrt::hstring>().ToJson(DarkName());
+    }
+    else
+    {
+        Json::Value json{ Json::ValueType::objectValue };
+
+        JsonUtils::SetValueForKey(json, DarkNameKey, _DarkName);
+        JsonUtils::SetValueForKey(json, LightNameKey, _LightName);
+        return json;
+    }
+}
+winrt::com_ptr<ThemePair> ThemePair::Copy() const
+{
+    auto pair{ winrt::make_self<ThemePair>() };
+    pair->_DarkName = _DarkName;
+    pair->_LightName = _LightName;
+    return pair;
+}

src/cascadia/TerminalSettingsModel/Theme.h

@@ -22,10 +22,33 @@ Author(s):
 #include "WindowTheme.g.h"
 #include "TabRowTheme.g.h"
 #include "TabTheme.g.h"
+#include "ThemePair.g.h"
 #include "Theme.g.h"
 
+#include "JsonUtils.h"
+
 namespace winrt::Microsoft::Terminal::Settings::Model::implementation
 {
+    struct ThemePair : ThemePairT<ThemePair>
+    {
+    public:
+        ThemePair() = default;
+        explicit ThemePair(const winrt::hstring& name) noexcept :
+            _DarkName{ name },
+            _LightName{ name } {};
+
+        explicit ThemePair(const winrt::hstring& lightName, const winrt::hstring& darkName) noexcept :
+            _DarkName{ darkName },
+            _LightName{ lightName } {};
+
+        static com_ptr<ThemePair> FromJson(const Json::Value& json);
+        Json::Value ToJson() const;
+        com_ptr<ThemePair> Copy() const;
+
+        WINRT_PROPERTY(winrt::hstring, DarkName);
+        WINRT_PROPERTY(winrt::hstring, LightName);
+    };
+
     struct ThemeColor : ThemeColorT<ThemeColor>
     {
     public:
@@ -76,6 +99,7 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
         Json::Value ToJson() const;
 
         winrt::Windows::UI::Xaml::ElementTheme RequestedTheme() const noexcept;
+        bool IsActuallyDarkTheme() const;
 
         WINRT_PROPERTY(winrt::hstring, Name);
 
@@ -92,4 +116,32 @@ namespace winrt::Microsoft::Terminal::Settings::Model::factory_implementation
 {
     BASIC_FACTORY(ThemeColor);
     BASIC_FACTORY(Theme);
+    BASIC_FACTORY(ThemePair);
+}
+
+namespace Microsoft::Terminal::Settings::Model::JsonUtils
+{
+    template<>
+    struct ConversionTrait<winrt::Microsoft::Terminal::Settings::Model::ThemePair>
+    {
+        winrt::Microsoft::Terminal::Settings::Model::ThemePair FromJson(const Json::Value& json)
+        {
+            return *winrt::Microsoft::Terminal::Settings::Model::implementation::ThemePair::FromJson(json);
+        }
+
+        bool CanConvert(const Json::Value& json) const
+        {
+            return json.isObject() || json.isString();
+        }
+
+        Json::Value ToJson(const winrt::Microsoft::Terminal::Settings::Model::ThemePair& val)
+        {
+            return winrt::get_self<winrt::Microsoft::Terminal::Settings::Model::implementation::ThemePair>(val)->ToJson();
+        }
+
+        std::string TypeDescription() const
+        {
+            return "ThemePair{ string, string }";
+        }
+    };
 }

src/cascadia/TerminalSettingsModel/Theme.idl

@@ -18,6 +18,16 @@ namespace Microsoft.Terminal.Settings.Model
         Never
     };
 
+    [default_interface] runtimeclass ThemePair
+    {
+        ThemePair();
+        ThemePair(String name);
+        ThemePair(String darkName, String lightName);
+
+        String DarkName;
+        String LightName;
+    };
+
     runtimeclass ThemeColor
     {
         ThemeColor();
@@ -68,6 +78,7 @@ namespace Microsoft.Terminal.Settings.Model
 
         // A helper for retrieving the RequestedTheme out of the window property
         Windows.UI.Xaml.ElementTheme RequestedTheme { get; };
+        Boolean IsActuallyDarkTheme();
 
     }
 }

src/cascadia/WindowsTerminal/AppHost.cpp

@@ -1353,6 +1353,12 @@ void AppHost::_updateTheme()
     const auto b = _logic.TitlebarBrush();
     const auto opacity = b ? ThemeColor::ColorFromBrush(b).A / 255.0 : 0.0;
     _window->UseMica(theme.Window().UseMica(), opacity);
+
+    // This is a hack to make the window borders dark instead of light.
+    // It must be done before WM_NCPAINT so that the borders are rendered with
+    // the correct theme.
+    // For more information, see GH#6620.
+    LOG_IF_FAILED(TerminalTrySetDarkTheme(_window->GetHandle(), theme.IsActuallyDarkTheme()));
 }
 
 void AppHost::_HandleSettingsChanged(const winrt::Windows::Foundation::IInspectable& /*sender*/,

src/cascadia/WindowsTerminal/BaseWindow.h

@@ -28,7 +28,7 @@ class BaseWindow
             WINRT_ASSERT(!that->_window);
             that->_window = wil::unique_hwnd(window);
 
-            return that->_OnNcCreate(wparam, lparam);
+            return that->OnNcCreate(wparam, lparam);
         }
         else if (T* that = GetThisFromHandle(window))
         {
@@ -214,7 +214,7 @@ class BaseWindow
     // - This method is called when the window receives the WM_NCCREATE message.
     // Return Value:
     // - The value returned from the window proc.
-    virtual [[nodiscard]] LRESULT _OnNcCreate(WPARAM wParam, LPARAM lParam) noexcept
+    virtual [[nodiscard]] LRESULT OnNcCreate(WPARAM wParam, LPARAM lParam) noexcept
     {
         SetWindowLongPtr(_window.get(), GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this));