mAYBE

src/buffer/out/cursor.cpp

@@ -29,7 +29,8 @@ Cursor::Cursor(const ULONG ulSize, TextBuffer& parentBuffer) noexcept :
     _ulSize(ulSize),
     _cursorType(CursorType::Legacy),
     _fUseColor(false),
-    _color(s_InvertCursorColor)
+    _color(s_InvertCursorColor),
+    _iDeferCounter{ 0 }
 {
 }
 
@@ -166,7 +167,7 @@ void Cursor::_RedrawCursor() noexcept
     // (Conversion areas have cursors to mark the insertion point internally, but the user's actual cursor is the one on the primary screen buffer.)
     if (IsOn() && !IsConversionArea())
     {
-        if (_fDeferCursorRedraw)
+        if (_iDeferCounter > 0)
         {
             _fHaveDeferredCursorRedraw = true;
         }
@@ -281,6 +282,7 @@ void Cursor::CopyProperties(const Cursor& OtherCursor) noexcept
 
     _fDeferCursorRedraw = OtherCursor._fDeferCursorRedraw;
     _fHaveDeferredCursorRedraw = OtherCursor._fHaveDeferredCursorRedraw;
+    _iDeferCounter = OtherCursor._iDeferCounter;
 
     // Size will be handled separately in the resize operation.
     //_ulSize                       = OtherCursor._ulSize;
@@ -312,17 +314,22 @@ bool Cursor::IsDelayedEOLWrap() const noexcept
 
 void Cursor::StartDeferDrawing() noexcept
 {
-    _fDeferCursorRedraw = true;
+    ++_iDeferCounter;
 }
 
 void Cursor::EndDeferDrawing() noexcept
 {
-    if (_fHaveDeferredCursorRedraw)
+    // Nobody has started a defer drawing.
+    if (_iDeferCounter == 0)
     {
-        _RedrawCursorAlways();
+        return;
     }
 
-    _fDeferCursorRedraw = FALSE;
+    --_iDeferCounter;
+    if (_iDeferCounter == 0)
+    {
+        _RedrawCursorAlways();
+    }
 }
 
 const CursorType Cursor::GetType() const noexcept

src/buffer/out/cursor.h

@@ -107,6 +107,7 @@ class Cursor final
     bool _fDelayedEolWrap; // don't wrap at EOL till the next char comes in.
     COORD _coordDelayedAt; // coordinate the EOL wrap was delayed at.
 
+    int _iDeferCounter;
     bool _fDeferCursorRedraw; // whether we should defer redrawing the cursor or not
     bool _fHaveDeferredCursorRedraw; // have we been asked to redraw the cursor while it was being deferred?
 

src/cascadia/TerminalCore/Terminal.cpp

@@ -166,11 +166,6 @@ void Terminal::UpdateSettings(winrt::Microsoft::Terminal::Settings::ICoreSetting
 {
     const auto oldDimensions = _mutableViewport.Dimensions();
 
-    if (!_buffer->GetSize().IsInBounds(_buffer->GetCursor().GetPosition()))
-    {
-        OutputDebugString(L"UserResize not in bounds\n");
-    }   
-
     if (viewportSize == oldDimensions)
     {
         return S_FALSE;
@@ -196,6 +191,23 @@ void Terminal::UpdateSettings(winrt::Microsoft::Terminal::Settings::ICoreSetting
     // bottom in the new buffer as well. Track that case now.
     const bool originalOffsetWasZero = _scrollOffset == 0;
 
+    // Defer the cursor drawing here right before the Reflow call
+    // because we only want the renderer to redraw the cursor right
+    // after we swap out the old buffer with the new buffer from Reflow.
+    // This swap happens down below, and so we'll EndDeferDrawing right
+    // after the swap.
+    // What would happen is that at the end of Reflow, we would call
+    // EndDeferDrawing, causing the renderer to go and attempt to redraw
+    // the cursor. However there's a race condition where, sometimes it
+    // would check for the _buffer properties before we swap out the
+    // buffer with the new one. This would make it crash if the old
+    // buffer's cursor position was out of bounds.
+    // Now that StartDeferDrawing uses a counter and will only redraw
+    // when the counter reaches 0, this StartDeferDrawing call here will
+    // force the renderer to redraw at least until this particular
+    // deferral is met with its corresponding EndDeferral down below.
+    _buffer->GetCursor().StartDeferDrawing();
+
     // First allocate a new text buffer to take the place of the current one.
     std::unique_ptr<TextBuffer> newTextBuffer;
     try
@@ -335,6 +347,8 @@ void Terminal::UpdateSettings(winrt::Microsoft::Terminal::Settings::ICoreSetting
 
     _buffer.swap(newTextBuffer);
 
+    _buffer->GetCursor().EndDeferDrawing();
+
     // GH#3494: Maintain scrollbar position during resize
     // Make sure that we don't scroll past the mutableViewport at the bottom of the buffer
     newVisibleTop = std::min(newVisibleTop, _mutableViewport.Top());
@@ -716,11 +730,6 @@ void Terminal::_WriteBuffer(const std::wstring_view& stringView)
             // -> Increment "i" by 1 in that case and thus by 2 in total in this iteration.
             proposedCursorPosition.X += gsl::narrow<SHORT>(cellDistance);
 
-            if (!_buffer->GetSize().IsInBounds(proposedCursorPosition))
-            {
-                OutputDebugString(L"InDist > 0 not in Bounds\n");
-            }
-
             i += inputDistance - 1;
         }
         else
@@ -737,8 +746,6 @@ void Terminal::_WriteBuffer(const std::wstring_view& stringView)
             // Try the character again.
             i--;
 
-            OutputDebugString(L"Reset to 0\n");
-
             // If we write the last cell of the row here, TextBuffer::Write will
             // mark this line as wrapped for us. If the next character we
             // process is a newline, the Terminal::CursorLineFeed will unmark
@@ -753,11 +760,6 @@ void Terminal::_WriteBuffer(const std::wstring_view& stringView)
         _AdjustCursorPosition(proposedCursorPosition);
     }
 
-    if (!_buffer->GetSize().IsInBounds(_buffer->GetCursor().GetPosition()))
-    {
-        OutputDebugString(L"Still not in Bounds\n");
-    }
-
     cursor.EndDeferDrawing();
 }
 

src/renderer/base/renderer.cpp

@@ -236,6 +236,13 @@ void Renderer::TriggerRedrawCursor(const COORD* const pcoord)
         {
             LOG_IF_FAILED(pEngine->InvalidateCursor(&updateCoord));
 
+            if (!_pData->GetTextBuffer().GetSize().IsInBounds(_pData->GetTextBuffer().GetCursor().GetPosition()))
+            {
+                char buf[2000];
+                sprintf_s(buf, "TriggerRedraw: bufferX: %d, cursorpos: %d, updateCoord: %d\n", gsl::narrow_cast<int>(_pData->GetTextBuffer().GetSize().RightExclusive()), gsl::narrow_cast<int>(_pData->GetTextBuffer().GetCursor().GetPosition().X), updateCoord.X);
+                OutputDebugStringA(buf);
+            }
+
             // Double-wide cursors need to invalidate the right half as well.
             if (_pData->IsCursorDoubleWidth())
             {
@@ -832,10 +839,6 @@ void Renderer::_PaintCursor(_In_ IRenderEngine* const pEngine)
             // Draw it within the viewport
             LOG_IF_FAILED(pEngine->PaintCursor(options));
         }
-        else
-        {
-            OutputDebugString(L"PaintCursor NOT In Bounds \n");
-        }
     }
 }