Re-enable the setting to adjust the colors of indistinguishable text

src/cascadia/TerminalSettingsModel/MTSMSettings.h

@@ -109,7 +109,7 @@ Author(s):
     X(hstring, ColorSchemeName, "colorScheme", L"Campbell")                                                                                                        \
     X(hstring, BackgroundImagePath, "backgroundImage")                                                                                                             \
     X(Model::IntenseStyle, IntenseTextStyle, "intenseTextStyle", Model::IntenseStyle::Bright)                                                                      \
-    X(bool, AdjustIndistinguishableColors, "adjustIndistinguishableColors", false)
+    X(bool, AdjustIndistinguishableColors, "adjustIndistinguishableColors", true)
 
 // Intentionally omitted Appearance settings:
 // * ForegroundKey, BackgroundKey, SelectionBackgroundKey, CursorColorKey: all optional colors

src/renderer/base/RenderSettings.cpp

@@ -13,6 +13,7 @@ using Microsoft::Console::Utils::InitializeColorTable;
 
 static constexpr size_t AdjustedFgIndex{ 16 };
 static constexpr size_t AdjustedBgIndex{ 17 };
+static constexpr size_t AdjustedBrightFgIndex{ 18 };
 
 RenderSettings::RenderSettings() noexcept
 {
@@ -79,15 +80,19 @@ void RenderSettings::MakeAdjustedColorArray() noexcept
 {
     // The color table has 16 colors, but the adjusted color table needs to be 18
     // to include the default background and default foreground colors
-    std::array<COLORREF, 18> colorTableWithDefaults;
+    std::array<COLORREF, 19> colorTableWithDefaults;
     std::copy_n(std::begin(_colorTable), 16, std::begin(colorTableWithDefaults));
     colorTableWithDefaults[AdjustedFgIndex] = GetColorAlias(ColorAlias::DefaultForeground);
     colorTableWithDefaults[AdjustedBgIndex] = GetColorAlias(ColorAlias::DefaultBackground);
 
-    for (auto fgIndex = 0; fgIndex < 18; ++fgIndex)
+    // We need to use TextColor to calculate the bright default fg
+    TextColor defaultFg;
+    colorTableWithDefaults[AdjustedBrightFgIndex] = defaultFg.GetColor(_colorTable, GetColorAliasIndex(ColorAlias::DefaultForeground), true);
+
+    for (auto fgIndex = 0; fgIndex < 19; ++fgIndex)
     {
         const auto fg = til::at(colorTableWithDefaults, fgIndex);
-        for (auto bgIndex = 0; bgIndex < 18; ++bgIndex)
+        for (auto bgIndex = 0; bgIndex < 19; ++bgIndex)
         {
             if (fgIndex == bgIndex)
             {
@@ -203,18 +208,30 @@ std::pair<COLORREF, COLORREF> RenderSettings::GetAttributeColors(const TextAttri
     if (Feature_AdjustIndistinguishableText::IsEnabled() &&
         GetRenderMode(Mode::DistinguishableColors) &&
         !dimFg &&
-        !brightenFg &&
         !attr.IsInvisible() &&
         (fgTextColor.IsDefault() || fgTextColor.IsLegacy()) &&
         (bgTextColor.IsDefault() || bgTextColor.IsLegacy()))
     {
         const auto bgIndex = bgTextColor.IsDefault() ? AdjustedBgIndex : bgTextColor.GetIndex();
         auto fgIndex = fgTextColor.IsDefault() ? AdjustedFgIndex : fgTextColor.GetIndex();
 
+        if (brightenFg)
+        {
+            // There is a special case for intense here - we need to get the bright version of the foreground color
+            if (fgTextColor.IsIndex16() && (fgIndex < 8))
+            {
+                fgIndex += 8;
+            }
+            else if (fgTextColor.IsDefault())
+            {
+                fgIndex = AdjustedBrightFgIndex;
+            }
+        }
+
         if (swapFgAndBg)
         {
             const auto fg = _adjustedForegroundColors[fgIndex][bgIndex];
-            const auto bg = fgTextColor.GetColor(_colorTable, defaultFgIndex);
+            const auto bg = fgTextColor.GetColor(_colorTable, defaultFgIndex, brightenFg);
             return { fg, bg };
         }
         else

src/renderer/inc/RenderSettings.hpp

@@ -47,7 +47,7 @@ namespace Microsoft::Console::Render
         til::enumset<Mode> _renderMode{ Mode::BlinkAllowed, Mode::IntenseIsBright };
         std::array<COLORREF, TextColor::TABLE_SIZE> _colorTable;
         std::array<size_t, static_cast<size_t>(ColorAlias::ENUM_COUNT)> _colorAliasIndices;
-        std::array<std::array<COLORREF, 18>, 18> _adjustedForegroundColors;
+        std::array<std::array<COLORREF, 19>, 19> _adjustedForegroundColors;
         size_t _blinkCycle = 0;
         mutable bool _blinkIsInUse = false;
         bool _blinkShouldBeFaint = false;

src/terminal/adapter/adaptDispatch.cpp

@@ -2221,6 +2221,11 @@ bool AdaptDispatch::SetClipboard(const std::wstring_view content)
 bool AdaptDispatch::SetColorTableEntry(const size_t tableIndex, const DWORD dwColor)
 {
     _renderSettings.SetColorTableEntry(tableIndex, dwColor);
+    if (_renderSettings.GetRenderMode(RenderSettings::Mode::DistinguishableColors))
+    {
+        // Re-calculate the adjusted colors now that one of the entries has been changed
+        _renderSettings.MakeAdjustedColorArray();
+    }
 
     // If we're a conpty, always return false, so that we send the updated color
     //      value to the terminal. Still handle the sequence so apps that use