Exterrata
454 lines
17 KiB
C#
454 lines
17 KiB
C#
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;
|
|
}
|
|
}
|
|
}
|