[pull] main from microsoft:main

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

@@ -1,3 +1,4 @@
+aaaaabbb
 aabbcc
 ABANDONFONT
 abbcc
@@ -92,6 +93,8 @@
 backstory
 barbaz
 Bazz
+bbb
+bbccb
 BBDM
 bbwe
 bcount
@@ -790,7 +793,7 @@
 Hostx
 HPA
 hpcon
 HPCON
 hpen
 HPR
 HProvider

src/buffer/out/LineRendition.hpp

@@ -23,21 +23,24 @@ enum class LineRendition : uint8_t
 
 constexpr til::inclusive_rect ScreenToBufferLine(const til::inclusive_rect& line, const LineRendition lineRendition)
 {
-    // Use shift right to quickly divide the Left and Right by 2 for double width lines.
     const auto scale = lineRendition == LineRendition::SingleWidth ? 0 : 1;
     return { line.left >> scale, line.top, line.right >> scale, line.bottom };
 }
 
-constexpr til::point ScreenToBufferLine(const til::point& line, const LineRendition lineRendition)
+constexpr til::point ScreenToBufferLineInclusive(const til::point& line, const LineRendition lineRendition)
 {
-    // Use shift right to quickly divide the Left and Right by 2 for double width lines.
     const auto scale = lineRendition == LineRendition::SingleWidth ? 0 : 1;
     return { line.x >> scale, line.y };
 }
 
+constexpr til::rect BufferToScreenLine(const til::rect& line, const LineRendition lineRendition)
+{
+    const auto scale = lineRendition == LineRendition::SingleWidth ? 0 : 1;
+    return { line.left << scale, line.top, line.right << scale, line.bottom };
+}
+
 constexpr til::inclusive_rect BufferToScreenLine(const til::inclusive_rect& line, const LineRendition lineRendition)
 {
-    // Use shift left to quickly multiply the Left and Right by 2 for double width lines.
     const auto scale = lineRendition == LineRendition::SingleWidth ? 0 : 1;
     return { line.left << scale, line.top, (line.right << scale) + scale, line.bottom };
 }

src/buffer/out/Row.cpp

@@ -349,12 +349,6 @@ void ROW::_init() noexcept
 #pragma warning(push)
 }
 
-void ROW::TransferAttributes(const til::small_rle<TextAttribute, uint16_t, 1>& attr, til::CoordType newWidth)
-{
-    _attr = attr;
-    _attr.resize_trailing_extent(gsl::narrow<uint16_t>(newWidth));
-}
-
 void ROW::CopyFrom(const ROW& source)
 {
     _lineRendition = source._lineRendition;
@@ -366,7 +360,8 @@ void ROW::CopyFrom(const ROW& source)
     };
     CopyTextFrom(state);
 
-    TransferAttributes(source.Attributes(), _columnCount);
+    _attr = source.Attributes();
+    _attr.resize_trailing_extent(_columnCount);
 }
 
 // Returns the previous possible cursor position, preceding the given column.

src/buffer/out/Row.hpp

@@ -132,7 +132,6 @@ class ROW final
     til::CoordType GetReadableColumnCount() const noexcept;
 
     void Reset(const TextAttribute& attr) noexcept;
-    void TransferAttributes(const til::small_rle<TextAttribute, uint16_t, 1>& attr, til::CoordType newWidth);
     void CopyFrom(const ROW& source);
 
     til::CoordType NavigateToPrevious(til::CoordType column) const noexcept;

src/buffer/out/cursor.cpp

@@ -188,11 +188,7 @@ void Cursor::_RedrawCursor() noexcept
 // - <none>
 void Cursor::_RedrawCursorAlways() noexcept
 {
-    try
-    {
-        _parentBuffer.TriggerRedrawCursor(_cPosition);
-    }
-    CATCH_LOG();
+    _parentBuffer.NotifyPaintFrame();
 }
 
 void Cursor::SetPosition(const til::point cPosition) noexcept

src/buffer/out/textBuffer.cpp

@@ -562,14 +562,44 @@ til::point TextBuffer::NavigateCursor(til::point position, til::CoordType distan
 
 // This function is intended for writing regular "lines" of text as it'll set the wrap flag on the given row.
 // You can continue calling the function on the same row as long as state.columnEnd < state.columnLimit.
-void TextBuffer::Write(til::CoordType row, const TextAttribute& attributes, RowWriteState& state)
+void TextBuffer::Replace(til::CoordType row, const TextAttribute& attributes, RowWriteState& state)
 {
     auto& r = GetMutableRowByOffset(row);
     r.ReplaceText(state);
     r.ReplaceAttributes(state.columnBegin, state.columnEnd, attributes);
     TriggerRedraw(Viewport::FromExclusive({ state.columnBeginDirty, row, state.columnEndDirty, row + 1 }));
 }
 
+void TextBuffer::Insert(til::CoordType row, const TextAttribute& attributes, RowWriteState& state)
+{
+    auto& r = GetMutableRowByOffset(row);
+    auto& scratch = GetScratchpadRow();
+
+    scratch.CopyFrom(r);
+
+    r.ReplaceText(state);
+    r.ReplaceAttributes(state.columnBegin, state.columnEnd, attributes);
+
+    // Restore trailing text from our backup in scratch.
+    RowWriteState restoreState{
+        .text = scratch.GetText(state.columnBegin, state.columnLimit),
+        .columnBegin = state.columnEnd,
+        .columnLimit = state.columnLimit,
+    };
+    r.ReplaceText(restoreState);
+
+    // Restore trailing attributes as well.
+    if (const auto copyAmount = restoreState.columnEnd - restoreState.columnBegin; copyAmount > 0)
+    {
+        auto& rowAttr = r.Attributes();
+        const auto& scratchAttr = scratch.Attributes();
+        const auto restoreAttr = scratchAttr.slice(gsl::narrow<uint16_t>(state.columnBegin), gsl::narrow<uint16_t>(state.columnBegin + copyAmount));
+        rowAttr.replace(gsl::narrow<uint16_t>(restoreState.columnBegin), gsl::narrow<uint16_t>(restoreState.columnEnd), restoreAttr);
+    }
+
+    TriggerRedraw(Viewport::FromExclusive({ state.columnBeginDirty, row, restoreState.columnEndDirty, row + 1 }));
+}
+
 // Fills an area of the buffer with a given fill character(s) and attributes.
 void TextBuffer::FillRect(const til::rect& rect, const std::wstring_view& fill, const TextAttribute& attributes)
 {
@@ -1083,11 +1113,8 @@ void TextBuffer::SetCurrentLineRendition(const LineRendition lineRendition, cons
         // And if it's no longer single width, the right half of the row should be erased.
         if (lineRendition != LineRendition::SingleWidth)
         {
-            const auto fillChar = L' ';
             const auto fillOffset = GetLineWidth(rowIndex);
-            const auto fillLength = gsl::narrow<size_t>(GetSize().Width() - fillOffset);
-            const OutputCellIterator fillData{ fillChar, fillAttributes, fillLength };
-            row.WriteCells(fillData, fillOffset, false);
+            FillRect({ fillOffset, rowIndex, til::CoordTypeMax, rowIndex + 1 }, L" ", fillAttributes);
             // We also need to make sure the cursor is clamped within the new width.
             GetCursor().SetPosition(ClampPositionWithinLine(cursorPosition));
         }
@@ -1238,19 +1265,19 @@ Microsoft::Console::Render::Renderer& TextBuffer::GetRenderer() noexcept
     return _renderer;
 }
 
-void TextBuffer::TriggerRedraw(const Viewport& viewport)
+void TextBuffer::NotifyPaintFrame() noexcept
 {
     if (_isActiveBuffer)
     {
-        _renderer.TriggerRedraw(viewport);
+        _renderer.NotifyPaintFrame();
     }
 }
 
-void TextBuffer::TriggerRedrawCursor(const til::point position)
+void TextBuffer::TriggerRedraw(const Viewport& viewport)
 {
     if (_isActiveBuffer)
     {
-        _renderer.TriggerRedrawCursor(&position);
+        _renderer.TriggerRedraw(viewport);
     }
 }
 
@@ -1893,8 +1920,8 @@ std::vector<til::point_span> TextBuffer::GetTextSpans(til::point start, til::poi
         // equivalent buffer offsets, taking line rendition into account.
         if (!bufferCoordinates)
         {
-            higherCoord = ScreenToBufferLine(higherCoord, GetLineRendition(higherCoord.y));
-            lowerCoord = ScreenToBufferLine(lowerCoord, GetLineRendition(lowerCoord.y));
+            higherCoord = ScreenToBufferLineInclusive(higherCoord, GetLineRendition(higherCoord.y));
+            lowerCoord = ScreenToBufferLineInclusive(lowerCoord, GetLineRendition(lowerCoord.y));
         }
 
         til::inclusive_rect asRect = { higherCoord.x, higherCoord.y, lowerCoord.x, lowerCoord.y };
@@ -2005,17 +2032,17 @@ std::tuple<til::CoordType, til::CoordType, bool> TextBuffer::_RowCopyHelper(cons
     if (req.blockSelection)
     {
         const auto lineRendition = row.GetLineRendition();
-        const auto minX = req.bufferCoordinates ? req.minX : ScreenToBufferLine(til::point{ req.minX, iRow }, lineRendition).x;
-        const auto maxX = req.bufferCoordinates ? req.maxX : ScreenToBufferLine(til::point{ req.maxX, iRow }, lineRendition).x;
+        const auto minX = req.bufferCoordinates ? req.minX : ScreenToBufferLineInclusive(til::point{ req.minX, iRow }, lineRendition).x;
+        const auto maxX = req.bufferCoordinates ? req.maxX : ScreenToBufferLineInclusive(til::point{ req.maxX, iRow }, lineRendition).x;
 
         rowBeg = minX;
         rowEnd = maxX + 1; // +1 to get an exclusive end
     }
     else
     {
         const auto lineRendition = row.GetLineRendition();
-        const auto beg = req.bufferCoordinates ? req.beg : ScreenToBufferLine(req.beg, lineRendition);
-        const auto end = req.bufferCoordinates ? req.end : ScreenToBufferLine(req.end, lineRendition);
+        const auto beg = req.bufferCoordinates ? req.beg : ScreenToBufferLineInclusive(req.beg, lineRendition);
+        const auto end = req.bufferCoordinates ? req.end : ScreenToBufferLineInclusive(req.end, lineRendition);
 
         rowBeg = iRow != beg.y ? 0 : beg.x;
         rowEnd = iRow != end.y ? row.GetReadableColumnCount() : end.x + 1; // +1 to get an exclusive end

src/buffer/out/textBuffer.hpp

@@ -107,7 +107,8 @@ class TextBuffer final
     til::point NavigateCursor(til::point position, til::CoordType distance) const;
 
     // Text insertion functions
-    void Write(til::CoordType row, const TextAttribute& attributes, RowWriteState& state);
+    void Replace(til::CoordType row, const TextAttribute& attributes, RowWriteState& state);
+    void Insert(til::CoordType row, const TextAttribute& attributes, RowWriteState& state);
     void FillRect(const til::rect& rect, const std::wstring_view& fill, const TextAttribute& attributes);
 
     OutputCellIterator Write(const OutputCellIterator givenIt);
@@ -168,8 +169,8 @@ class TextBuffer final
 
     Microsoft::Console::Render::Renderer& GetRenderer() noexcept;
 
+    void NotifyPaintFrame() noexcept;
     void TriggerRedraw(const Microsoft::Console::Types::Viewport& viewport);
-    void TriggerRedrawCursor(const til::point position);
     void TriggerRedrawAll();
     void TriggerScroll();
     void TriggerScroll(const til::point delta);

src/buffer/out/ut_textbuffer/UTextAdapterTests.cpp

@@ -41,7 +41,7 @@ class UTextAdapterTests
         RowWriteState state{
             .text = L"abc 𝒶𝒷𝒸 abc ネコちゃん",
         };
-        buffer.Write(0, TextAttribute{}, state);
+        buffer.Replace(0, TextAttribute{}, state);
         VERIFY_IS_TRUE(state.text.empty());
 
         static constexpr auto s = [](til::CoordType beg, til::CoordType end) -> til::point_span {

src/cascadia/TerminalApp/TerminalPage.cpp

@@ -1645,10 +1645,6 @@ namespace winrt::TerminalApp::implementation
     {
         term.RaiseNotice({ this, &TerminalPage::_ControlNoticeRaisedHandler });
 
-        // Add an event handler when the terminal's selection wants to be copied.
-        // When the text buffer data is retrieved, we'll copy the data into the Clipboard
-        term.CopyToClipboard({ this, &TerminalPage::_CopyToClipboardHandler });
-
         // Add an event handler when the terminal wants to paste data from the Clipboard.
         term.PasteFromClipboard({ this, &TerminalPage::_PasteFromClipboardHandler });
 
@@ -2556,54 +2552,6 @@ namespace winrt::TerminalApp::implementation
         return dimension;
     }
 
-    // Method Description:
-    // - Place `copiedData` into the clipboard as text. Triggered when a
-    //   terminal control raises its CopyToClipboard event.
-    // Arguments:
-    // - copiedData: the new string content to place on the clipboard.
-    winrt::fire_and_forget TerminalPage::_CopyToClipboardHandler(const IInspectable /*sender*/,
-                                                                 const CopyToClipboardEventArgs copiedData)
-    {
-        co_await wil::resume_foreground(Dispatcher(), CoreDispatcherPriority::High);
-
-        auto dataPack = DataPackage();
-        dataPack.RequestedOperation(DataPackageOperation::Copy);
-
-        const auto copyFormats = copiedData.Formats() != nullptr ?
-                                     copiedData.Formats().Value() :
-                                     static_cast<CopyFormat>(0);
-
-        // copy text to dataPack
-        dataPack.SetText(copiedData.Text());
-
-        if (WI_IsFlagSet(copyFormats, CopyFormat::HTML))
-        {
-            // copy html to dataPack
-            const auto htmlData = copiedData.Html();
-            if (!htmlData.empty())
-            {
-                dataPack.SetHtmlFormat(htmlData);
-            }
-        }
-
-        if (WI_IsFlagSet(copyFormats, CopyFormat::RTF))
-        {
-            // copy rtf data to dataPack
-            const auto rtfData = copiedData.Rtf();
-            if (!rtfData.empty())
-            {
-                dataPack.SetRtf(rtfData);
-            }
-        }
-
-        try
-        {
-            Clipboard::SetContent(dataPack);
-            Clipboard::Flush();
-        }
-        CATCH_LOG();
-    }
-
     static wil::unique_close_clipboard_call _openClipboard(HWND hwnd)
     {
         bool success = false;

src/cascadia/TerminalApp/TerminalPage.h

@@ -394,7 +394,6 @@ namespace winrt::TerminalApp::implementation
         void _ScrollToBufferEdge(ScrollDirection scrollDirection);
         void _SetAcceleratorForMenuItem(Windows::UI::Xaml::Controls::MenuFlyoutItem& menuItem, const winrt::Microsoft::Terminal::Control::KeyChord& keyChord);
 
-        winrt::fire_and_forget _CopyToClipboardHandler(const IInspectable sender, const winrt::Microsoft::Terminal::Control::CopyToClipboardEventArgs copiedData);
         winrt::fire_and_forget _PasteFromClipboardHandler(const IInspectable sender,
                                                           const Microsoft::Terminal::Control::PasteFromClipboardEventArgs eventArgs);