aboutsummaryrefslogtreecommitdiffstatsci
path: root/Samples/DebugLogViewer/src
diff options
context:
space:
mode:
Diffstat (limited to 'Samples/DebugLogViewer/src')
-rw-r--r--Samples/DebugLogViewer/src/DbgEventWidget.cs161
-rw-r--r--Samples/DebugLogViewer/src/DbgLogViewer.cs800
-rw-r--r--Samples/DebugLogViewer/src/main.cs281
3 files changed, 1242 insertions, 0 deletions
diff --git a/Samples/DebugLogViewer/src/DbgEventWidget.cs b/Samples/DebugLogViewer/src/DbgEventWidget.cs
new file mode 100644
index 00000000..570cc2f9
--- /dev/null
+++ b/Samples/DebugLogViewer/src/DbgEventWidget.cs
@@ -0,0 +1,161 @@
+// Copyright (c) 2025 Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
+//
+// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using Drawing2D;
+using Crow.DebugLogger;
+
+namespace Crow
+{
+ public class DbgEventView : TemplatedContainer {
+ DbgEvent evt;
+ public DbgEvent Event {
+ get => evt;
+ set {
+ if (evt == value)
+ return;
+ evt = value;
+ NotifyValueChangedAuto (evt);
+ }
+ }
+ }
+ public class DbgEventWidget : Widget
+ {
+ public DbgEventWidget (){}
+
+ DbgEvent evt, hoverEvt;
+ long ticksPerPixel;
+ double pixelPerTick;
+
+ object dataMutex = new object();
+
+ public DbgEvent Event {
+ get => evt;
+ set {
+ if (evt == value)
+ return;
+ lock (dataMutex)
+ evt = value;
+ updatePixelPerTicks ();
+ NotifyValueChangedAuto (evt);
+ RegisterForRedraw ();
+ }
+ }
+ public DbgEvent HoverEvent {
+ get => hoverEvt;
+ private set {
+ if (hoverEvt == value)
+ return;
+ lock (dataMutex)
+ evt = value;
+ hoverEvt = value;
+ NotifyValueChangedAuto (hoverEvt);
+ }
+ }
+
+ [DefaultValue ("1000")]
+ public long TicksPerPixel {
+ get => ticksPerPixel;
+ set {
+ if (ticksPerPixel == value)
+ return;
+ ticksPerPixel = value;
+ NotifyValueChangedAuto (ticksPerPixel);
+ if (Width == Measure.Fit)
+ RegisterForLayouting (LayoutingType.Width);
+ }
+ }
+
+ public override int measureRawSize (LayoutingType lt)
+ {
+ updatePixelPerTicks ();
+ if (lt == LayoutingType.Width)
+ contentSize.Width = Event == null ? 0 : (int)Math.Max(pixelPerTick * Event.Duration, 2);
+
+ return base.measureRawSize (lt);
+ }
+
+ public override void OnLayoutChanges (LayoutingType layoutType)
+ {
+ if (layoutType == LayoutingType.Width)
+ updatePixelPerTicks ();
+
+ base.OnLayoutChanges (layoutType);
+ }
+
+ protected override void onDraw (IContext gr)
+ {
+ lock (dataMutex) {
+
+ if (Event == null) {
+ base.onDraw (gr);
+ return;
+ }
+
+ gr.LineWidth = 1;
+ gr.SetDash (new double [] { 1.0, 3.0 }, 0);
+
+ Rectangle cb = ClientRectangle;
+
+ if (Event.Duration == 0) {
+ gr.SetSource (Event.Color);
+ gr.Rectangle (cb);
+ gr.Fill ();
+ return;
+ }
+
+ drawEvent (gr, cb.Height, Event);
+ }
+ }
+ void drawEvent (IContext ctx, int h, DbgEvent dbge)
+ {
+ double w = Math.Max(dbge.Duration * pixelPerTick, 2.0);
+ double x = (dbge.begin - Event.begin) * pixelPerTick;
+
+ ctx.Rectangle (x, 0, w, h);
+ ctx.SetSource (dbge.Color);
+ /*if (dbge.IsSelected) {
+ ctx.FillPreserve ();
+ ctx.SetSource (1, 1, 1);
+ ctx.Stroke ();
+ }else*/
+ ctx.Fill ();
+
+ if (dbge.Events == null)
+ return;
+ foreach (DbgEvent e in dbge.Events)
+ drawEvent (ctx, h, e);
+ }
+
+ public override void onMouseMove (object sender, MouseMoveEventArgs e)
+ {
+ if (Event != null) {
+ Point m = ScreenPointToLocal (e.Position);
+ long curTick = (long)(m.X / pixelPerTick) + Event.begin;
+ HoverEvent = hoverEvent (Event, curTick);
+
+ e.Handled = true;
+ }
+ base.onMouseMove (sender, e);
+ }
+
+ DbgEvent hoverEvent (DbgEvent hevt, long curTick){
+ if (hevt.Events != null) {
+ foreach (DbgEvent e in hevt.Events) {
+ if (curTick >= e.begin && curTick <= e.end)
+ return hoverEvent (e, curTick);
+ }
+ }
+ return hevt;
+ }
+ void updatePixelPerTicks ()
+ {
+ if (Width == Measure.Fit)
+ pixelPerTick = 1.0 / ticksPerPixel;
+ else
+ pixelPerTick = Event == null ? 0 : (double)ClientRectangle.Width / Event.Duration;
+ }
+ }
+} \ No newline at end of file
diff --git a/Samples/DebugLogViewer/src/DbgLogViewer.cs b/Samples/DebugLogViewer/src/DbgLogViewer.cs
new file mode 100644
index 00000000..265f031c
--- /dev/null
+++ b/Samples/DebugLogViewer/src/DbgLogViewer.cs
@@ -0,0 +1,800 @@
+// Copyright (c) 2013-2025 Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
+//
+// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Drawing2D;
+using Crow.DebugLogger;
+using System.Diagnostics;
+
+namespace Crow
+{
+ public class DbgLogViewer : Widget
+ {
+ public static Dictionary<DbgEvtType, Color> colors;
+
+ #region CTOR
+ protected DbgLogViewer () : base(){}
+ public DbgLogViewer (Interface iface, string style = null) : base(iface, style){}
+ #endregion
+
+ FontExtents fe;
+
+
+ double xScale = 1.0/1024.0, yScale = 1.0, leftMargin, topMargin = 0.0;
+ DbgWidgetRecord curWidget, hoverWidget;
+ DbgEvent curEvent, hoverEvent;
+
+ IList<DbgEvent> events = new List<DbgEvent> ();
+ IList<DbgWidgetRecord> widgets = new List<DbgWidgetRecord> ();
+
+
+ public DbgEvtType Filter {
+ get => Configuration.Global.Get<DbgEvtType> ("DbgLogViewFilter");
+ set {
+ if (Filter == value)
+ return;
+ Configuration.Global.Set ("DbgLogViewFilter", value);
+ NotifyValueChangedAuto(Filter);
+ RegisterForGraphicUpdate();
+ }
+ }
+ public IList<DbgEvent> Events {
+ get => events;
+ set {
+ if (events == value)
+ return;
+ events = value;
+ NotifyValueChanged (nameof (Events), events);
+
+ maxTicks = minTicks = 0;
+ if (events != null && events.Count > 0) {
+ minTicks = long.MaxValue;
+ foreach (DbgEvent e in events) {
+ if (e.begin < minTicks)
+ minTicks = e.begin;
+ if (e.end > maxTicks)
+ maxTicks = e.end;
+ }
+ visibleTicks = maxTicks - minTicks;
+ XScale = (ClientRectangle.Width - leftMargin)/visibleTicks;
+ ScrollX = 0;
+ ScrollY = 0;
+ } else {
+ maxTicks = 1;
+ XScale = 1.0/1024.0;
+ }
+
+
+ RegisterForGraphicUpdate ();
+ }
+ }
+ public IList<DbgWidgetRecord> Widgets {
+ get => widgets;
+ set {
+ if (widgets == value)
+ return;
+ widgets = value;
+ NotifyValueChanged (nameof (Widgets), widgets);
+ updateMargins ();
+ updateMaxScrollX ();
+ updateMaxScrollY ();
+ }
+ }
+ public DbgWidgetRecord CurrentWidget {
+ get => curWidget;
+ set {
+ if (curWidget == value)
+ return;
+ curWidget = value;
+ NotifyValueChanged (nameof (CurrentWidget), curWidget);
+ if (CurrentWidget == null)
+ return;
+ if (CurrentWidget.listIndex < scrollY || CurrentWidget.listIndex > scrollY + visibleLines)
+ ScrollY = CurrentWidget.listIndex - (visibleLines / 2);
+
+ currentLine = CurrentWidget.listIndex;
+ RegisterForRedraw();
+ }
+ }
+ public DbgEvent CurrentEvent {
+ get => curEvent;
+ set {
+ if (curEvent == value)
+ return;
+ /*if (curEvent != null)
+ curEvent.IsSelected = false;*/
+ curEvent = value;
+ if (curEvent != null) {
+ //curEvent.IsSelected = true;
+ if (curEvent is DbgWidgetEvent we) {
+ //CurrentWidget = Widgets [we.InstanceIndex];
+ hoverLine = we.InstanceIndex;
+ }
+ currentTick = curEvent.begin;
+ if (curEvent.begin > minTicks + ScrollX + visibleTicks ||
+ curEvent.end < minTicks + ScrollX)
+ ScrollX = curEvent.begin - minTicks - visibleTicks / 2;
+ }
+ NotifyValueChanged (nameof (CurrentEvent), curEvent);
+ RegisterForRedraw ();
+ }
+ }
+ public DbgWidgetRecord HoverWidget {
+ get => hoverWidget;
+ internal set {
+ if (hoverWidget == value)
+ return;
+ hoverWidget = value;
+ NotifyValueChanged (nameof (HoverWidget), hoverWidget);
+ }
+ }
+
+ public DbgEvent HoverEvent {
+ get => hoverEvent;
+ set {
+ if (hoverEvent == value)
+ return;
+ hoverEvent = value;
+ NotifyValueChanged (nameof (HoverEvent), hoverEvent);
+ RegisterForRepaint ();
+ }
+ }
+
+ long hoverTick = 0, currentTick, selStart = -1, selEnd = -1, minTicks = 0, maxTicks = 0, visibleTicks = 0;
+ int hoverLine = -1, currentLine = -1;
+ int visibleLines = 1;
+ Point mousePos;
+
+ public double XScale {
+ get => xScale;
+ set {
+ if (xScale == value)
+ return;
+ xScale = value;
+ NotifyValueChanged ("XScale", xScale);
+ updateVisibleTicks ();
+ RegisterForGraphicUpdate ();
+ }
+ }
+ public double YScale {
+ get => yScale;
+ set {
+ if (yScale == value)
+ return;
+ yScale = value;
+ NotifyValueChanged ("YScale", yScale);
+ RegisterForGraphicUpdate ();
+ }
+ }
+ public override Font Font {
+ get { return base.Font; }
+ set {
+ base.Font = value;
+ using (IContext gr = IFace.Backend.CreateContext (IFace.MainSurface)) {
+ gr.SelectFontFace (Font.Name, Font.Slant, Font.Wheight);
+ gr.SetFontSize (Font.Size);
+
+ fe = gr.FontExtents;
+ }
+ updateMargins ();
+ }
+ }
+ RectangleD getWidgetEvtBounds (DbgEvent evt, ref Rectangle cb, double penY) {
+ double x = xScale * (evt.begin - minTicks - ScrollX);
+ double w = Math.Max (Math.Max (2.0, 2.0 * xScale), (double)(evt.end - evt.begin) * xScale);
+ if (x < 0.0) {
+ w += x;
+ x = 0.0;
+ }
+ x += leftMargin + cb.Left;
+ double rightDiff = x + w - cb.Right;
+ if (rightDiff > 0)
+ w -= rightDiff;
+ return new RectangleD(x, penY, w, fe.Height);
+ }
+ void drawEvents (IContext ctx, IList<DbgEvent> evts)
+ {
+ if (evts == null || evts.Count == 0)
+ return;
+ Rectangle cb = ClientRectangle;
+
+ foreach (DbgEvent evt in evts) {
+ if ((evt.Category & currentFilter) == currentFilter) {
+ if (evt.end - minTicks <= ScrollX)
+ continue;
+ if (evt.begin - minTicks > ScrollX + visibleTicks)
+ break;
+ double penY = topMargin + ClientRectangle.Top;
+
+ if (evt.type.HasFlag (DbgEvtType.Widget)) {
+ DbgWidgetEvent eW = evt as DbgWidgetEvent;
+ int lIdx = eW.InstanceIndex - ScrollY;
+ if (lIdx >= 0 && lIdx <= visibleLines) {
+
+ penY += (lIdx) * fe.Height;
+
+ ctx.SetSource (evt.Color);
+ RectangleD r = getWidgetEvtBounds (evt, ref cb, penY);
+ if (r.Width > 0){
+ ctx.Rectangle (r.X,r.Y,r.Width,r.Height);
+ ctx.Fill ();
+ }
+ }
+ } else if (evt.type.HasFlag (DbgEvtType.IFace)) {
+ double x = xScale * (evt.begin - minTicks - ScrollX);
+ double w = Math.Max (Math.Max (2.0, 2.0 * xScale), (double)(evt.end - evt.begin) * xScale);
+ if (x < 0.0) {
+ w += x;
+ x = 0.0;
+ }
+ x += leftMargin + cb.Left;
+ double rightDiff = x + w - cb.Right;
+ if (rightDiff > 0)
+ w -= rightDiff;
+ //ctx.SetSource (0.9,0.9,0.0,0.1);
+ ctx.SetSource (evt.Color.AdjustAlpha(0.13));
+ ctx.Rectangle (x, cb.Top + topMargin, w, cb.Height);
+ ctx.Fill ();
+ }
+ }
+ drawEvents (ctx, evt.Events);
+ }
+ }
+
+ DbgEvtType currentFilter;
+ protected override void onDraw (IContext gr)
+ {
+ base.onDraw (gr);
+
+ gr.SelectFontFace (Font.Name, Font.Slant, Font.Wheight);
+ gr.SetFontSize (Font.Size);
+
+ if (widgets == null)
+ return;
+
+ gr.LineWidth = 1.0;
+
+ Rectangle cb = ClientRectangle;
+
+ double penY = topMargin + ClientRectangle.Top;
+
+ for (int i = 0; i < visibleLines; i++) {
+ if (i + ScrollY >= widgets.Count)
+ break;
+ int gIdx = i + ScrollY;
+ DbgWidgetRecord g = widgets [gIdx];
+
+ penY += fe.Height;
+
+ gr.SetSource (Colors.Jet);
+ gr.MoveTo (cb.X, penY - 0.5);
+ gr.LineTo (cb.Right, penY - 0.5);
+ gr.Stroke ();
+
+ double penX = 5.0 * g.xLevel + cb.Left;
+
+ if (g.xLevel == 0)
+ gr.SetSource (Colors.LightSalmon);
+ else if (currentLine == g.listIndex)
+ gr.SetSource(Colors.RoyalBlue);
+ else
+ Foreground.SetAsSource (IFace, gr);
+
+ gr.MoveTo (penX, penY - gr.FontExtents.Descent);
+ gr.ShowText (g.name + gIdx);
+ }
+
+ currentFilter = Filter;
+ drawEvents (gr, events);
+
+ gr.MoveTo (cb.Left, topMargin - 0.5 + cb.Top);
+ gr.LineTo (cb.Right, topMargin - 0.5 + cb.Top);
+
+ gr.MoveTo (leftMargin + cb.Left, cb.Top);
+ gr.LineTo (leftMargin + cb.Left, cb.Bottom);
+ gr.SetSource (Colors.Grey);
+
+ penY = topMargin + ClientRectangle.Top;
+
+ //graduation
+ long largeGrad = long.Parse ("1" + new string ('0', visibleTicks.ToString ().Length - 1));
+ long smallGrad = Math.Max (1, largeGrad / 10);
+
+ long firstVisibleTicks = minTicks + ScrollX;
+ long curGrad = firstVisibleTicks - firstVisibleTicks % smallGrad + smallGrad;
+
+ long gg = curGrad - ScrollX - minTicks;
+ while (gg < visibleTicks ) {
+ double x = (double)gg * xScale + leftMargin + cb.Left;
+
+ gr.MoveTo (x, penY - 0.5);
+ if (curGrad % largeGrad == 0) {
+ gr.LineTo (x, penY - 8.5);
+ string str = ticksToMS(curGrad);
+ TextExtents te = gr.TextExtents (str);
+ gr.RelMoveTo (-0.5 * te.Width, -2.0);
+ gr.ShowText (str);
+ }else
+ gr.LineTo (x, penY - 2.5);
+
+ curGrad += smallGrad;
+ gg = curGrad - ScrollX - minTicks;
+ }
+
+ gr.Stroke ();
+
+
+
+ }
+ string ticksToMS(long ticks) => Math.Round ((double)ticks / Stopwatch.Frequency * 1000.0, 2).ToString();
+ public override bool Paint (IContext ctx)
+ {
+ base.Paint (ctx);
+
+ Rectangle r = new Rectangle(mousePos.X, 0, 1, Slot.Height);
+ Rectangle ctxR = ContextCoordinates (r);
+ Rectangle cb = ClientRectangle;
+ ctx.LineWidth = 1.0;
+ if (hoverTick >= 0) {
+ double x = xScale * (hoverTick - minTicks - ScrollX) + leftMargin;
+ if (x - Math.Truncate (x) > 0.5)
+ x = Math.Truncate (x) + 0.5;
+ else
+ x = Math.Truncate (x) - 0.5;
+ ctx.MoveTo (x, cb.Top + topMargin - 4.0);
+ ctx.LineTo (x, cb.Bottom);
+ ctx.SetSource (0.7,0.7,0.7,0.5);
+ ctx.Stroke();
+ }
+ if (currentTick >= 0) {
+ double x = xScale * (currentTick - minTicks - ScrollX) + leftMargin;
+ if (x > leftMargin && x < cb.Right) {
+ if (x - Math.Truncate (x) > 0.5)
+ x = Math.Truncate (x) + 0.5;
+ else
+ x = Math.Truncate (x) - 0.5;
+ ctx.MoveTo (x, cb.Top);
+ ctx.LineTo (x, cb.Bottom);
+ ctx.SetSource (0.2,0.7,1.0,0.6);
+ ctx.Stroke();
+ }
+ }
+
+ ctx.SelectFontFace (Font.Name, Font.Slant, Font.Wheight);
+ ctx.SetFontSize (Font.Size);
+
+ string str = ticksToMS(hoverTick);
+
+ ctx.MoveTo (ctxR.X - ctx.TextExtents (str).Width / 2, ctxR.Y + fe.Height);
+ ctx.ShowText (str);
+
+ ctx.Operator = Operator.Add;
+
+ if (hoverLine >= 0) {
+ double y = fe.Height * (hoverLine - ScrollY) + topMargin + cb.Top;
+ r = new Rectangle (cb.Left, (int)y, cb.Width, (int)fe.Height);
+
+ ctx.SetSource (0.1, 0.1, 0.1, 0.4);
+ ctx.Rectangle (ContextCoordinates (r));
+ ctx.Fill ();
+
+ if (hoverEvent is DbgWidgetEvent wevt) {
+ ctx.SetSource (1.0,1.0,1.0,0.7);
+ ctx.SetDash (new double[] {1, 2});
+ ctx.Rectangle ((Rectangle)getWidgetEvtBounds (wevt, ref cb, y).Inflated (1), 1);
+ }
+ }
+
+ if (currentLine >= ScrollY && currentLine < scrollY + visibleLines) {
+ double y = fe.Height * (currentLine - ScrollY) + topMargin + cb.Top;
+ r = new Rectangle (cb.Left, (int)y, cb.Width, (int)fe.Height);
+
+ ctx.SetSource (0.1, 0.1, 0.7, 0.2);
+ ctx.Rectangle (ContextCoordinates (r));
+ ctx.Fill ();
+ }
+
+ if (selStart < 0 || selEnd < 0) {
+ ctx.Operator = Operator.Over;
+ return true;
+ }
+ double selStartX = (double)(selStart - ScrollX - minTicks) * xScale + leftMargin + cb.Left;
+ double selEndX = (double)(selEnd - ScrollX - minTicks) * xScale + leftMargin + cb.Left;
+
+ if (selStartX < selEndX) {
+ ctxR.X = (int)selStartX;
+ ctxR.Width = (int)(selEndX - selStartX);
+ } else {
+ ctxR.X = (int)selEndX;
+ ctxR.Width = (int)(selStartX - selEndX);
+ }
+
+ ctxR.Width = Math.Max (1, ctxR.Width);
+ ctx.Rectangle (ctxR);
+ ctx.SetSource (0.0,0.2,0.8,0.15);
+ //ctx.SetSource (Colors.Jet);
+ ctx.Fill();
+ ctx.Operator = Operator.Over;
+
+ str = $"{ticksToMS(Math.Abs (selEnd - selStart))} (ms)";
+
+ ctx.MoveTo (ctxR.Center.X - ctx.TextExtents (str).Width / 2, ctxR.Y + fe.Height);
+ ctx.SetSource (Colors.Black);
+ ctx.ShowText (str);
+
+ return true;
+ }
+ public override void OnLayoutChanges (LayoutingType layoutType)
+ {
+ base.OnLayoutChanges (layoutType);
+ switch (layoutType) {
+ case LayoutingType.Width:
+ if (xScale < 0) {
+ visibleTicks = maxTicks - minTicks;
+ XScale = (ClientRectangle.Width - leftMargin) / visibleTicks;
+ }
+ updateVisibleTicks ();
+ break;
+ case LayoutingType.Height:
+ updateVisibleLines ();
+ break;
+ }
+ }
+
+ public override void onMouseLeave (object sender, MouseMoveEventArgs e)
+ {
+ base.onMouseLeave (sender, e);
+ hoverLine = -1;
+ hoverTick = 0;
+ }
+ public override void onMouseMove (object sender, MouseMoveEventArgs e)
+ {
+ long lastTick = hoverTick;
+ int lastLine = hoverLine;
+ updateMouseLocalPos (e.Position);
+
+ if ((IFace.IsDown (Glfw.MouseButton.Left) || IFace.IsDown (Glfw.MouseButton.Middle)) && selStart >= 0)
+ selEnd = hoverTick;
+ else if (IFace.IsDown(Glfw.MouseButton.Right)) {
+ if (lastTick >= 0 && hoverTick >= 0)
+ ScrollX += lastTick - hoverTick;
+ if (lastLine >= 0 && hoverLine >= 0)
+ ScrollY += lastLine - hoverLine;
+ updateMouseLocalPos (e.Position);
+ } else if (widgets != null) {
+ HoverWidget = (hoverLine < 0 || hoverLine >= widgets.Count) ? null : widgets [hoverLine];
+ //HoverEvent = hoverWidget?.Events.FirstOrDefault (ev => ev.begin <= hoverTick && ev.end >= hoverTick);
+ double tickPerPixel = (double)visibleTicks / ClientRectangle.Width;
+ //Console.WriteLine ($"ticks per pixel: {tickPerPixel}");
+ Task.Run (() => findHoverEvent (hoverWidget, hoverTick, (int)tickPerPixel));
+ }
+
+ RegisterForRepaint();
+
+ e.Handled = true;
+ base.onMouseMove (sender, e);
+ }
+ void findHoverEvent (DbgWidgetRecord widget, long tick, long precision = 0) {
+ DbgEvent tmp = widget?.Events.FirstOrDefault (ev => ev.begin - precision <= tick && ev.end + precision >= tick);
+ if (tmp == null) {
+ tmp = Events.Where(e=>e.type.HasFlag(DbgEvtType.IFace)).Where (ev => ev.begin - precision <= tick && ev.end + precision >= tick).FirstOrDefault();
+ while(tmp != null) {
+ DbgEvent che = tmp.Events?.Where(e=>e.type.HasFlag(DbgEvtType.IFace)).Where (ev => ev.begin - precision <= tick && ev.end + precision >= tick).FirstOrDefault();
+ if (che == null)
+ break;
+ tmp = che;
+ }
+ } else {
+ while(tmp != null) {
+ DbgEvent che = tmp.Events?.OfType<DbgWidgetEvent>()?.Where(ev=>ev.InstanceIndex == widget.listIndex && ev.begin - precision <= tick && ev.end + precision >= tick).FirstOrDefault();
+ if (che == null)
+ break;
+ tmp = che;
+ }
+ }
+ HoverEvent = tmp;
+ }
+ public override void onMouseClick(object sender, MouseButtonEventArgs e)
+ {
+ if (e.Button == Glfw.MouseButton.Left) {
+ if (selEnd < 0) {
+ currentTick = hoverTick;
+ currentLine = hoverLine;
+ CurrentWidget = hoverWidget;
+ CurrentEvent = hoverEvent;
+ }
+ selStart = -1;
+ selEnd = -1;
+ }
+
+ e.Handled = true;
+ base.onMouseClick(sender, e);
+ }
+ public override void onMouseDown (object sender, MouseButtonEventArgs e)
+ {
+ if (e.Button == Glfw.MouseButton.Left || e.Button == Glfw.MouseButton.Middle) {
+ selStart = hoverTick;
+ selEnd = -1;
+ }
+
+ RegisterForRedraw ();
+ e.Handled = true;
+ base.onMouseDown (sender, e);
+ }
+ public override void onMouseUp (object sender, MouseButtonEventArgs e)
+ {
+
+ if (e.Button == Glfw.MouseButton.Left && selEnd > 0 && selEnd != selStart) {
+ long scrX = 0;
+ if (selStart < selEnd) {
+ visibleTicks = selEnd - selStart;
+ scrX = selStart - minTicks;
+ } else {
+ visibleTicks = selStart - selEnd;
+ scrX = selEnd - minTicks;
+ }
+ XScale = (ClientRectangle.Width - leftMargin) / visibleTicks;
+ ScrollX = scrX;
+ }
+
+ RegisterForRedraw ();
+ e.Handled = true;
+ base.onMouseUp (sender, e);
+ }
+
+ /// <summary> Process scrolling vertically, or if shift is down, vertically </summary>
+ public override void onMouseWheel (object sender, MouseWheelEventArgs e)
+ {
+ //base.onMouseWheel (sender, e);
+
+ if (IFace.Shift)
+ ScrollX -= (int)((double)(e.Delta * MouseWheelSpeed) / xScale);
+ else if (IFace.Ctrl)
+ ScrollY -= e.Delta * MouseWheelSpeed;
+ else {
+ if (e.Delta > 0) {
+ XScale *= 2.0;
+ } else {
+ if (MaxScrollX > 0)
+ XScale *= 0.5;
+ }
+ ScrollX = (long)(hoverTick - (long)((double)Math.Max(0, mousePos.X - (long)leftMargin) / xScale) - minTicks);
+ }
+ }
+
+ public override void onKeyDown (object sender, KeyEventArgs e)
+ {
+ base.onKeyDown (sender, e);
+
+ if (e.Key == Glfw.Key.F3) {
+ if (selEnd < 0)
+ return;
+ if (selEnd < selStart)
+ zoom (selEnd, selStart);
+ else
+ zoom (selStart, selEnd);
+ selEnd = selStart = -1;
+ }
+ }
+
+ void updateMargins ()
+ {
+ leftMargin = topMargin = 0.0;
+
+ if (widgets == null)
+ return;
+
+ using (IContext gr = IFace.Backend.CreateContext (IFace.MainSurface)) {
+ gr.SelectFontFace (Font.Name, Font.Slant, Font.Wheight);
+ gr.SetFontSize (Font.Size);
+
+ double maxNameWidth = 0.0;
+
+ foreach (DbgWidgetRecord o in widgets) {
+ double nameWidth = gr.TextExtents (o.name).Width + 5.0 * o.xLevel;
+ if (nameWidth > maxNameWidth)
+ maxNameWidth = nameWidth;
+ }
+
+ leftMargin = 10.5 + maxNameWidth;
+ topMargin = 2.0 * fe.Height;
+
+ RegisterForGraphicUpdate ();
+ }
+ }
+
+ void updateVisibleLines ()
+ {
+ visibleLines = fe.Height < 1 ? 1 : (int)Math.Ceiling (((double)ClientRectangle.Height - topMargin) / fe.Height);
+ NotifyValueChanged ("VisibleLines", visibleLines);
+ updateMaxScrollY ();
+ }
+ void updateVisibleTicks ()
+ {
+ visibleTicks = Math.Max (0, (long)((double)(ClientRectangle.Width - leftMargin) / XScale));
+ NotifyValueChanged ("VisibleTicks", visibleTicks);
+ updateMaxScrollX ();
+ }
+
+ void updateMaxScrollX ()
+ {
+ if (widgets == null) {
+ MaxScrollX = 0;
+ } else {
+ long tot = maxTicks - minTicks;
+ MaxScrollX = Math.Max (0L, tot - visibleTicks);
+ NotifyValueChanged ("ChildWidthRatio", (double)visibleTicks / tot);
+ }
+ }
+ void updateMaxScrollY ()
+ {
+ if (widgets == null)
+ MaxScrollY = 0;
+ else {
+ MaxScrollY = Math.Max (0, widgets.Count + 1 - visibleLines);
+ NotifyValueChanged ("ChildHeightRatio", (double)visibleLines / (widgets.Count + 1));
+ }
+ }
+
+ void updateMouseLocalPos (Point mPos)
+ {
+ Rectangle r = ScreenCoordinates (Slot);
+ Rectangle cb = ClientRectangle;
+ cb.Left += (int)leftMargin;
+ cb.Width -= (int)leftMargin;
+ cb.Y += (int)topMargin;
+ cb.Height -= (int)topMargin;
+
+ mousePos = mPos - r.Position;
+
+ mousePos.X = Math.Max (cb.X, mousePos.X);
+ mousePos.X = Math.Min (cb.Right, mousePos.X);
+
+ if (mousePos.Y < cb.Top || mousePos.Y > cb.Bottom)
+ hoverLine = -1;
+ else
+ hoverLine = (int)((double)(mousePos.Y - cb.Top) / fe.Height) + ScrollY;
+
+ NotifyValueChanged ("CurrentLine", hoverLine);
+
+ mousePos.Y = Math.Max (cb.Y, mousePos.Y);
+ mousePos.Y = Math.Min (cb.Bottom, mousePos.Y);
+
+ hoverTick = (long)((double)(mousePos.X - cb.X) / xScale) + minTicks + ScrollX;
+ RegisterForRedraw ();
+ }
+ void zoom (long start, long end) {
+ //Rectangle cb = ClientRectangle;
+ //cb.X += (int)leftMargin;
+ XScale = ((double)ClientRectangle.Width - leftMargin)/(end - start);
+ ScrollX = (int)(start - minTicks);
+ }
+
+
+ long scrollX, maxScrollX;
+ int scrollY, maxScrollY, mouseWheelSpeed;
+
+ /// <summary>
+ /// if true, key stroke are handled in derrived class
+ /// </summary>
+ protected bool KeyEventsOverrides = false;
+
+ /// <summary> Horizontal Scrolling Position </summary>
+ [DefaultValue(0)]
+ public virtual long ScrollX {
+ get => scrollX;
+ set {
+ if (scrollX == value)
+ return;
+
+ long newS = value;
+ if (newS < 0)
+ newS = 0;
+ else if (newS > maxScrollX)
+ newS = maxScrollX;
+
+ if (newS == scrollX)
+ return;
+
+ scrollX = newS;
+
+ NotifyValueChangedAuto (scrollX);
+ RegisterForGraphicUpdate ();
+ }
+ }
+ /// <summary> Vertical Scrolling Position </summary>
+ [DefaultValue(0)]
+ public virtual int ScrollY {
+ get => scrollY;
+ set {
+ if (scrollY == value)
+ return;
+
+ int newS = value;
+ if (newS < 0)
+ newS = 0;
+ else if (newS > maxScrollY)
+ newS = maxScrollY;
+
+ if (newS == scrollY)
+ return;
+
+ scrollY = newS;
+
+ NotifyValueChangedAuto (scrollY);
+ RegisterForGraphicUpdate ();
+
+ if (widgets == null)
+ return;
+
+ Rectangle cb = ClientRectangle;
+ cb.Left += (int)leftMargin;
+ cb.Width -= (int)leftMargin;
+ cb.Y += (int)topMargin;
+ cb.Height -= (int)topMargin;
+
+ if (mousePos.Y < cb.Top || mousePos.Y > cb.Bottom)
+ hoverLine = -1;
+ else
+ hoverLine = (int)((double)(mousePos.Y - cb.Top) / fe.Height) + ScrollY;
+
+ NotifyValueChanged ("CurrentLine", hoverLine);
+ }
+ }
+ /// <summary> Horizontal Scrolling maximum value </summary>
+ [DefaultValue(0)]
+ public virtual long MaxScrollX {
+ get => maxScrollX;
+ set {
+ if (maxScrollX == value)
+ return;
+
+ maxScrollX = Math.Max(0, value);
+
+ if (scrollX > maxScrollX)
+ ScrollX = maxScrollX;
+
+ NotifyValueChangedAuto (maxScrollX);
+ RegisterForGraphicUpdate ();
+ }
+ }
+ /// <summary> Vertical Scrolling maximum value </summary>
+ [DefaultValue(0)]
+ public virtual int MaxScrollY {
+ get => maxScrollY;
+ set {
+ if (maxScrollY == value)
+ return;
+
+ maxScrollY = Math.Max (0, value);
+
+ if (scrollY > maxScrollY)
+ ScrollY = maxScrollY;
+
+ NotifyValueChangedAuto (maxScrollY);
+ RegisterForGraphicUpdate ();
+ }
+ }
+ /// <summary> Mouse Wheel Scrolling multiplier </summary>
+ [DefaultValue(1)]
+ public virtual int MouseWheelSpeed {
+ get => mouseWheelSpeed;
+ set {
+ if (mouseWheelSpeed == value)
+ return;
+
+ mouseWheelSpeed = value;
+
+ NotifyValueChangedAuto (mouseWheelSpeed);
+ }
+ }
+ }
+}
+
+
diff --git a/Samples/DebugLogViewer/src/main.cs b/Samples/DebugLogViewer/src/main.cs
new file mode 100644
index 00000000..ac1c9d37
--- /dev/null
+++ b/Samples/DebugLogViewer/src/main.cs
@@ -0,0 +1,281 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Crow;
+using Crow.DebugLogger;
+using Drawing2D;
+using Glfw;
+using Samples;
+
+namespace DebugLogViewer
+{
+ class DebugLogViewer : Interface {
+ static void Main (string[] args) {
+ using (DebugLogViewer app = new DebugLogViewer ())
+ app.Run ();
+ }
+
+ public DebugLogViewer () : base (Configuration.Global.Get<int>("MainWinWidth", 800), Configuration.Global.Get<int>("MainWinHeight", 600), true) { }
+ public override void ProcessResize(Rectangle bounds)
+ {
+ base.ProcessResize(bounds);
+ Configuration.Global.Set ("MainWinWidth", clientRectangle.Width);
+ Configuration.Global.Set ("MainWinHeight", clientRectangle.Height);
+ //Console.WriteLine($"{clientRectangle.Width}x{clientRectangle.Height}");
+ }
+ protected override void OnInitialized () {
+ base.OnInitialized ();
+
+ initCommands ();
+
+ SetWindowIcon ("#Crow.Icons.crow.png");
+
+ if (ReopenLastLog)
+ loadLog(CurrentLogFilePath);
+
+ Load ("#ui.main.crow").DataSource = this;
+ }
+
+ #region Commands
+ public Command CMDQuit, CMDHelp, CMDAbout, CMDOptions;
+ public Command CMDStartRecording, CMDStopRecording, CMDRefresh, CMDAddEventToRecord, CMDRemoveEventToRecord;
+ public Command CMDGotoParentEvent, CMDEventHistoryForward, CMDEventHistoryBackward;
+ public CommandGroup LoggerCommands => new CommandGroup (CMDRefresh, CMDStartRecording, CMDStopRecording);
+ public CommandGroup EventCommands => new CommandGroup(
+ CMDGotoParentEvent, CMDEventHistoryBackward, CMDEventHistoryForward);
+ public CommandGroup CommandsRoot, FileCommands;
+
+ void initCommands ()
+ {
+ FileCommands = new CommandGroup ("File",
+ new ActionCommand("Open Log...", openFileDialog, "#icons.outbox.svg"),
+ new ActionCommand("Options", openOptionsDialog, "#icons.tools.svg"),
+ new ActionCommand("Quit", base.Quit, "#icons.sign-out.svg")
+ );
+
+
+ CMDGotoParentEvent = new ActionCommand("parent", ()=> { CurrentEvent = CurrentEvent?.parentEvent; }, "#icons.level-up.svg", false);
+ CMDEventHistoryBackward = new ActionCommand("back.", currentEventHistoryGoBack, "#icons.previous.svg", false);
+ CMDEventHistoryForward = new ActionCommand("forw.", currentEventHistoryGoForward, "#icons.forward-arrow.svg", false);
+
+ CMDHelp = new ActionCommand("Help", () => System.Diagnostics.Debug.WriteLine("help"), "#icons.question.svg");
+
+ CommandsRoot = new CommandGroup (
+ FileCommands,
+ new CommandGroup ("Help", CMDHelp)
+ );
+ }
+ void openOptionsDialog() => Load ("#ui.Options.crow").DataSource = this;
+ void openFileDialog() =>
+ LoadIMLFragment (
+ @"<FileDialog Width='60%' Height='50%' Caption='Open Log File' AlwaysOnTop='true'
+ CurrentDirectory='{²CurrentDir}'
+ SelectedFile='{²CurrentLogFileName}'
+ OkClicked='openFileDialog_OkClicked'/>").DataSource = this;
+
+ void openFileDialog_OkClicked (object sender, EventArgs e)
+ {
+ loadLog (CurrentLogFilePath);
+ }
+
+ #endregion
+
+
+ IList<DbgEvent> events;
+ IList<DbgWidgetRecord> widgets;
+
+ public string CurrentDir {
+ get => Configuration.Global.Get<string>("CurrentDir", Environment.GetFolderPath (Environment.SpecialFolder.MyDocuments));
+ set {
+ if (CurrentDir == value)
+ return;
+ Configuration.Global.Set ("CurrentDir", value);
+ NotifyValueChanged (CurrentDir);
+ }
+ }
+ public string CurrentLogFileName {
+ get => Configuration.Global.Get<string> ("CurrentLogFileName");
+ set {
+ if (CurrentLogFileName == value)
+ return;
+ Configuration.Global.Set ("CurrentLogFileName", value);
+ NotifyValueChanged (value);
+ }
+ }
+ public string CurrentLogFilePath => Path.Combine(CurrentDir,CurrentLogFileName);
+ public bool ReopenLastLog
+ {
+ get => Configuration.Global.Get<bool> ("ReopenLastLog", true);
+ set {
+ if (ReopenLastLog == value)
+ return;
+ Configuration.Global.Set ("ReopenLastLog", value);
+ NotifyValueChanged (value);
+ }
+ }
+
+ public IList<DbgEvent> Events {
+ get => events;
+ set {
+ if (events == value)
+ return;
+ events = value;
+ NotifyValueChanged (nameof (Events), events);
+ }
+ }
+ public IList<DbgWidgetRecord> Widgets {
+ get => widgets;
+ set {
+ if (widgets == value)
+ return;
+ widgets = value;
+ NotifyValueChanged (nameof (Widgets), widgets);
+ }
+ }
+
+ void loadLog (string logFile) {
+ if (!File.Exists(logFile))
+ return;
+ //lock(UpdateMutex) {
+ using (Stream stream = new FileStream (logFile, FileMode.Open, FileAccess.Read)) {
+ List<DbgWidgetRecord> widgets = new List<DbgWidgetRecord>();
+ List<DbgEvent> events = new List<DbgEvent>();
+ DbgLogger.Load (stream, events, widgets);
+
+ for (int i = 0; i < widgets.Count; i++) {
+ widgets[i].listIndex = i;
+ //Widgets.Add (widgets[i]);
+ }
+ for (int i = 0; i < events.Count; i++) {
+ //Events.Add (events[i]);
+ updateWidgetEvents (widgets, events[i]);
+ }
+
+ Events = events;
+ Widgets = widgets;
+ }
+ //}
+ }
+ void updateWidgetEvents (IList<DbgWidgetRecord> widgets, DbgEvent evt) {
+ if (evt is DbgWidgetEvent we)
+ widgets.FirstOrDefault (w => w.InstanceIndex == we.InstanceIndex)?.Events.Add (we);
+ if (evt.Events == null)
+ return;
+ foreach (DbgEvent e in evt.Events)
+ updateWidgetEvents (widgets, e);
+ }
+ void saveLogToDebugLogFilePath () {
+
+ }
+ void loadLogFromDebugLogFilePath () {
+
+ }
+
+ DbgEvent curEvent;
+ bool disableCurrentEventHistory;
+ Stack<DbgEvent> CurrentEventHistoryForward = new Stack<DbgEvent>();
+ Stack<DbgEvent> CurrentEventHistoryBackward = new Stack<DbgEvent>();
+ DbgWidgetRecord curWidgetRecord = new DbgWidgetRecord();
+ public string[] AllEventTypes => Enum.GetNames (typeof(DbgEvtType));
+ string searchEventType;
+ DbgWidgetRecord searchWidget;
+ public string SearchEventType {
+ get => searchEventType;
+ set {
+ if (searchEventType == value)
+ return;
+ searchEventType = value;
+ NotifyValueChanged (searchEventType);
+ }
+ }
+ public DbgWidgetRecord SearchWidget {
+ get => searchWidget;
+ set {
+ if (searchWidget == value)
+ return;
+ searchWidget = value;
+ NotifyValueChanged (searchWidget);
+ }
+ }
+
+ public DbgEvent CurrentEvent {
+ get => curEvent;
+ set {
+ if (curEvent == value)
+ return;
+
+ if (!disableCurrentEventHistory) {
+ CurrentEventHistoryForward.Clear ();
+ CMDEventHistoryForward.CanExecute = false;
+ if (!(value == null || curEvent == null)) {
+ CurrentEventHistoryBackward.Push (curEvent);
+ CMDEventHistoryBackward.CanExecute = true;
+ }
+ }
+
+ curEvent = value;
+
+ NotifyValueChanged (nameof (CurrentEvent), curEvent);
+ NotifyValueChanged ("CurEventChildEvents", curEvent?.Events);
+ NotifyValueChanged ("CurWidgetProperties", CurWidgetProperties);
+
+ if (CurrentEvent != null && CurrentEvent.parentEvent != null)
+ CMDGotoParentEvent.CanExecute = true;
+ else
+ CMDGotoParentEvent.CanExecute = false;
+ }
+ }
+ public DbgWidgetRecord CurrentWidget {
+ get => curWidgetRecord;
+ set {
+ if (curWidgetRecord == value)
+ return;
+ curWidgetRecord = value;
+ NotifyValueChanged ("CurrentWidget", curWidgetRecord);
+ NotifyValueChanged ("CurWidgetRootEvents", curWidgetRecord?.RootEvents);
+ NotifyValueChanged ("CurrentWidgetEvents", curWidgetRecord?.Events);
+ NotifyValueChanged ("CurWidgetProperties", CurWidgetProperties);
+ }
+ }
+ public List<DbgWidgetEvent> CurWidgetRootEvents => curWidgetRecord == null? new List<DbgWidgetEvent>() : curWidgetRecord.RootEvents;
+
+ public IEnumerable<KeyValuePair<string, string>> CurWidgetProperties {
+ get {
+ if (curWidgetRecord == null)
+ return null;
+ long endTime = curEvent == null ? long.MaxValue : curEvent.end;
+ Dictionary<string, string> result = new Dictionary<string, string> ();
+ foreach (DbgWidgetEvent evt in curWidgetRecord?.Events?.Where (e => e.type == DbgEvtType.GOSetProperty && e.begin <= endTime)){
+ string[] tmp = evt.Message.Split('=');
+ if (result.ContainsKey (tmp[0]))
+ result[tmp[0]] = tmp[1];
+ else
+ result.Add (tmp[0], tmp[1]);
+ }
+ return result;
+ }
+ }
+
+ void currentEventHistoryGoBack () {
+ disableCurrentEventHistory = true;
+ if (CurrentEvent != null) {
+ CurrentEventHistoryForward.Push (CurrentEvent);
+ CMDEventHistoryForward.CanExecute = true;
+ }
+ CurrentEvent = CurrentEventHistoryBackward.Pop ();
+ CMDEventHistoryBackward.CanExecute = CurrentEventHistoryBackward.Count > 0;
+
+ disableCurrentEventHistory = false;
+ }
+ void currentEventHistoryGoForward () {
+ disableCurrentEventHistory = true;
+ CurrentEventHistoryBackward.Push (CurrentEvent);
+ CMDEventHistoryBackward.CanExecute = true;
+ CurrentEvent = CurrentEventHistoryForward.Pop ();
+ CMDEventHistoryForward.CanExecute = CurrentEventHistoryForward.Count > 0;
+
+ disableCurrentEventHistory = false;
+ }
+ }
+}
generated by cgit v1.3.1-4-g156e (git 2.54.0) at 2026-11-12 13:59:54 +0000