Move all blink handling into Renderer

Author: lhecker

src/buffer/out/cursor.cpp

@@ -13,18 +13,7 @@
 // - ulSize - The height of the cursor within this buffer
 Cursor::Cursor(const ULONG ulSize, TextBuffer& parentBuffer) noexcept :
     _parentBuffer{ parentBuffer },
-    _fHasMoved(false),
-    _fIsVisible(true),
-    _fIsOn(true),
-    _fIsDouble(false),
-    _fBlinkingAllowed(true),
-    _fDelay(false),
-    _fIsConversionArea(false),
-    _fDelayedEolWrap(false),
-    _fDeferCursorRedraw(false),
-    _fHaveDeferredCursorRedraw(false),
-    _ulSize(ulSize),
-    _cursorType(CursorType::Legacy)
+    _ulSize(ulSize)
 {
 }
 
@@ -35,203 +24,145 @@ til::point Cursor::GetPosition() const noexcept
     return _cPosition;
 }
 
-bool Cursor::HasMoved() const noexcept
+uint64_t Cursor::GetLastMutationId() const noexcept
 {
-    return _fHasMoved;
+    return _mutationId;
 }
 
 bool Cursor::IsVisible() const noexcept
 {
-    return _fIsVisible;
+    return _isVisible;
 }
 
-bool Cursor::IsOn() const noexcept
+bool Cursor::IsBlinking() const noexcept
 {
-    return _fIsOn;
-}
-
-bool Cursor::IsBlinkingAllowed() const noexcept
-{
-    return _fBlinkingAllowed;
+    return _isBlinking;
 }
 
 bool Cursor::IsDouble() const noexcept
 {
     return _fIsDouble;
 }
 
-bool Cursor::IsConversionArea() const noexcept
-{
-    return _fIsConversionArea;
-}
-
-bool Cursor::GetDelay() const noexcept
-{
-    return _fDelay;
-}
-
 ULONG Cursor::GetSize() const noexcept
 {
     return _ulSize;
 }
 
-void Cursor::SetHasMoved(const bool fHasMoved) noexcept
-{
-    _fHasMoved = fHasMoved;
-}
-
-void Cursor::SetIsVisible(const bool fIsVisible) noexcept
-{
-    _fIsVisible = fIsVisible;
-    _RedrawCursor();
-}
-
-void Cursor::SetIsOn(const bool fIsOn) noexcept
+void Cursor::SetIsVisible(bool enable)
 {
-    _fIsOn = fIsOn;
-    _RedrawCursorAlways();
+    if (_isVisible != enable)
+    {
+        _isVisible = enable;
+        _redrawIfVisible();
+    }
 }
 
-void Cursor::SetBlinkingAllowed(const bool fBlinkingAllowed) noexcept
+void Cursor::SetIsBlinking(bool enable)
 {
-    _fBlinkingAllowed = fBlinkingAllowed;
-    // GH#2642 - From what we've gathered from other terminals, when blinking is
-    // disabled, the cursor should remain On always, and have the visibility
-    // controlled by the IsVisible property. So when you do a printf "\e[?12l"
-    // to disable blinking, the cursor stays stuck On. At this point, only the
-    // cursor visibility property controls whether the user can see it or not.
-    // (Yes, the cursor can be On and NOT Visible)
-    _fIsOn = true;
-    _RedrawCursorAlways();
+    if (_isBlinking != enable)
+    {
+        _isBlinking = enable;
+        _redrawIfVisible();
+    }
 }
 
 void Cursor::SetIsDouble(const bool fIsDouble) noexcept
 {
-    _fIsDouble = fIsDouble;
-    _RedrawCursor();
-}
-
-void Cursor::SetIsConversionArea(const bool fIsConversionArea) noexcept
-{
-    // Functionally the same as "Hide cursor"
-    // Never called with TRUE, it's only used in the creation of a
-    //      ConversionAreaInfo, and never changed after that.
-    _fIsConversionArea = fIsConversionArea;
-    _RedrawCursorAlways();
-}
-
-void Cursor::SetDelay(const bool fDelay) noexcept
-{
-    _fDelay = fDelay;
+    if (_fIsDouble != fIsDouble)
+    {
+        _fIsDouble = fIsDouble;
+        _redrawIfVisible();
+    }
 }
 
 void Cursor::SetSize(const ULONG ulSize) noexcept
 {
-    _ulSize = ulSize;
-    _RedrawCursor();
+    if (_ulSize != ulSize)
+    {
+        _ulSize = ulSize;
+        _redrawIfVisible();
+    }
 }
 
 void Cursor::SetStyle(const ULONG ulSize, const CursorType type) noexcept
 {
-    _ulSize = ulSize;
-    _cursorType = type;
-
-    _RedrawCursor();
-}
-
-// Routine Description:
-// - Sends a redraw message to the renderer only if the cursor is currently on.
-// - NOTE: For use with most methods in this class.
-// Arguments:
-// - <none>
-// Return Value:
-// - <none>
-void Cursor::_RedrawCursor() noexcept
-{
-    // Only trigger the redraw if we're on.
-    // Don't draw the cursor if this was triggered from a conversion area.
-    // (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 (_ulSize != ulSize || _cursorType != type)
     {
-        if (_fDeferCursorRedraw)
-        {
-            _fHaveDeferredCursorRedraw = true;
-        }
-        else
-        {
-            _RedrawCursorAlways();
-        }
+        _ulSize = ulSize;
+        _cursorType = type;
+        _redrawIfVisible();
     }
 }
 
-// Routine Description:
-// - Sends a redraw message to the renderer no matter what.
-// - NOTE: For use with the method that turns the cursor on and off to force a refresh
-//         and clear the ON cursor from the screen. Not for use with other methods.
-//         They should use the other method so refreshes are suppressed while the cursor is off.
-// Arguments:
-// - <none>
-// Return Value:
-// - <none>
-void Cursor::_RedrawCursorAlways() noexcept
-{
-    _parentBuffer.NotifyPaintFrame();
-}
-
 void Cursor::SetPosition(const til::point cPosition) noexcept
 {
-    _RedrawCursor();
-    _cPosition = cPosition;
-    _RedrawCursor();
-    ResetDelayEOLWrap();
+    if (_cPosition != cPosition)
+    {
+        _cPosition = cPosition;
+        ResetDelayEOLWrap();
+        _redrawIfVisible();
+    }
 }
 
 void Cursor::SetXPosition(const til::CoordType NewX) noexcept
 {
-    _RedrawCursor();
-    _cPosition.x = NewX;
-    _RedrawCursor();
-    ResetDelayEOLWrap();
+    if (_cPosition.x != NewX)
+    {
+        _cPosition.x = NewX;
+        ResetDelayEOLWrap();
+        _redrawIfVisible();
+    }
 }
 
 void Cursor::SetYPosition(const til::CoordType NewY) noexcept
 {
-    _RedrawCursor();
-    _cPosition.y = NewY;
-    _RedrawCursor();
-    ResetDelayEOLWrap();
+    if (_cPosition.y != NewY)
+    {
+        _cPosition.y = NewY;
+        ResetDelayEOLWrap();
+        _redrawIfVisible();
+    }
 }
 
 void Cursor::IncrementXPosition(const til::CoordType DeltaX) noexcept
 {
-    _RedrawCursor();
-    _cPosition.x += DeltaX;
-    _RedrawCursor();
-    ResetDelayEOLWrap();
+    if (DeltaX != 0)
+    {
+        _cPosition.x = _cPosition.x + DeltaX;
+        ResetDelayEOLWrap();
+        _redrawIfVisible();
+    }
 }
 
 void Cursor::IncrementYPosition(const til::CoordType DeltaY) noexcept
 {
-    _RedrawCursor();
-    _cPosition.y += DeltaY;
-    _RedrawCursor();
-    ResetDelayEOLWrap();
+    if (DeltaY != 0)
+    {
+        _cPosition.y = _cPosition.y + DeltaY;
+        ResetDelayEOLWrap();
+        _redrawIfVisible();
+    }
 }
 
 void Cursor::DecrementXPosition(const til::CoordType DeltaX) noexcept
 {
-    _RedrawCursor();
-    _cPosition.x -= DeltaX;
-    _RedrawCursor();
-    ResetDelayEOLWrap();
+    if (DeltaX != 0)
+    {
+        _cPosition.x = _cPosition.x - DeltaX;
+        ResetDelayEOLWrap();
+        _redrawIfVisible();
+    }
 }
 
 void Cursor::DecrementYPosition(const til::CoordType DeltaY) noexcept
 {
-    _RedrawCursor();
-    _cPosition.y -= DeltaY;
-    _RedrawCursor();
-    ResetDelayEOLWrap();
+    if (DeltaY != 0)
+    {
+        _cPosition.y = _cPosition.y - DeltaY;
+        ResetDelayEOLWrap();
+        _redrawIfVisible();
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -244,79 +175,53 @@ void Cursor::DecrementYPosition(const til::CoordType DeltaY) noexcept
 // - OtherCursor - The cursor to copy properties from
 // Return Value:
 // - <none>
-void Cursor::CopyProperties(const Cursor& OtherCursor) noexcept
+void Cursor::CopyProperties(const Cursor& other) noexcept
 {
-    // We shouldn't copy the position as it will be already rearranged by the resize operation.
-    //_cPosition                    = pOtherCursor->_cPosition;
-
-    _fHasMoved = OtherCursor._fHasMoved;
-    _fIsVisible = OtherCursor._fIsVisible;
-    _fIsOn = OtherCursor._fIsOn;
-    _fIsDouble = OtherCursor._fIsDouble;
-    _fBlinkingAllowed = OtherCursor._fBlinkingAllowed;
-    _fDelay = OtherCursor._fDelay;
-    _fIsConversionArea = OtherCursor._fIsConversionArea;
-
-    // A resize operation should invalidate the delayed end of line status, so do not copy.
-    //_fDelayedEolWrap              = OtherCursor._fDelayedEolWrap;
-    //_coordDelayedAt               = OtherCursor._coordDelayedAt;
-
-    _fDeferCursorRedraw = OtherCursor._fDeferCursorRedraw;
-    _fHaveDeferredCursorRedraw = OtherCursor._fHaveDeferredCursorRedraw;
-
-    // Size will be handled separately in the resize operation.
-    //_ulSize                       = OtherCursor._ulSize;
-    _cursorType = OtherCursor._cursorType;
+    _cPosition = other._cPosition;
+    _coordDelayedAt = other._coordDelayedAt;
+    _ulSize = other._ulSize;
+    _cursorType = other._cursorType;
+    _isVisible = other._isVisible;
+    _isBlinking = other._isBlinking;
+    _fIsDouble = other._fIsDouble;
 }
 
 void Cursor::DelayEOLWrap() noexcept
 {
     _coordDelayedAt = _cPosition;
-    _fDelayedEolWrap = true;
 }
 
 void Cursor::ResetDelayEOLWrap() noexcept
 {
-    _coordDelayedAt = {};
-    _fDelayedEolWrap = false;
+    _coordDelayedAt.reset();
 }
 
-til::point Cursor::GetDelayedAtPosition() const noexcept
+const std::optional<til::point>& Cursor::GetDelayEOLWrap() const noexcept
 {
     return _coordDelayedAt;
 }
 
-bool Cursor::IsDelayedEOLWrap() const noexcept
+CursorType Cursor::GetType() const noexcept
 {
-    return _fDelayedEolWrap;
-}
-
-void Cursor::StartDeferDrawing() noexcept
-{
-    _fDeferCursorRedraw = true;
+    return _cursorType;
 }
 
-bool Cursor::IsDeferDrawing() noexcept
+void Cursor::SetType(const CursorType type) noexcept
 {
-    return _fDeferCursorRedraw;
+    _cursorType = type;
 }
 
-void Cursor::EndDeferDrawing() noexcept
+void Cursor::_redrawIfVisible() noexcept
 {
-    if (_fHaveDeferredCursorRedraw)
+    _mutationId++;
+    if (IsVisible())
     {
-        _RedrawCursorAlways();
+        _parentBuffer.NotifyPaintFrame();
     }
-
-    _fDeferCursorRedraw = FALSE;
-}
-
-const CursorType Cursor::GetType() const noexcept
-{
-    return _cursorType;
 }
 
-void Cursor::SetType(const CursorType type) noexcept
+void Cursor::_redraw() noexcept
 {
-    _cursorType = type;
+    _mutationId++;
+    _parentBuffer.NotifyPaintFrame();
 }