Address all of the things, mostly

Author: lhecker

.github/actions/spelling/expect/expect.txt

@@ -179,7 +179,6 @@ changelists
 charinfo
 CHARSETINFO
 chh
-chonker
 chshdng
 CHT
 CLASSSTRING
@@ -1049,7 +1048,6 @@ mdmerge
 MDs
 MEASUREITEM
 megamix
-Meh
 memallocator
 meme
 MENUCHAR
@@ -1988,6 +1986,7 @@ WCIW
 WCSHELPER
 wcsicmp
 wcsrev
+wcswidth
 wddm
 wddmcon
 WDDMCONSOLECONTEXT
@@ -2142,6 +2141,7 @@ XFORM
 XIn
 XManifest
 XMath
+XNamespace
 xorg
 XPan
 XResource

src/buffer/out/Row.cpp

@@ -566,6 +566,7 @@ void ROW::ReplaceAttributes(const til::CoordType beginIndex, const til::CoordTyp
 void ROW::ReplaceCharacters(til::CoordType columnBegin, til::CoordType width, const std::wstring_view& chars)
 try
 {
+    assert(width >= 1 && width <= 2);
     WriteHelper h{ *this, columnBegin, _columnCount, chars };
     if (!h.IsValid())
     {
@@ -634,16 +635,17 @@ catch (...)
     throw;
 }
 
-[[msvc::forceinline]] void ROW::WriteHelper::ReplaceText() noexcept
+void ROW::WriteHelper::ReplaceText() noexcept
 {
     // This function starts with a fast-pass for ASCII. ASCII is still predominant in technical areas.
     //
     // We can infer the "end" from the amount of columns we're given (colLimit - colBeg),
     // because ASCII is always 1 column wide per character.
-    const auto len = std::min<size_t>(chars.size(), colLimit - colBeg);
+    auto len = std::min<size_t>(chars.size(), colLimit - colEnd);
     size_t ch = chBeg;
+    size_t off = 0;
 
-    for (size_t off = 0; off < len; ++off)
+    for (; off < len; ++off)
     {
         if (chars[off] >= 0x80) [[unlikely]]
         {
@@ -660,27 +662,70 @@ catch (...)
     charsConsumed = ch - chBeg;
 }
 
-[[msvc::forceinline]] void ROW::WriteHelper::_replaceTextUnicode(size_t ch, size_t off) noexcept
+void ROW::WriteHelper::_replaceTextUnicode(size_t ch, size_t off) noexcept
 {
     auto& cwd = CodepointWidthDetector::Singleton();
     const auto len = chars.size();
 
-    // The non-ASCII character we have encountered may be a combining mark, like "a^" which is then displayed as "â".
-    // In order to recognize both characters as a single grapheme, we need to back up by 1 ASCII character
-    // and let MeasureNext() find the next proper grapheme boundary.
-    if (off != 0)
+    // Check if the new text joins with the existing contents of the row to form a single grapheme cluster.
+    if (off == 0)
     {
+        auto colPrev = colBeg;
+        while (colPrev > 0 && row._uncheckedIsTrailer(--colPrev))
+        {
+        }
+
+        const auto chPrev = row._uncheckedCharOffset(colPrev);
+        const std::wstring_view charsPrev{ row._chars.data() + chPrev, ch - chPrev };
+
+        GraphemeState state;
+        cwd.GraphemeNext(state, charsPrev);
+        cwd.GraphemeNext(state, chars);
+
+        if (state.len > 0)
+        {
+            colBegDirty = colPrev;
+            colEnd = colPrev;
+
+            const auto colEndNew = gsl::narrow_cast<uint16_t>(colEnd + state.width);
+            if (colEndNew > colLimit)
+            {
+                colEndDirty = colLimit;
+                charsConsumed = ch - chBeg;
+                return;
+            }
+
+            // Fill our char-offset buffer with 1 entry containing the mapping from the
+            // current column (colEnd) to the start of the glyph in the string (ch)...
+            til::at(row._charOffsets, colEnd++) = gsl::narrow_cast<uint16_t>(chPrev);
+            // ...followed by 0-N entries containing an indication that the
+            // columns are just a wide-glyph extension of the preceding one.
+            while (colEnd < colEndNew)
+            {
+                til::at(row._charOffsets, colEnd++) = gsl::narrow_cast<uint16_t>(chPrev | CharOffsetsTrailer);
+            }
+
+            ch += state.len;
+            off += state.len;
+        }
+    }
+    else
+    {
+        // The non-ASCII character we have encountered may be a combining mark, like "a^" which is then displayed as "â".
+        // In order to recognize both characters as a single grapheme, we need to back up by 1 ASCII character
+        // and let MeasureNext() find the next proper grapheme boundary.
         --colEnd;
         --ch;
         --off;
     }
 
+    GraphemeState state{ .beg = chars.data() + off };
+
     while (off < len)
     {
-        int width;
-        const auto end = cwd.GraphemeNext(chars, off, &width);
+        cwd.GraphemeNext(state, chars);
 
-        const auto colEndNew = gsl::narrow_cast<uint16_t>(colEnd + width);
+        const auto colEndNew = gsl::narrow_cast<uint16_t>(colEnd + state.width);
         if (colEndNew > colLimit)
         {
             colEndDirty = colLimit;
@@ -698,8 +743,8 @@ catch (...)
             til::at(row._charOffsets, colEnd++) = gsl::narrow_cast<uint16_t>(ch | CharOffsetsTrailer);
         }
 
-        ch += end - off;
-        off = end;
+        ch += state.len;
+        off += state.len;
     }
 
     colEndDirty = colEnd;
@@ -804,7 +849,7 @@ catch (...)
 }
 #pragma warning(pop)
 
-[[msvc::forceinline]] void ROW::WriteHelper::Finish()
+void ROW::WriteHelper::Finish()
 {
     colEndDirty = row._adjustForward(colEndDirty);
 

src/buffer/out/textBuffer.cpp

@@ -409,14 +409,18 @@ void TextBuffer::_PrepareForDoubleByteSequence(const DbcsAttribute dbcsAttribute
 size_t TextBuffer::GraphemeNext(const std::wstring_view& chars, size_t position) noexcept
 {
     auto& cwd = CodepointWidthDetector::Singleton();
-    return cwd.GraphemeNext(chars, position, nullptr);
+    GraphemeState state{ .beg = chars.data() + position };
+    cwd.GraphemeNext(state, chars);
+    return position + state.len;
 }
 
 // It's the counterpart to GraphemeNext. See GraphemeNext.
 size_t TextBuffer::GraphemePrev(const std::wstring_view& chars, size_t position) noexcept
 {
     auto& cwd = CodepointWidthDetector::Singleton();
-    return cwd.GraphemePrev(chars, position, nullptr);
+    GraphemeState state{ .beg = chars.data() + position };
+    cwd.GraphemePrev(state, chars);
+    return position - state.len;
 }
 
 // Ever wondered how much space a piece of text needs before inserting it? This function will tell you!
@@ -465,11 +469,13 @@ size_t TextBuffer::FitTextIntoColumns(const std::wstring_view& chars, til::Coord
         col--;
     }
 
+    GraphemeState state{ .beg = chars.data() + dist };
+
     while (dist < len)
     {
-        int width;
-        dist = cwd.GraphemeNext(chars, dist, &width);
-        col += width;
+        cwd.GraphemeNext(state, chars);
+        dist += state.len;
+        col += state.width;
 
         // If we ran out of columns, we need to always return `columnLimit` and not `cols`,
         // because if we tried inserting a wide glyph into just 1 remaining column it will

src/cascadia/TerminalApp/AppLogic.cpp

@@ -3,16 +3,18 @@
 
 #include "pch.h"
 #include "AppLogic.h"
-#include "../inc/WindowingBehavior.h"
-#include "AppLogic.g.cpp"
-#include "FindTargetWindowResult.g.cpp"
-#include "SettingsLoadEventArgs.h"
 
 #include <LibraryResources.h>
 #include <WtExeUtils.h>
 #include <wil/token_helpers.h>
 
+#include "SettingsLoadEventArgs.h"
+#include "../../types/inc/CodepointWidthDetector.hpp"
 #include "../../types/inc/utils.hpp"
+#include "../inc/WindowingBehavior.h"
+
+#include "AppLogic.g.cpp"
+#include "FindTargetWindowResult.g.cpp"
 
 using namespace winrt::Windows::ApplicationModel;
 using namespace winrt::Windows::ApplicationModel::DataTransfer;
@@ -433,13 +435,6 @@ namespace winrt::TerminalApp::implementation
             }
         }
 
-        if (initialLoad)
-        {
-            // Register for directory change notification.
-            _RegisterSettingsChange();
-            return;
-        }
-
         // Here, we successfully reloaded the settings, and created a new
         // TerminalSettings object.
 

src/cascadia/TerminalApp/TerminalPage.cpp

@@ -4,18 +4,11 @@
 
 #include "pch.h"
 #include "TerminalPage.h"
-#include "TerminalPage.g.cpp"
-#include "RenameWindowRequestedArgs.g.cpp"
-#include "RequestMoveContentArgs.g.cpp"
-#include "RequestReceiveContentArgs.g.cpp"
-#include "LaunchPositionRequest.g.cpp"
-
-#include <filesystem>
 
-#include <inc/WindowingBehavior.h>
 #include <LibraryResources.h>
 #include <TerminalCore/ControlKeyStates.hpp>
 #include <til/latch.h>
+#include <Utils.h>
 
 #include "../../types/inc/utils.hpp"
 #include "App.h"
@@ -24,7 +17,12 @@
 #include "SettingsPaneContent.h"
 #include "ScratchpadContent.h"
 #include "TabRowControl.h"
-#include "Utils.h"
+
+#include "TerminalPage.g.cpp"
+#include "RenameWindowRequestedArgs.g.cpp"
+#include "RequestMoveContentArgs.g.cpp"
+#include "RequestReceiveContentArgs.g.cpp"
+#include "LaunchPositionRequest.g.cpp"
 
 using namespace winrt;
 using namespace winrt::Microsoft::Terminal::Control;
@@ -1211,6 +1209,26 @@ namespace winrt::TerminalApp::implementation
                                                                                         TerminalSettings settings,
                                                                                         const bool inheritCursor)
     {
+        // The only way to create string references to literals in WinRT is through std::optional. Fun!
+        static std::optional<winrt::param::hstring> textMeasurement;
+        static const auto textMeasurementInit = [&]() {
+            switch (_settings.GlobalSettings().TextMeasurement())
+            {
+            case TextMeasurement::Graphemes:
+                textMeasurement.emplace(L"graphemes");
+                break;
+            case TextMeasurement::Wcswidth:
+                textMeasurement.emplace(L"wcswidth");
+                break;
+            case TextMeasurement::Console:
+                textMeasurement.emplace(L"console");
+                break;
+            default:
+                break;
+            }
+            return true;
+        }();
+
         TerminalConnection::ITerminalConnection connection{ nullptr };
 
         auto connectionType = profile.ConnectionType();
@@ -1282,6 +1300,11 @@ namespace winrt::TerminalApp::implementation
             }
         }
 
+        if (textMeasurement)
+        {
+            valueSet.Insert(L"textMeasurement", Windows::Foundation::PropertyValue::CreateString(*textMeasurement));
+        }
+
         if (const auto id = settings.SessionId(); id != winrt::guid{})
         {
             valueSet.Insert(L"sessionId", Windows::Foundation::PropertyValue::CreateGuid(id));

src/cascadia/TerminalConnection/ConptyConnection.cpp

@@ -5,7 +5,6 @@
 #include "ConptyConnection.h"
 
 #include <conpty-static.h>
-#include <til/string.h>
 #include <winternl.h>
 
 #include "CTerminalHandoff.h"
@@ -259,11 +258,39 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
             _cols = unbox_prop_or<uint32_t>(settings, L"initialCols", _cols);
             _sessionId = unbox_prop_or<winrt::guid>(settings, L"sessionId", _sessionId);
             _environment = settings.TryLookup(L"environment").try_as<Windows::Foundation::Collections::ValueSet>();
-            _inheritCursor = unbox_prop_or<bool>(settings, L"inheritCursor", _inheritCursor);
             _profileGuid = unbox_prop_or<winrt::guid>(settings, L"profileGuid", _profileGuid);
 
-            const auto& initialEnvironment{ unbox_prop_or<winrt::hstring>(settings, L"initialEnvironment", L"") };
+            _flags = PSEUDOCONSOLE_RESIZE_QUIRK;
+
+            // If we're using an existing buffer, we want the new connection
+            // to reuse the existing cursor. When not setting this flag, the
+            // PseudoConsole sends a clear screen VT code which our renderer
+            // interprets into making all the previous lines be outside the
+            // current viewport.
+            const auto inheritCursor = unbox_prop_or<bool>(settings, L"inheritCursor", false);
+            if (inheritCursor)
+            {
+                _flags |= PSEUDOCONSOLE_INHERIT_CURSOR;
+            }
+
+            const auto textMeasurement = unbox_prop_or<winrt::hstring>(settings, L"textMeasurement", winrt::hstring{});
+            if (!textMeasurement.empty())
+            {
+                if (textMeasurement == L"graphemes")
+                {
+                    _flags |= PSEUDOCONSOLE_GLYPH_WIDTH_GRAPHEMES;
+                }
+                else if (textMeasurement == L"wcswidth")
+                {
+                    _flags |= PSEUDOCONSOLE_GLYPH_WIDTH_WCSWIDTH;
+                }
+                else if (textMeasurement == L"console")
+                {
+                    _flags |= PSEUDOCONSOLE_GLYPH_WIDTH_CONSOLE;
+                }
+            }
 
+            const auto& initialEnvironment{ unbox_prop_or<winrt::hstring>(settings, L"initialEnvironment", L"") };
             const bool reloadEnvironmentVariables = unbox_prop_or<bool>(settings, L"reloadEnvironmentVariables", false);
 
             if (reloadEnvironmentVariables)
@@ -318,19 +345,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
         // handoff from an already-started PTY process.
         if (!_inPipe)
         {
-            DWORD flags = PSEUDOCONSOLE_RESIZE_QUIRK;
-
-            // If we're using an existing buffer, we want the new connection
-            // to reuse the existing cursor. When not setting this flag, the
-            // PseudoConsole sends a clear screen VT code which our renderer
-            // interprets into making all the previous lines be outside the
-            // current viewport.
-            if (_inheritCursor)
-            {
-                flags |= PSEUDOCONSOLE_INHERIT_CURSOR;
-            }
-
-            THROW_IF_FAILED(_CreatePseudoConsoleAndPipes(til::unwrap_coord_size(dimensions), flags, &_inPipe, &_outPipe, &_hPC));
+            THROW_IF_FAILED(_CreatePseudoConsoleAndPipes(til::unwrap_coord_size(dimensions), _flags, &_inPipe, &_outPipe, &_hPC));
 
             if (_initialParentHwnd != 0)
             {

src/cascadia/TerminalConnection/ConptyConnection.h

@@ -90,7 +90,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
         til::u8state _u8State{};
         std::wstring _u16Str{};
         std::array<char, 4096> _buffer{};
-        bool _inheritCursor{ false };
+        DWORD _flags{ 0 };
 
         til::env _initialEnv{};
         guid _profileGuid{};