Implement SafeRender() for use under a screen reader

Author: andyleejordan

PSReadLine/BasicEditing.cs

@@ -86,7 +86,7 @@ public static void CancelLine(ConsoleKeyInfo? key = null, object arg = null)
             _singleton._current = _singleton._buffer.Length;
 
             using var _ = _singleton._prediction.DisableScoped();
-            _singleton.ForceRender();
+            _singleton.Render(force: true);
 
             _singleton._console.Write("\x1b[91m^C\x1b[0m");
 
@@ -335,7 +335,7 @@ private bool AcceptLineImpl(bool validate)
 
             if (renderNeeded)
             {
-                ForceRender();
+                Render(force: true);
             }
 
             // Only run validation if we haven't before.  If we have and status line shows an error,

PSReadLine/Options.cs

@@ -189,10 +189,12 @@ private void SetOptionsInternal(SetPSReadLineOption options)
             {
                 Options.ScreenReader = options.ScreenReader;
 
-                // Disable prediction for better accessibility
                 if (Options.ScreenReader)
                 {
+                    // Disable prediction for better accessibility.
                     Options.PredictionSource = PredictionSource.None;
+                    // Disable continuation prompt as multi-line is not available.
+                    Options.ContinuationPrompt = "";
                 }
             }
         }

PSReadLine/Render.Helper.cs

@@ -96,6 +96,7 @@ internal static int LengthInBufferCells(char c)
             if (c < 256)
             {
                 // We render ^C for Ctrl+C, so return 2 for control characters
+                // TODO: Do we care about this under a screen reader?
                 return Char.IsControl(c) ? 2 : 1;
             }
 

PSReadLine/Render.cs

@@ -218,11 +218,11 @@ private void RenderWithPredictionQueryPaused()
             Render();
         }
 
-        private void Render()
+        private void Render(bool force = false)
         {
             // If there are a bunch of keys queued up, skip rendering if we've rendered very recently.
             long elapsedMs = _lastRenderTime.ElapsedMilliseconds;
-            if (_queuedKeys.Count > 10 && elapsedMs < 50)
+            if (!force && _queuedKeys.Count > 10 && elapsedMs < 50)
             {
                 // We won't render, but most likely the tokens will be different, so make
                 // sure we don't use old tokens, also allow garbage to get collected.
@@ -242,12 +242,142 @@ private void Render()
             // See the following 2 GitHub issues for more context:
             //  - https://github.com/PowerShell/PSReadLine/issues/3879#issuecomment-2573996070
             //  - https://github.com/PowerShell/PowerShell/issues/24696
-            if (elapsedMs < 50)
+            if (!force && elapsedMs < 50)
             {
                 _handlePotentialResizing = false;
             }
 
-            ForceRender();
+            // Use simplified rendering for screen readers
+            if (Options.ScreenReader)
+            {
+                SafeRender();
+            }
+            else
+            {
+                ForceRender();
+            }
+        }
+
+        private Point CalculateNextInputPoint(int _current)
+        {
+            var point = ConvertOffsetToPoint(_current);
+
+            if (point.Y == _console.BufferHeight)
+            {
+                // The cursor top exceeds the buffer height, so we need to
+                // scroll up the buffer by 1 line.
+                _console.Write("\n");
+
+                // Adjust the initial cursor position and the to-be-set cursor position
+                // after scrolling up the buffer.
+                _initialY -= 1;
+                point.Y -= 1;
+            }
+            else if (point.Y < 0)
+            {
+                // This could happen in at least 3 cases:
+                //
+                //   1. when you are adding characters to the first line in the buffer (top = 0) to make the logical line
+                //      wrap to one extra physical line. This would cause the buffer to scroll up and push the line being
+                //      edited up-off the buffer.
+                //   2. when you are deleting characters (Backspace) from the first line in the buffer without changing the
+                //      number of physical lines (either editing the same logical line or causing the current logical line
+                //      to merge in the previous but still span to the current physical line). The cursor is supposed to
+                //      appear in the previous line (which is off the buffer).
+                //   3. Both 'bck-i-search' and 'fwd-i-search' may find a history command with multi-line text, and the
+                //      matching string in the text, where the cursor is supposed to be moved to, will be scrolled up-off
+                //      the buffer after rendering.
+                //
+                // In these case, we move the cursor to the left-most position of the first line, where it's closest to
+                // the real position it should be in the ideal world.
+
+                // First update '_current' to the index of the first character that appears on the line 0,
+                // then we call 'ConvertOffsetToPoint' again to get the right cursor position to use.
+                point.X = point.Y = 0;
+                _current = ConvertLineAndColumnToOffset(point);
+                point = ConvertOffsetToPoint(_current);
+            }
+
+            return point;
+        }
+        
+        private void SafeRender()
+        {
+            static int FindCommonPrefixLength(string leftStr, string rightStr)
+            {
+                if (string.IsNullOrEmpty(leftStr) || string.IsNullOrEmpty(rightStr))
+                {
+                    return 0;
+                }
+
+                int i = 0;
+                int minLength = Math.Min(leftStr.Length, rightStr.Length);
+
+                while (i < minLength && leftStr[i] == rightStr[i])
+                {
+                    i++;
+                }
+
+                return i;
+            }
+
+            // For screen readers, we don't need complex tokenization or coloring.
+            // Just compare the raw buffer content and output differences.
+            // (Though we do have to adjust the cursor aftewards.)
+            string currentBuffer = _buffer.ToString(); // Just like GenerateRender().
+            string previousBuffer = _previousRender.lines[0].Line;
+
+            // In case the buffer was resized.
+            RecomputeInitialCoords(isTextBufferUnchanged: false);
+
+            // Make cursor invisible while we're rendering.
+            _console.CursorVisible = false;
+
+            // Calculate what to render and where to start the rendering.
+            int commonPrefixLength = FindCommonPrefixLength(previousBuffer, currentBuffer);
+
+            if (commonPrefixLength > 0 && commonPrefixLength == previousBuffer.Length)
+            {
+                // Previous buffer is a complete prefix of current buffer.
+                // Just append the new data.
+                var appendedData = currentBuffer.Substring(commonPrefixLength);
+                _console.Write(appendedData);
+            }
+            else if (commonPrefixLength > 0)
+            {
+                // Buffers share a common prefix but previous buffer has additional content.
+                // Move cursor to where the difference starts, clear forward, and write the data.
+                var diffPoint = ConvertOffsetToPoint(commonPrefixLength);
+                _console.SetCursorPosition(diffPoint.X, diffPoint.Y);
+                var changedData = currentBuffer.Substring(commonPrefixLength);
+                _console.Write("\x1b[0J");
+                _console.Write(changedData);
+            }
+            else
+            {
+                // No common prefix, rewrite entire buffer.
+                _console.SetCursorPosition(_initialX, _initialY);
+                _console.Write("\x1b[0J");
+                _console.Write(currentBuffer);
+            }
+
+            // Preserve the current render data.
+            var renderData = new RenderData
+            {
+                lines = new RenderedLineData[] { new(currentBuffer, isFirstLogicalLine: true) }
+            };
+            _previousRender = renderData;
+
+            // Calculate the coord to place the cursor for the next input.
+            var point = CalculateNextInputPoint(_current);
+            _console.SetCursorPosition(point.X, point.Y);
+            _console.CursorVisible = true;
+
+            renderData.UpdateConsoleInfo(_console.BufferWidth, _console.BufferHeight, point.X, point.Y);
+            renderData.initialY = _initialY;
+
+            _lastRenderTime.Restart();
+            _waitingToRender = false;
         }
 
         private void ForceRender()
@@ -261,7 +391,7 @@ private void ForceRender()
             // and minimize writing more than necessary on the next render.)
 
             var renderLines = new RenderedLineData[logicalLineCount];
-            var renderData = new RenderData {lines = renderLines};
+            var renderData = new RenderData { lines = renderLines };
             for (var i = 0; i < logicalLineCount; i++)
             {
                 var line = _consoleBufferLines[i].ToString();
@@ -909,44 +1039,7 @@ void UpdateColorsIfNecessary(string newColor)
             }
 
             // Calculate the coord to place the cursor for the next input.
-            var point = ConvertOffsetToPoint(_current);
-
-            if (point.Y == bufferHeight)
-            {
-                // The cursor top exceeds the buffer height, so we need to
-                // scroll up the buffer by 1 line.
-                _console.Write("\n");
-
-                // Adjust the initial cursor position and the to-be-set cursor position
-                // after scrolling up the buffer.
-                _initialY -= 1;
-                point.Y -= 1;
-            }
-            else if (point.Y < 0)
-            {
-                // This could happen in at least 3 cases:
-                //
-                //   1. when you are adding characters to the first line in the buffer (top = 0) to make the logical line
-                //      wrap to one extra physical line. This would cause the buffer to scroll up and push the line being
-                //      edited up-off the buffer.
-                //   2. when you are deleting characters (Backspace) from the first line in the buffer without changing the
-                //      number of physical lines (either editing the same logical line or causing the current logical line
-                //      to merge in the previous but still span to the current physical line). The cursor is supposed to
-                //      appear in the previous line (which is off the buffer).
-                //   3. Both 'bck-i-search' and 'fwd-i-search' may find a history command with multi-line text, and the
-                //      matching string in the text, where the cursor is supposed to be moved to, will be scrolled up-off
-                //      the buffer after rendering.
-                //
-                // In these case, we move the cursor to the left-most position of the first line, where it's closest to
-                // the real position it should be in the ideal world.
-
-                // First update '_current' to the index of the first character that appears on the line 0,
-                // then we call 'ConvertOffsetToPoint' again to get the right cursor position to use.
-                point.X = point.Y = 0;
-                _current = ConvertLineAndColumnToOffset(point);
-                point = ConvertOffsetToPoint(_current);
-            }
-
+            var point = CalculateNextInputPoint(_current);
             _console.SetCursorPosition(point.X, point.Y);
             _console.CursorVisible = true;
 
@@ -1178,8 +1271,11 @@ private void MoveCursor(int newCursor)
                     // to issuing a newline to scroll the buffer.
                     _console.SetCursorPosition(point.X, point.Y);
 
-                    // Scroll up the buffer by 1 line.
-                    _console.Write("\n");
+                    // Scroll up the buffer by 1 line, except under a screen reader which naturally wraps.
+                    if (!Options.ScreenReader)
+                    {
+                        _console.Write("\n");
+                    }
                 }
                 else
                 {
@@ -1827,6 +1923,6 @@ public static void ScrollDisplayToCursor(ConsoleKeyInfo? key = null, object arg
                 newTop = (console.BufferHeight - console.WindowHeight);
             }
             console.SetWindowPosition(0, newTop);
-        }
+        }        
     }
 }