Sicherung

2023-01-20 16:09:00 +01:00
parent e5257d8413
commit b684704bf8
139 changed files with 95678 additions and 499 deletions
--- a/Kalk/Consolus/ConsoleRenderer.cs
+++ b/Kalk/Consolus/ConsoleRenderer.cs
@@ -0,0 +1,217 @@
+using System;
+using System.Collections.Generic;
+
+namespace Consolus
+{
+    public class ConsoleRenderer
+    {
+        private readonly ConsoleTextWriter _consoleWriter;
+        private int _previousDisplayLength;
+        private int _cursorIndex;
+        private int _beforeEditLineSize;
+
+        public ConsoleRenderer()
+        {
+            SupportEscapeSequences = ConsoleHelper.SupportEscapeSequences;
+            _consoleWriter = new ConsoleTextWriter(Console.Out);
+            Prompt = new ConsoleText();
+            EditLine = new ConsoleText();
+            AfterEditLine = new ConsoleText();
+            SelectionIndex = -1;
+            EnableCursorChanged = true;
+        }
+
+        public bool SupportEscapeSequences { get; set; }
+
+        public ConsoleTextWriter ConsoleWriter => _consoleWriter;
+        
+        public int LineTop
+        {
+            get
+            {
+                var currentLine = (_beforeEditLineSize + CursorIndex) / Console.BufferWidth;
+                return Console.CursorTop - currentLine;
+            }
+        }
+
+        public bool IsClean => _previousDisplayLength == 0;
+
+        public bool EnableCursorChanged { get; set; }
+
+        public int CursorIndex
+        {
+            get => _cursorIndex;
+            set
+            {
+                if (value < 0 || value > EditLine.Count) throw new ArgumentOutOfRangeException(nameof(value), $"Value must be >= 0 and <= {EditLine.Count}");
+
+                var lineTop = LineTop;
+                bool changed = _cursorIndex != value;
+                _cursorIndex = value;
+                UpdateCursorPosition(lineTop);
+                if (changed)
+                {
+                    NotifyCursorChanged();
+                }
+            }
+        }
+
+        public Action CursorChanged { get; set; }
+
+        private void NotifyCursorChanged()
+        {
+            var cursorChanged = CursorChanged;
+            if (EnableCursorChanged) CursorChanged?.Invoke();
+        }
+
+        public bool HasSelection => SelectionIndex >= 0 && CursorIndex != SelectionIndex;
+
+        public int SelectionStartIndex => HasSelection ? SelectionIndex < CursorIndex ? SelectionIndex : CursorIndex : -1;
+
+        public int SelectionEndIndex => HasSelection ? SelectionIndex < CursorIndex ? CursorIndex : SelectionIndex : -1;
+
+        public int SelectionIndex { get; private set; }
+        
+        public ConsoleText Prompt { get; }
+
+        public ConsoleText EditLine { get; }
+
+        public ConsoleText AfterEditLine { get; }
+
+        public Action BeforeRender { get; set; }
+
+        public void BeginSelection()
+        {
+            if (SelectionIndex >= 0) return;
+            SelectionIndex = CursorIndex;
+        }
+
+        public void EndSelection()
+        {
+            if (SelectionIndex < 0) return;
+            SelectionIndex = -1;
+            Render();
+        }
+
+        public void RemoveSelection()
+        {
+            if (!HasSelection) return;
+
+            var start = SelectionStartIndex;
+            var count = SelectionEndIndex - start;
+
+            for (int i = 0; i < count; i++)
+            {
+                if (start >= EditLine.Count) break;
+                EditLine.RemoveAt(start);
+            }
+
+            var cursorIndex = start;
+            SelectionIndex = -1;
+            Render(cursorIndex);
+        }
+
+        public void Reset()
+        {
+            AfterEditLine.Clear();
+            EditLine.Clear();
+            _cursorIndex = 0;
+            _beforeEditLineSize = 0;
+            _previousDisplayLength = 0;
+        }
+
+        public void Render(int? newCursorIndex = null, bool reset = false)
+        {
+            // Invoke before rendering to update the highlighting
+            BeforeRender?.Invoke();
+
+            Console.CursorVisible = false;
+            Console.SetCursorPosition(0, LineTop);
+
+            if (SupportEscapeSequences)
+            {
+                ConsoleStyle.Reset.Render(_consoleWriter);
+            }
+            else
+            {
+                Console.ResetColor();
+            }
+
+            Prompt.Render(_consoleWriter);
+
+            EditLine.SelectionStart = SelectionStartIndex;
+            EditLine.SelectionEnd = SelectionEndIndex;
+            EditLine.Render(_consoleWriter, SupportEscapeSequences);
+
+            AfterEditLine.Render(_consoleWriter);
+
+            // Fill remaining space with space
+            var newLength = _consoleWriter.VisibleCharacterCount;
+            var visualLength = newLength;
+            if (newLength < _previousDisplayLength)
+            {
+                if (SupportEscapeSequences)
+                {
+                    ConsoleStyle.Reset.Render(_consoleWriter);
+                }
+
+                for (int i = newLength; i < _previousDisplayLength; i++)
+                {
+                    _consoleWriter.Write(' ');
+                }
+                visualLength = _previousDisplayLength;
+            }
+
+            if (SupportEscapeSequences)
+            {
+                ConsoleStyle.Reset.Render(_consoleWriter);
+            }
+
+            _consoleWriter.Commit();
+
+            if (!SupportEscapeSequences)
+            {
+                Console.ResetColor();
+            }
+
+            _previousDisplayLength = newLength;
+
+            if (!reset)
+            {
+                // Calculate the current line based on the visual
+                var lineTop = Console.CursorTop - (visualLength - 1) / Console.BufferWidth;
+
+                _beforeEditLineSize = EditLine.VisibleCharacterStart;
+                if (newCursorIndex.HasValue)
+                {
+                    bool changed = _cursorIndex != newCursorIndex.Value;
+                    _cursorIndex = newCursorIndex.Value;
+
+                    if (changed)
+                    {
+                        NotifyCursorChanged();
+                    }
+                }
+
+                if (_cursorIndex > EditLine.Count) _cursorIndex = EditLine.Count;
+
+                UpdateCursorPosition(lineTop);
+            }
+            else
+            {
+                Reset();
+            }
+
+            Console.CursorVisible = true;
+        }
+        
+        private void UpdateCursorPosition(int lineTop)
+        {
+            var position = _beforeEditLineSize + _cursorIndex;
+
+            var deltaX = position % Console.BufferWidth;
+            var deltaY = position / Console.BufferWidth;
+            Console.SetCursorPosition(deltaX, lineTop + deltaY);
+        }
+    }
+}