CVR Manager 1.0.0
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Exterrata
@@ -0,0 +1,453 @@
|
||||
using System.Globalization;
|
||||
using System.Text;
|
||||
using System.Text.RegularExpressions;
|
||||
using Avalonia;
|
||||
using Avalonia.Controls;
|
||||
using Avalonia.Controls.Primitives;
|
||||
using Avalonia.Input;
|
||||
using Avalonia.Input.Platform;
|
||||
using Avalonia.Media;
|
||||
using Avalonia.Threading;
|
||||
|
||||
namespace CVRManager.Views;
|
||||
|
||||
public class LogView : UserControl
|
||||
{
|
||||
public static readonly StyledProperty<string?> TextProperty = AvaloniaProperty.Register<LogView, string?>(nameof(Text));
|
||||
|
||||
readonly ScrollViewer scroll;
|
||||
readonly LogSurface surface = new();
|
||||
|
||||
static LogView() => TextProperty.Changed.AddClassHandler<LogView>((c, _) => c.OnTextChanged());
|
||||
|
||||
public LogView()
|
||||
{
|
||||
scroll = new ScrollViewer
|
||||
{
|
||||
Content = surface,
|
||||
HorizontalScrollBarVisibility = ScrollBarVisibility.Auto,
|
||||
VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
|
||||
};
|
||||
scroll.ScrollChanged += (_, _) => surface.UpdateView(scroll.Offset, scroll.Viewport);
|
||||
Content = new Border
|
||||
{
|
||||
Background = new SolidColorBrush(Color.Parse("#0B0D10")),
|
||||
BorderBrush = new SolidColorBrush(Color.Parse("#232833")),
|
||||
BorderThickness = new Thickness(1),
|
||||
CornerRadius = new CornerRadius(8),
|
||||
ClipToBounds = true,
|
||||
Child = scroll,
|
||||
};
|
||||
}
|
||||
|
||||
public string? Text
|
||||
{
|
||||
get => GetValue(TextProperty);
|
||||
set => SetValue(TextProperty, value);
|
||||
}
|
||||
|
||||
void OnTextChanged()
|
||||
{
|
||||
var atEnd = scroll.Extent.Height <= 0 || scroll.Offset.Y + scroll.Viewport.Height >= scroll.Extent.Height - 24;
|
||||
if (!surface.SetText(Text ?? "")) return;
|
||||
if (atEnd) Dispatcher.UIThread.Post(() => scroll.ScrollToEnd(), DispatcherPriority.Background);
|
||||
}
|
||||
}
|
||||
|
||||
internal sealed class LogSurface : Control
|
||||
{
|
||||
const int MaxLines = 20000;
|
||||
const int KeepLines = 15000;
|
||||
|
||||
static readonly IBrush DefaultBrush = new SolidColorBrush(Color.Parse("#E6E8EC"));
|
||||
static readonly IBrush TimeBrush = new SolidColorBrush(Color.Parse("#6B7585"));
|
||||
static readonly IBrush TagBrush = new SolidColorBrush(Color.Parse("#7AA2FF"));
|
||||
static readonly IBrush ErrorBrush = new SolidColorBrush(Color.Parse("#F0646A"));
|
||||
static readonly IBrush WarnBrush = new SolidColorBrush(Color.Parse("#F5B13D"));
|
||||
static readonly IBrush SelectionBrush = new SolidColorBrush(Color.Parse("#553A5BA8"));
|
||||
|
||||
static readonly Regex TimeRx = new(@"^(\[\d{1,2}:\d{2}:\d{2}(?:[.,]\d+)?\]|\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:[.,]\d+)?)(\s*)(.*)$", RegexOptions.Compiled);
|
||||
static readonly Regex TagRx = new(@"^(\s*(?:\[[^\]]{1,40}\]|\([^)]{1,100}\)))(.*)$", RegexOptions.Compiled);
|
||||
static readonly Regex StackRx = new(@"^\s+at\s", RegexOptions.Compiled);
|
||||
static readonly Regex FileLineRx = new(@"^\(Filename:", RegexOptions.Compiled);
|
||||
static readonly Regex PipeLevelRx = new(@"\|\s*(?<l>error|exception|fatal|warn|warning|info|debug|trace)\s*\)", RegexOptions.Compiled | RegexOptions.IgnoreCase);
|
||||
static readonly Regex BracketLevelRx = new(@"\[(?<l>error|fatal|fail|exception|warn|warning)\]", RegexOptions.Compiled | RegexOptions.IgnoreCase);
|
||||
static readonly Regex LeadingLevelRx = new(@"^\s*(?<l>error|fatal|unhandled exception|exception|failed|failure|warning|warn)\b", RegexOptions.Compiled | RegexOptions.IgnoreCase);
|
||||
static readonly Regex ExceptionRx = new(@"(?:^|\s)(?:[A-Za-z_]\w*\.)*[A-Za-z_]\w*Exception:", RegexOptions.Compiled);
|
||||
|
||||
readonly record struct Seg(string Text, IBrush Brush);
|
||||
|
||||
static readonly Regex AnsiRx = new("\u001b\\[([0-9;]*)m", RegexOptions.Compiled);
|
||||
static readonly Regex OtherEscRx = new("\u001b\\[[0-9;?]*[A-Za-ln-z]", RegexOptions.Compiled);
|
||||
static readonly IBrush[] AnsiNormal = new[] { "#8B93A1", "#F0646A", "#4ADE9B", "#F5B13D", "#7AA2FF", "#C792EA", "#5FD3E0", "#E6E8EC" }
|
||||
.Select(c => (IBrush)new SolidColorBrush(Color.Parse(c))).ToArray();
|
||||
static readonly IBrush[] AnsiBright = new[] { "#A0A8B5", "#FF8087", "#6EF0B5", "#FFD166", "#9AB8FF", "#DDA8FF", "#8FEAF5", "#FFFFFF" }
|
||||
.Select(c => (IBrush)new SolidColorBrush(Color.Parse(c))).ToArray();
|
||||
|
||||
static IBrush Rgb(int r, int g, int b) => new SolidColorBrush(Color.FromRgb((byte)Math.Clamp(r, 0, 255), (byte)Math.Clamp(g, 0, 255), (byte)Math.Clamp(b, 0, 255)));
|
||||
|
||||
static IBrush? ApplySgr(string codes, IBrush? current)
|
||||
{
|
||||
var parts = codes.Length == 0 ? new[] { "0" } : codes.Split(';');
|
||||
for (var i = 0; i < parts.Length; i++)
|
||||
{
|
||||
if (!int.TryParse(parts[i], out var n)) continue;
|
||||
if (n == 0 || n == 39) current = null;
|
||||
else if (n >= 30 && n <= 37) current = AnsiNormal[n - 30];
|
||||
else if (n >= 90 && n <= 97) current = AnsiBright[n - 90];
|
||||
else if (n == 38 && i + 1 < parts.Length)
|
||||
{
|
||||
if (parts[i + 1] == "2" && i + 4 < parts.Length && int.TryParse(parts[i + 2], out var r) && int.TryParse(parts[i + 3], out var g) && int.TryParse(parts[i + 4], out var b))
|
||||
{
|
||||
current = Rgb(r, g, b);
|
||||
i += 4;
|
||||
}
|
||||
else if (parts[i + 1] == "5" && i + 2 < parts.Length && int.TryParse(parts[i + 2], out var idx))
|
||||
{
|
||||
if (idx < 8) current = AnsiNormal[idx];
|
||||
else if (idx < 16) current = AnsiBright[idx - 8];
|
||||
else if (idx < 232)
|
||||
{
|
||||
var c = idx - 16;
|
||||
int Level(int v) => v == 0 ? 0 : 55 + v * 40;
|
||||
current = Rgb(Level(c / 36), Level(c / 6 % 6), Level(c % 6));
|
||||
}
|
||||
else { var v = 8 + (idx - 232) * 10; current = Rgb(v, v, v); }
|
||||
i += 2;
|
||||
}
|
||||
}
|
||||
}
|
||||
return current;
|
||||
}
|
||||
|
||||
static Line ParseAnsi(string raw, IBrush? carried)
|
||||
{
|
||||
raw = OtherEscRx.Replace(raw, "");
|
||||
var segs = new List<Seg>(4);
|
||||
var brush = carried;
|
||||
var pos = 0;
|
||||
foreach (Match m in AnsiRx.Matches(raw))
|
||||
{
|
||||
if (m.Index > pos) segs.Add(new Seg(raw[pos..m.Index], brush ?? DefaultBrush));
|
||||
brush = ApplySgr(m.Groups[1].Value, brush);
|
||||
pos = m.Index + m.Length;
|
||||
}
|
||||
if (pos < raw.Length) segs.Add(new Seg(raw[pos..], brush ?? DefaultBrush));
|
||||
return new Line { Text = string.Concat(segs.Select(s => s.Text)), Segs = segs.ToArray(), AnsiEnd = brush };
|
||||
}
|
||||
|
||||
sealed class Line
|
||||
{
|
||||
public IBrush? AnsiEnd;
|
||||
public string Text = "";
|
||||
public Seg[] Segs = Array.Empty<Seg>();
|
||||
public IBrush? Level;
|
||||
}
|
||||
|
||||
readonly List<Line> lines = new();
|
||||
readonly Dictionary<Line, FormattedText[]> formatted = new();
|
||||
readonly Typeface typeface = new(new FontFamily("Cascadia Mono,Consolas,monospace"));
|
||||
readonly double fontSize = 12;
|
||||
readonly Thickness pad = new(12, 8);
|
||||
readonly double charWidth;
|
||||
readonly double lineHeight;
|
||||
|
||||
string shown = "";
|
||||
int maxCols;
|
||||
Vector offset;
|
||||
Size viewport;
|
||||
(int Line, int Col)? anchor;
|
||||
(int Line, int Col)? caret;
|
||||
bool dragging;
|
||||
|
||||
public LogSurface()
|
||||
{
|
||||
var probe = Format("0000000000", DefaultBrush);
|
||||
charWidth = probe.Width / 10;
|
||||
lineHeight = Math.Ceiling(probe.Height) + 1;
|
||||
Focusable = true;
|
||||
Cursor = new Cursor(StandardCursorType.Ibeam);
|
||||
ClipToBounds = true;
|
||||
}
|
||||
|
||||
FormattedText Format(string text, IBrush brush) =>
|
||||
new(text, CultureInfo.InvariantCulture, FlowDirection.LeftToRight, typeface, fontSize, brush);
|
||||
|
||||
static IBrush? FromWord(string word) => word.ToLowerInvariant() switch
|
||||
{
|
||||
"error" or "fatal" or "fail" or "exception" or "failed" or "failure" or "unhandled exception" => ErrorBrush,
|
||||
"warn" or "warning" => WarnBrush,
|
||||
_ => null,
|
||||
};
|
||||
|
||||
static IBrush? LevelOfLine(string line)
|
||||
{
|
||||
var pipe = PipeLevelRx.Match(line);
|
||||
if (pipe.Success) return FromWord(pipe.Groups["l"].Value);
|
||||
|
||||
var head = line.Length > 160 ? line[..160] : line;
|
||||
var bracket = BracketLevelRx.Match(head);
|
||||
if (bracket.Success) return FromWord(bracket.Groups["l"].Value);
|
||||
|
||||
var message = line;
|
||||
var time = TimeRx.Match(message);
|
||||
if (time.Success) message = time.Groups[3].Value;
|
||||
var tag = TagRx.Match(message);
|
||||
while (tag.Success)
|
||||
{
|
||||
message = tag.Groups[2].Value;
|
||||
tag = TagRx.Match(message);
|
||||
}
|
||||
|
||||
var leading = LeadingLevelRx.Match(message);
|
||||
if (leading.Success) return FromWord(leading.Groups["l"].Value);
|
||||
return ExceptionRx.IsMatch(message) ? ErrorBrush : null;
|
||||
}
|
||||
|
||||
static Line Parse(string text, IBrush? inherited)
|
||||
{
|
||||
var line = new Line { Text = text, Level = inherited };
|
||||
var segs = new List<Seg>(4);
|
||||
if (StackRx.IsMatch(text)) segs.Add(new Seg(text, inherited ?? DefaultBrush));
|
||||
else if (FileLineRx.IsMatch(text)) segs.Add(new Seg(text, TimeBrush));
|
||||
else
|
||||
{
|
||||
var level = LevelOfLine(text);
|
||||
line.Level = level;
|
||||
var rest = text;
|
||||
var time = TimeRx.Match(rest);
|
||||
if (time.Success)
|
||||
{
|
||||
segs.Add(new Seg(time.Groups[1].Value, TimeBrush));
|
||||
if (time.Groups[2].Length > 0) segs.Add(new Seg(time.Groups[2].Value, DefaultBrush));
|
||||
rest = time.Groups[3].Value;
|
||||
}
|
||||
var tag = TagRx.Match(rest);
|
||||
if (tag.Success)
|
||||
{
|
||||
segs.Add(new Seg(tag.Groups[1].Value, level ?? TagBrush));
|
||||
rest = tag.Groups[2].Value;
|
||||
}
|
||||
if (rest.Length > 0) segs.Add(new Seg(rest, level ?? DefaultBrush));
|
||||
}
|
||||
line.Segs = segs.ToArray();
|
||||
return line;
|
||||
}
|
||||
|
||||
void AppendLines(string chunk)
|
||||
{
|
||||
var parts = chunk.Split('\n');
|
||||
var count = parts.Length;
|
||||
if (count > 0 && parts[^1].Length == 0) count--;
|
||||
for (var i = 0; i < count; i++)
|
||||
{
|
||||
var text = parts[i].TrimEnd('\r');
|
||||
var carried = lines.Count > 0 ? lines[^1].AnsiEnd : null;
|
||||
var line = carried != null || text.IndexOf('\u001b') >= 0
|
||||
? ParseAnsi(text, carried)
|
||||
: Parse(text, lines.Count > 0 ? lines[^1].Level : null);
|
||||
text = line.Text;
|
||||
lines.Add(line);
|
||||
if (text.Length > maxCols) maxCols = text.Length;
|
||||
}
|
||||
}
|
||||
|
||||
void TrimHead()
|
||||
{
|
||||
if (lines.Count <= MaxLines) return;
|
||||
var drop = lines.Count - KeepLines;
|
||||
foreach (var l in lines.Take(drop)) formatted.Remove(l);
|
||||
lines.RemoveRange(0, drop);
|
||||
maxCols = lines.Count == 0 ? 0 : lines.Max(l => l.Text.Length);
|
||||
anchor = anchor is { } a ? (Math.Max(0, a.Line - drop), a.Line - drop < 0 ? 0 : a.Col) : null;
|
||||
caret = caret is { } c ? (Math.Max(0, c.Line - drop), c.Line - drop < 0 ? 0 : c.Col) : null;
|
||||
}
|
||||
|
||||
public bool SetText(string text)
|
||||
{
|
||||
if (text == shown) return false;
|
||||
|
||||
string? appended = null;
|
||||
var endsWithNewline = shown.Length == 0 || shown[^1] == '\n';
|
||||
if (shown.Length > 0 && text.StartsWith(shown, StringComparison.Ordinal)) appended = text[shown.Length..];
|
||||
else if (shown.Length > 0)
|
||||
{
|
||||
var key = shown.Length > 400 ? shown[^400..] : shown;
|
||||
var at = text.LastIndexOf(key, StringComparison.Ordinal);
|
||||
if (at >= 0) appended = text[(at + key.Length)..];
|
||||
}
|
||||
|
||||
if (appended == null)
|
||||
{
|
||||
lines.Clear();
|
||||
formatted.Clear();
|
||||
maxCols = 0;
|
||||
anchor = caret = null;
|
||||
AppendLines(text);
|
||||
}
|
||||
else
|
||||
{
|
||||
var partial = "";
|
||||
if (!endsWithNewline && lines.Count > 0)
|
||||
{
|
||||
partial = lines[^1].Text;
|
||||
formatted.Remove(lines[^1]);
|
||||
lines.RemoveAt(lines.Count - 1);
|
||||
}
|
||||
AppendLines(partial + appended);
|
||||
}
|
||||
|
||||
TrimHead();
|
||||
shown = text;
|
||||
InvalidateMeasure();
|
||||
InvalidateVisual();
|
||||
return true;
|
||||
}
|
||||
|
||||
public void UpdateView(Vector newOffset, Size newViewport)
|
||||
{
|
||||
var resized = newViewport != viewport;
|
||||
offset = newOffset;
|
||||
viewport = newViewport;
|
||||
if (resized) InvalidateMeasure();
|
||||
InvalidateVisual();
|
||||
}
|
||||
|
||||
protected override Size MeasureOverride(Size availableSize)
|
||||
{
|
||||
var width = pad.Left + pad.Right + maxCols * charWidth;
|
||||
var height = pad.Top + pad.Bottom + lines.Count * lineHeight;
|
||||
return new Size(Math.Max(width, viewport.Width), Math.Max(height, viewport.Height));
|
||||
}
|
||||
|
||||
public override void Render(DrawingContext context)
|
||||
{
|
||||
context.FillRectangle(Brushes.Transparent, new Rect(Bounds.Size));
|
||||
if (lines.Count == 0) return;
|
||||
|
||||
var first = Math.Max(0, (int)((offset.Y - pad.Top) / lineHeight));
|
||||
var last = Math.Min(lines.Count - 1, (int)((offset.Y + viewport.Height - pad.Top) / lineHeight) + 1);
|
||||
var (selStart, selEnd) = Selection();
|
||||
|
||||
if (formatted.Count > 600) formatted.Clear();
|
||||
for (var i = first; i <= last; i++)
|
||||
{
|
||||
var line = lines[i];
|
||||
var y = pad.Top + i * lineHeight;
|
||||
|
||||
if (selStart is { } s && selEnd is { } e && i >= s.Line && i <= e.Line)
|
||||
{
|
||||
var c0 = i == s.Line ? s.Col : 0;
|
||||
var c1 = i == e.Line ? e.Col : line.Text.Length + 1;
|
||||
if (c1 > c0) context.FillRectangle(SelectionBrush, new Rect(pad.Left + c0 * charWidth, y, (c1 - c0) * charWidth, lineHeight));
|
||||
}
|
||||
|
||||
if (!formatted.TryGetValue(line, out var fts))
|
||||
formatted[line] = fts = line.Segs.Select(sg => Format(sg.Text, sg.Brush)).ToArray();
|
||||
|
||||
var x = pad.Left;
|
||||
for (var k = 0; k < line.Segs.Length; k++)
|
||||
{
|
||||
var width = line.Segs[k].Text.Length * charWidth;
|
||||
if (x + width >= offset.X && x <= offset.X + viewport.Width)
|
||||
context.DrawText(fts[k], new Point(x, y));
|
||||
x += width;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
(int Line, int Col) HitTest(Point p)
|
||||
{
|
||||
if (lines.Count == 0) return (0, 0);
|
||||
var line = Math.Clamp((int)Math.Floor((p.Y - pad.Top) / lineHeight), 0, lines.Count - 1);
|
||||
var col = Math.Clamp((int)Math.Round((p.X - pad.Left) / charWidth), 0, lines[line].Text.Length);
|
||||
return (line, col);
|
||||
}
|
||||
|
||||
((int Line, int Col)? Start, (int Line, int Col)? End) Selection()
|
||||
{
|
||||
if (anchor is not { } a || caret is not { } c || a == c) return (null, null);
|
||||
var forward = a.Line < c.Line || (a.Line == c.Line && a.Col <= c.Col);
|
||||
return forward ? (a, c) : (c, a);
|
||||
}
|
||||
|
||||
protected override void OnPointerPressed(PointerPressedEventArgs e)
|
||||
{
|
||||
base.OnPointerPressed(e);
|
||||
Focus();
|
||||
if (!e.GetCurrentPoint(this).Properties.IsLeftButtonPressed) return;
|
||||
var hit = HitTest(e.GetPosition(this));
|
||||
if (e.ClickCount == 2 && lines.Count > 0)
|
||||
{
|
||||
var text = lines[hit.Line].Text;
|
||||
int start = hit.Col, end = hit.Col;
|
||||
while (start > 0 && !char.IsWhiteSpace(text[start - 1])) start--;
|
||||
while (end < text.Length && !char.IsWhiteSpace(text[end])) end++;
|
||||
anchor = (hit.Line, start);
|
||||
caret = (hit.Line, end);
|
||||
}
|
||||
else if (e.ClickCount >= 3 && lines.Count > 0)
|
||||
{
|
||||
anchor = (hit.Line, 0);
|
||||
caret = (hit.Line, lines[hit.Line].Text.Length);
|
||||
}
|
||||
else
|
||||
{
|
||||
anchor = hit;
|
||||
caret = hit;
|
||||
dragging = true;
|
||||
}
|
||||
e.Pointer.Capture(this);
|
||||
InvalidateVisual();
|
||||
}
|
||||
|
||||
protected override void OnPointerMoved(PointerEventArgs e)
|
||||
{
|
||||
base.OnPointerMoved(e);
|
||||
if (!dragging) return;
|
||||
caret = HitTest(e.GetPosition(this));
|
||||
InvalidateVisual();
|
||||
}
|
||||
|
||||
protected override void OnPointerReleased(PointerReleasedEventArgs e)
|
||||
{
|
||||
base.OnPointerReleased(e);
|
||||
dragging = false;
|
||||
e.Pointer.Capture(null);
|
||||
}
|
||||
|
||||
string SelectedText()
|
||||
{
|
||||
var (start, end) = Selection();
|
||||
if (start is not { } s || end is not { } e) return "";
|
||||
var sb = new StringBuilder();
|
||||
for (var i = s.Line; i <= e.Line && i < lines.Count; i++)
|
||||
{
|
||||
var text = lines[i].Text;
|
||||
var c0 = i == s.Line ? Math.Min(s.Col, text.Length) : 0;
|
||||
var c1 = i == e.Line ? Math.Min(e.Col, text.Length) : text.Length;
|
||||
sb.Append(text, c0, Math.Max(0, c1 - c0));
|
||||
if (i < e.Line) sb.Append('\n');
|
||||
}
|
||||
return sb.ToString();
|
||||
}
|
||||
|
||||
protected override async void OnKeyDown(KeyEventArgs e)
|
||||
{
|
||||
base.OnKeyDown(e);
|
||||
if (!e.KeyModifiers.HasFlag(KeyModifiers.Control)) return;
|
||||
if (e.Key == Key.A && lines.Count > 0)
|
||||
{
|
||||
anchor = (0, 0);
|
||||
caret = (lines.Count - 1, lines[^1].Text.Length);
|
||||
InvalidateVisual();
|
||||
e.Handled = true;
|
||||
}
|
||||
else if (e.Key == Key.C)
|
||||
{
|
||||
var text = SelectedText();
|
||||
if (text.Length > 0 && TopLevel.GetTopLevel(this)?.Clipboard is { } clipboard) await clipboard.SetTextAsync(text);
|
||||
e.Handled = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user