feat(ui-visuals): add series, bar, heatmap, stacked and timeline charts
SeriesChart decimates each line to two points per pixel column and adds a legend row, nice-tick gridlines, dashed markers, a playhead, click-to-seek and a hover readout. BarChart, HeatmapStrip, StackedBar and TimelineBands cover the Archive statistics and the Library timeline bands. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
5 files changed
+1351
No files matched your search
@@ -0,0 +1,277 @@
|
||||
using System.Windows;
|
||||
using System.Windows.Controls;
|
||||
using System.Windows.Input;
|
||||
using System.Windows.Media;
|
||||
using Titano.Core.Localization;
|
||||
|
||||
namespace Titano.Ui.Visuals;
|
||||
|
||||
/// <summary>
|
||||
/// Bars for labelled values (Archive: storage by year, by camera, by format; uploads per day). Horizontal bars put
|
||||
/// the category labels on the left and the value labels after each bar, as in the Archive mockup; vertical bars
|
||||
/// put the categories underneath (skipping labels that would collide). Optional value gridlines use nice ticks.
|
||||
/// A bar's opacity can follow its value (<see cref="MinimumOpacity"/>). Hovering reads out the bar; clicking raises
|
||||
/// <see cref="ItemActivatedEvent"/>.
|
||||
/// </summary>
|
||||
public sealed class BarChart : DrawingElement
|
||||
{
|
||||
public static readonly DependencyProperty ItemsProperty = DependencyProperty.Register(
|
||||
nameof(Items), typeof(IReadOnlyList<ChartItem>), typeof(BarChart), new PropertyMetadata(null, OnDataPropertyChanged));
|
||||
|
||||
public static readonly DependencyProperty OrientationProperty = DependencyProperty.Register(
|
||||
nameof(Orientation), typeof(Orientation), typeof(BarChart),
|
||||
new FrameworkPropertyMetadata(Orientation.Horizontal, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure));
|
||||
|
||||
public static readonly DependencyProperty BrushKeyProperty = DependencyProperty.Register(
|
||||
nameof(BrushKey), typeof(string), typeof(BarChart), new FrameworkPropertyMetadata("Brush.Accent", FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty MinimumOpacityProperty = DependencyProperty.Register(
|
||||
nameof(MinimumOpacity), typeof(double), typeof(BarChart), new FrameworkPropertyMetadata(1.0, FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty ShowValuesProperty = DependencyProperty.Register(
|
||||
nameof(ShowValues), typeof(bool), typeof(BarChart), new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty ShowGridProperty = DependencyProperty.Register(
|
||||
nameof(ShowGrid), typeof(bool), typeof(BarChart), new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty MaximumProperty = DependencyProperty.Register(
|
||||
nameof(Maximum), typeof(double), typeof(BarChart), new FrameworkPropertyMetadata(double.NaN, FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty BarThicknessProperty = DependencyProperty.Register(
|
||||
nameof(BarThickness), typeof(double), typeof(BarChart),
|
||||
new FrameworkPropertyMetadata(14.0, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure));
|
||||
|
||||
public static readonly DependencyProperty ValueFormatterProperty = DependencyProperty.Register(
|
||||
nameof(ValueFormatter), typeof(Func<double, string>), typeof(BarChart), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly RoutedEvent ItemActivatedEvent = EventManager.RegisterRoutedEvent(
|
||||
nameof(ItemActivated), RoutingStrategy.Bubble, typeof(ChartItemEventHandler), typeof(BarChart));
|
||||
|
||||
private const double LabelSize = 11;
|
||||
private const double RowGap = 8;
|
||||
|
||||
private Rect _area;
|
||||
private double _pitch;
|
||||
private int _hover = -1;
|
||||
|
||||
/// <summary>Bars in display order.</summary>
|
||||
public IReadOnlyList<ChartItem>? Items { get => (IReadOnlyList<ChartItem>?)GetValue(ItemsProperty); set => SetValue(ItemsProperty, value); }
|
||||
|
||||
public Orientation Orientation { get => (Orientation)GetValue(OrientationProperty); set => SetValue(OrientationProperty, value); }
|
||||
|
||||
/// <summary>Theme brush key of the bars (items may override).</summary>
|
||||
public string BrushKey { get => (string)GetValue(BrushKeyProperty); set => SetValue(BrushKeyProperty, value); }
|
||||
|
||||
/// <summary>Opacity of a zero bar; bars ramp linearly to 1 at the maximum (1 = flat colour).</summary>
|
||||
public double MinimumOpacity { get => (double)GetValue(MinimumOpacityProperty); set => SetValue(MinimumOpacityProperty, value); }
|
||||
|
||||
public bool ShowValues { get => (bool)GetValue(ShowValuesProperty); set => SetValue(ShowValuesProperty, value); }
|
||||
|
||||
/// <summary>Value-axis gridlines and tick labels.</summary>
|
||||
public bool ShowGrid { get => (bool)GetValue(ShowGridProperty); set => SetValue(ShowGridProperty, value); }
|
||||
|
||||
/// <summary>Value at full length; NaN = the largest value (or the nice tick above it with the grid on).</summary>
|
||||
public double Maximum { get => (double)GetValue(MaximumProperty); set => SetValue(MaximumProperty, value); }
|
||||
|
||||
/// <summary>Maximum bar thickness in DIPs.</summary>
|
||||
public double BarThickness { get => (double)GetValue(BarThicknessProperty); set => SetValue(BarThicknessProperty, value); }
|
||||
|
||||
/// <summary>Culture-aware value formatting for value labels, ticks and readouts.</summary>
|
||||
public Func<double, string>? ValueFormatter { get => (Func<double, string>?)GetValue(ValueFormatterProperty); set => SetValue(ValueFormatterProperty, value); }
|
||||
|
||||
public event ChartItemEventHandler ItemActivated
|
||||
{
|
||||
add => AddHandler(ItemActivatedEvent, value);
|
||||
remove => RemoveHandler(ItemActivatedEvent, value);
|
||||
}
|
||||
|
||||
protected override Size MeasureOverride(Size availableSize)
|
||||
{
|
||||
var count = Items?.Count ?? 0;
|
||||
return Orientation == Orientation.Horizontal ? new Size(0, count * (BarThickness + RowGap)) : new Size(0, 120);
|
||||
}
|
||||
|
||||
protected override void OnDataChanged()
|
||||
{
|
||||
_hover = -1;
|
||||
base.OnDataChanged();
|
||||
}
|
||||
|
||||
protected override void OnRender(DrawingContext dc)
|
||||
{
|
||||
DrawHitArea(dc);
|
||||
_area = Rect.Empty;
|
||||
if (Items is not { Count: > 0 } items) return;
|
||||
var max = ScaleMaximum(items);
|
||||
if (Orientation == Orientation.Horizontal) RenderHorizontal(dc, items, max);
|
||||
else RenderVertical(dc, items, max);
|
||||
}
|
||||
|
||||
protected override void OnMouseMove(MouseEventArgs e)
|
||||
{
|
||||
base.OnMouseMove(e);
|
||||
var p = e.GetPosition(this);
|
||||
_hover = HitTest(p);
|
||||
Readout.Show(_hover >= 0 && Items is { } items ? ReadoutText(items[_hover]) : null, p);
|
||||
}
|
||||
|
||||
protected override void OnQueryCursor(QueryCursorEventArgs e)
|
||||
{
|
||||
base.OnQueryCursor(e);
|
||||
if (e.Handled || _hover < 0) return;
|
||||
e.Cursor = Cursors.Hand;
|
||||
e.Handled = true;
|
||||
}
|
||||
|
||||
protected override void OnMouseLeave(MouseEventArgs e)
|
||||
{
|
||||
base.OnMouseLeave(e);
|
||||
_hover = -1;
|
||||
Readout.Hide();
|
||||
}
|
||||
|
||||
protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
|
||||
{
|
||||
base.OnMouseLeftButtonUp(e);
|
||||
var index = HitTest(e.GetPosition(this));
|
||||
if (index < 0) return;
|
||||
RaiseEvent(new ChartItemEventArgs(ItemActivatedEvent, index, -1));
|
||||
e.Handled = true;
|
||||
}
|
||||
|
||||
private string Format(double value) => (ValueFormatter ?? DefaultFormat)(value);
|
||||
|
||||
private static string DefaultFormat(double value) => value.ToString("N0", Loc.Culture);
|
||||
|
||||
private string ReadoutText(ChartItem item) => item.ToolTip ?? item.Label + " · " + (item.ValueText ?? Format(item.Value));
|
||||
|
||||
private double ScaleMaximum(IReadOnlyList<ChartItem> items)
|
||||
{
|
||||
if (double.IsFinite(Maximum) && Maximum > 0) return Maximum;
|
||||
var max = 0.0;
|
||||
for (var i = 0; i < items.Count; i++) max = Math.Max(max, items[i].Value);
|
||||
if (max <= 0) return 1;
|
||||
return ShowGrid ? NiceScale.Outer(0, max, 5).Last : max;
|
||||
}
|
||||
|
||||
private double OpacityOf(double value, double max) =>
|
||||
MinimumOpacity >= 1 ? 1 : MinimumOpacity + (1 - MinimumOpacity) * Math.Clamp(value / max, 0, 1);
|
||||
|
||||
private void RenderHorizontal(DrawingContext dc, IReadOnlyList<ChartItem> items, double max)
|
||||
{
|
||||
var faint = GetBrush("Brush.TextFaint");
|
||||
var text = GetBrush("Brush.Text");
|
||||
var labels = new FormattedText[items.Count];
|
||||
var values = new FormattedText?[items.Count];
|
||||
double labelWidth = 0, valueWidth = 0;
|
||||
for (var i = 0; i < items.Count; i++)
|
||||
{
|
||||
labels[i] = CreateText(items[i].Label, LabelSize, faint);
|
||||
labelWidth = Math.Max(labelWidth, labels[i].Width);
|
||||
if (!ShowValues) continue;
|
||||
values[i] = CreateText(items[i].ValueText ?? Format(items[i].Value), LabelSize, text);
|
||||
valueWidth = Math.Max(valueWidth, values[i]!.Width);
|
||||
}
|
||||
var gridHeight = ShowGrid ? 16 : 0;
|
||||
var left = Math.Ceiling(labelWidth) + 8;
|
||||
var right = ActualWidth - (ShowValues ? valueWidth + 6 : 0);
|
||||
_area = new Rect(left, 0, Math.Max(0, right - left), Math.Max(0, ActualHeight - gridHeight));
|
||||
_pitch = Math.Min(_area.Height / items.Count, BarThickness + RowGap);
|
||||
var thickness = Math.Max(1, Math.Min(BarThickness, _pitch - 2));
|
||||
if (ShowGrid) DrawValueGrid(dc, max, horizontal: true);
|
||||
|
||||
for (var i = 0; i < items.Count; i++)
|
||||
{
|
||||
var item = items[i];
|
||||
var cy = _area.Top + _pitch * (i + 0.5);
|
||||
dc.DrawText(labels[i], new Point(left - 8 - labels[i].Width, cy - labels[i].Height / 2));
|
||||
var length = _area.Width * Math.Clamp(item.Value / max, 0, 1);
|
||||
if (length > 0)
|
||||
{
|
||||
dc.PushOpacity(OpacityOf(item.Value, max));
|
||||
dc.DrawRoundedRectangle(GetBrush(item.BrushKey ?? BrushKey), null, new Rect(left, cy - thickness / 2, length, thickness), 2, 2);
|
||||
dc.Pop();
|
||||
}
|
||||
if (values[i] is { } value) dc.DrawText(value, new Point(left + length + 6, cy - value.Height / 2));
|
||||
}
|
||||
}
|
||||
|
||||
private void RenderVertical(DrawingContext dc, IReadOnlyList<ChartItem> items, double max)
|
||||
{
|
||||
var faint = GetBrush("Brush.TextFaint");
|
||||
var sample = CreateText("0", LabelSize, faint);
|
||||
var labelHeight = Math.Ceiling(sample.Height) + 4;
|
||||
var valueHeight = ShowValues ? labelHeight : 0;
|
||||
var axisWidth = 0.0;
|
||||
if (ShowGrid)
|
||||
{
|
||||
var top = CreateText(Format(max), LabelSize, faint);
|
||||
axisWidth = Math.Ceiling(top.Width) + 8;
|
||||
}
|
||||
_area = new Rect(axisWidth, valueHeight, Math.Max(0, ActualWidth - axisWidth), Math.Max(0, ActualHeight - labelHeight - valueHeight));
|
||||
_pitch = _area.Width / items.Count;
|
||||
var width = Math.Max(1, Math.Min(BarThickness * 2, _pitch * 0.7));
|
||||
if (ShowGrid) DrawValueGrid(dc, max, horizontal: false);
|
||||
|
||||
var text = GetBrush("Brush.Text");
|
||||
var lastLabelRight = double.NegativeInfinity;
|
||||
for (var i = 0; i < items.Count; i++)
|
||||
{
|
||||
var item = items[i];
|
||||
var cx = _area.Left + _pitch * (i + 0.5);
|
||||
var height = _area.Height * Math.Clamp(item.Value / max, 0, 1);
|
||||
if (height > 0)
|
||||
{
|
||||
dc.PushOpacity(OpacityOf(item.Value, max));
|
||||
dc.DrawRoundedRectangle(GetBrush(item.BrushKey ?? BrushKey), null, new Rect(cx - width / 2, _area.Bottom - height, width, height), 2, 2);
|
||||
dc.Pop();
|
||||
}
|
||||
if (ShowValues && _pitch >= 24)
|
||||
{
|
||||
var value = CreateText(item.ValueText ?? Format(item.Value), LabelSize, text);
|
||||
if (value.Width <= _pitch) dc.DrawText(value, new Point(cx - value.Width / 2, _area.Bottom - height - value.Height - 2));
|
||||
}
|
||||
var label = CreateText(item.Label, LabelSize, faint);
|
||||
var x = cx - label.Width / 2;
|
||||
if (x < lastLabelRight + 6) continue;
|
||||
dc.DrawText(label, new Point(x, _area.Bottom + 4));
|
||||
lastLabelRight = x + label.Width;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Gridlines at nice ticks along the value axis, with labels below (horizontal bars) or left (vertical bars).</summary>
|
||||
private void DrawValueGrid(DrawingContext dc, double max, bool horizontal)
|
||||
{
|
||||
var ticks = NiceScale.Inner(0, max, horizontal ? Math.Max(2, (int)(_area.Width / 80)) : Math.Max(2, (int)(_area.Height / 36)));
|
||||
var pen = GetHairline("Brush.Stroke");
|
||||
var faint = GetBrush("Brush.TextFaint");
|
||||
var scale = PixelScale;
|
||||
for (var i = 0; i < ticks.Count; i++)
|
||||
{
|
||||
var label = CreateText(Format(ticks[i]), LabelSize, faint);
|
||||
if (horizontal)
|
||||
{
|
||||
var x = PixelGrid.SnapLine(_area.Left + _area.Width * ticks[i] / max, pen.Thickness, scale);
|
||||
dc.DrawLine(pen, new Point(x, _area.Top), new Point(x, _area.Bottom));
|
||||
dc.DrawText(label, new Point(Math.Min(x - label.Width / 2, ActualWidth - label.Width), _area.Bottom + 2));
|
||||
}
|
||||
else
|
||||
{
|
||||
var y = PixelGrid.SnapLine(_area.Bottom - _area.Height * ticks[i] / max, pen.Thickness, scale);
|
||||
dc.DrawLine(pen, new Point(_area.Left, y), new Point(_area.Right, y));
|
||||
dc.DrawText(label, new Point(_area.Left - 8 - label.Width, y - label.Height / 2));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private int HitTest(Point p)
|
||||
{
|
||||
var count = Items?.Count ?? 0;
|
||||
if (count == 0 || _area.IsEmpty || !(_pitch > 0)) return -1;
|
||||
var index = Orientation == Orientation.Horizontal
|
||||
? (int)Math.Floor((p.Y - _area.Top) / _pitch)
|
||||
: (int)Math.Floor((p.X - _area.Left) / _pitch);
|
||||
var inside = Orientation == Orientation.Horizontal ? p.X >= 0 && p.X <= ActualWidth : p.Y >= 0 && p.Y <= ActualHeight;
|
||||
return inside && index >= 0 && index < count ? index : -1;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,241 @@
|
||||
using System.Windows;
|
||||
using System.Windows.Input;
|
||||
using System.Windows.Media;
|
||||
using Titano.Core.Localization;
|
||||
|
||||
namespace Titano.Ui.Visuals;
|
||||
|
||||
/// <summary>
|
||||
/// Density grid (Archive: photos per month, one row per year × 12 months). Each value is a square cell in the
|
||||
/// brush colour whose opacity grows with the value; NaN cells ("no data", e.g. future months) use the card fill.
|
||||
/// Column labels sit above, row labels on the left, an optional min–max scale below. Hovering reads out the cell
|
||||
/// (its tooltip or "row column · value"); clicking raises <see cref="CellActivatedEvent"/>.
|
||||
/// </summary>
|
||||
public sealed class HeatmapStrip : DrawingElement
|
||||
{
|
||||
public static readonly DependencyProperty RowsProperty = DependencyProperty.Register(
|
||||
nameof(Rows), typeof(IReadOnlyList<ChartRow>), typeof(HeatmapStrip), new PropertyMetadata(null, OnDataPropertyChanged));
|
||||
|
||||
public static readonly DependencyProperty ColumnLabelsProperty = DependencyProperty.Register(
|
||||
nameof(ColumnLabels), typeof(IReadOnlyList<string>), typeof(HeatmapStrip), new PropertyMetadata(null, OnDataPropertyChanged));
|
||||
|
||||
public static readonly DependencyProperty BrushKeyProperty = DependencyProperty.Register(
|
||||
nameof(BrushKey), typeof(string), typeof(HeatmapStrip), new FrameworkPropertyMetadata("Brush.Accent", FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty MaximumProperty = DependencyProperty.Register(
|
||||
nameof(Maximum), typeof(double), typeof(HeatmapStrip), new FrameworkPropertyMetadata(double.NaN, FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty MinimumOpacityProperty = DependencyProperty.Register(
|
||||
nameof(MinimumOpacity), typeof(double), typeof(HeatmapStrip), new FrameworkPropertyMetadata(0.08, FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty MaxCellSizeProperty = DependencyProperty.Register(
|
||||
nameof(MaxCellSize), typeof(double), typeof(HeatmapStrip),
|
||||
new FrameworkPropertyMetadata(24.0, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure));
|
||||
|
||||
public static readonly DependencyProperty CellGapProperty = DependencyProperty.Register(
|
||||
nameof(CellGap), typeof(double), typeof(HeatmapStrip),
|
||||
new FrameworkPropertyMetadata(3.0, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure));
|
||||
|
||||
public static readonly DependencyProperty ShowScaleProperty = DependencyProperty.Register(
|
||||
nameof(ShowScale), typeof(bool), typeof(HeatmapStrip),
|
||||
new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure));
|
||||
|
||||
public static readonly DependencyProperty ValueFormatterProperty = DependencyProperty.Register(
|
||||
nameof(ValueFormatter), typeof(Func<double, string>), typeof(HeatmapStrip), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly RoutedEvent CellActivatedEvent = EventManager.RegisterRoutedEvent(
|
||||
nameof(CellActivated), RoutingStrategy.Bubble, typeof(ChartItemEventHandler), typeof(HeatmapStrip));
|
||||
|
||||
private const double LabelSize = 11;
|
||||
|
||||
private CellGridLayout _grid;
|
||||
private bool _hovering;
|
||||
|
||||
/// <summary>One row per year (label + 12 monthly values).</summary>
|
||||
public IReadOnlyList<ChartRow>? Rows { get => (IReadOnlyList<ChartRow>?)GetValue(RowsProperty); set => SetValue(RowsProperty, value); }
|
||||
|
||||
/// <summary>Column headers (culture-aware month initials); also fixes the column count.</summary>
|
||||
public IReadOnlyList<string>? ColumnLabels { get => (IReadOnlyList<string>?)GetValue(ColumnLabelsProperty); set => SetValue(ColumnLabelsProperty, value); }
|
||||
|
||||
public string BrushKey { get => (string)GetValue(BrushKeyProperty); set => SetValue(BrushKeyProperty, value); }
|
||||
|
||||
/// <summary>Value drawn at full opacity; NaN = the largest value.</summary>
|
||||
public double Maximum { get => (double)GetValue(MaximumProperty); set => SetValue(MaximumProperty, value); }
|
||||
|
||||
/// <summary>Opacity of a zero cell.</summary>
|
||||
public double MinimumOpacity { get => (double)GetValue(MinimumOpacityProperty); set => SetValue(MinimumOpacityProperty, value); }
|
||||
|
||||
public double MaxCellSize { get => (double)GetValue(MaxCellSizeProperty); set => SetValue(MaxCellSizeProperty, value); }
|
||||
|
||||
public double CellGap { get => (double)GetValue(CellGapProperty); set => SetValue(CellGapProperty, value); }
|
||||
|
||||
/// <summary>Min–max colour scale under the grid.</summary>
|
||||
public bool ShowScale { get => (bool)GetValue(ShowScaleProperty); set => SetValue(ShowScaleProperty, value); }
|
||||
|
||||
/// <summary>Culture-aware value formatting (scale ends and readouts).</summary>
|
||||
public Func<double, string>? ValueFormatter { get => (Func<double, string>?)GetValue(ValueFormatterProperty); set => SetValue(ValueFormatterProperty, value); }
|
||||
|
||||
public event ChartItemEventHandler CellActivated
|
||||
{
|
||||
add => AddHandler(CellActivatedEvent, value);
|
||||
remove => RemoveHandler(CellActivatedEvent, value);
|
||||
}
|
||||
|
||||
private int RowCount => Rows?.Count ?? 0;
|
||||
|
||||
private int ColumnCount
|
||||
{
|
||||
get
|
||||
{
|
||||
if (ColumnLabels is { Count: > 0 } labels) return labels.Count;
|
||||
var max = 0;
|
||||
if (Rows is { } rows)
|
||||
for (var r = 0; r < rows.Count; r++) max = Math.Max(max, rows[r].Values.Count);
|
||||
return max;
|
||||
}
|
||||
}
|
||||
|
||||
protected override Size MeasureOverride(Size availableSize)
|
||||
{
|
||||
if (RowCount == 0 || ColumnCount == 0) return new Size(0, 0);
|
||||
var layout = Layout(availableSize.Width, double.PositiveInfinity);
|
||||
return new Size(0, layout.Top + layout.Height + ScaleHeight());
|
||||
}
|
||||
|
||||
protected override void OnRender(DrawingContext dc)
|
||||
{
|
||||
DrawHitArea(dc);
|
||||
if (Rows is not { Count: > 0 } rows || ColumnCount == 0) return;
|
||||
_grid = Layout(ActualWidth, ActualHeight - ScaleHeight());
|
||||
var faint = GetBrush("Brush.TextFaint");
|
||||
var max = ScaleMaximum(rows);
|
||||
|
||||
if (ColumnLabels is { } columns)
|
||||
{
|
||||
for (var c = 0; c < columns.Count; c++)
|
||||
{
|
||||
var label = CreateText(columns[c], LabelSize, faint);
|
||||
var (x, _) = _grid.CellOrigin(0, c);
|
||||
dc.DrawText(label, new Point(x + (_grid.CellSize - label.Width) / 2, 0));
|
||||
}
|
||||
}
|
||||
|
||||
var fill = GetBrush(BrushKey);
|
||||
var empty = GetBrush("Brush.Card");
|
||||
var radius = Math.Min(2, _grid.CellSize / 4);
|
||||
for (var r = 0; r < rows.Count; r++)
|
||||
{
|
||||
var row = rows[r];
|
||||
var label = CreateText(row.Label, LabelSize, faint);
|
||||
var (_, y) = _grid.CellOrigin(r, 0);
|
||||
dc.DrawText(label, new Point(_grid.Left - 8 - label.Width, y + (_grid.CellSize - label.Height) / 2));
|
||||
for (var c = 0; c < _grid.Columns; c++)
|
||||
{
|
||||
var (x, _) = _grid.CellOrigin(r, c);
|
||||
var cell = new Rect(x, y, _grid.CellSize, _grid.CellSize);
|
||||
var value = c < row.Values.Count ? row.Values[c] : double.NaN;
|
||||
if (!double.IsFinite(value))
|
||||
{
|
||||
dc.DrawRoundedRectangle(empty, null, cell, radius, radius);
|
||||
continue;
|
||||
}
|
||||
dc.PushOpacity(MinimumOpacity + (1 - MinimumOpacity) * Math.Clamp(value / max, 0, 1));
|
||||
dc.DrawRoundedRectangle(fill, null, cell, radius, radius);
|
||||
dc.Pop();
|
||||
}
|
||||
}
|
||||
if (ShowScale) DrawScale(dc, fill, max);
|
||||
}
|
||||
|
||||
protected override void OnMouseMove(MouseEventArgs e)
|
||||
{
|
||||
base.OnMouseMove(e);
|
||||
var p = e.GetPosition(this);
|
||||
_hovering = _grid.TryHit(p.X, p.Y, out var row, out var column) && row < RowCount;
|
||||
Readout.Show(_hovering ? ReadoutText(row, column) : null, p);
|
||||
}
|
||||
|
||||
protected override void OnMouseLeave(MouseEventArgs e)
|
||||
{
|
||||
base.OnMouseLeave(e);
|
||||
_hovering = false;
|
||||
Readout.Hide();
|
||||
}
|
||||
|
||||
protected override void OnQueryCursor(QueryCursorEventArgs e)
|
||||
{
|
||||
base.OnQueryCursor(e);
|
||||
if (e.Handled || !_hovering) return;
|
||||
e.Cursor = Cursors.Hand;
|
||||
e.Handled = true;
|
||||
}
|
||||
|
||||
protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
|
||||
{
|
||||
base.OnMouseLeftButtonUp(e);
|
||||
var p = e.GetPosition(this);
|
||||
if (!_grid.TryHit(p.X, p.Y, out var row, out var column) || row >= RowCount) return;
|
||||
RaiseEvent(new ChartItemEventArgs(CellActivatedEvent, row, column));
|
||||
e.Handled = true;
|
||||
}
|
||||
|
||||
private string Format(double value) => (ValueFormatter ?? DefaultFormat)(value);
|
||||
|
||||
private static string DefaultFormat(double value) => value.ToString("N0", Loc.Culture);
|
||||
|
||||
private double LabelHeight() => Math.Ceiling(CreateText("0", LabelSize, Brushes.Transparent).Height);
|
||||
|
||||
private double ScaleHeight() => ShowScale ? LabelHeight() + 8 : 0;
|
||||
|
||||
private CellGridLayout Layout(double width, double height)
|
||||
{
|
||||
var faint = Brushes.Transparent;
|
||||
var labelWidth = 0.0;
|
||||
if (Rows is { } rows)
|
||||
for (var r = 0; r < rows.Count; r++) labelWidth = Math.Max(labelWidth, CreateText(rows[r].Label, LabelSize, faint).Width);
|
||||
var left = Math.Ceiling(labelWidth) + 8;
|
||||
var top = ColumnLabels is { Count: > 0 } ? LabelHeight() + 4 : 0;
|
||||
var cell = CellGridLayout.FitCellSize(width - left, height - top, RowCount, ColumnCount, CellGap, MaxCellSize);
|
||||
return new CellGridLayout(left, top, RowCount, ColumnCount, cell, CellGap);
|
||||
}
|
||||
|
||||
private double ScaleMaximum(IReadOnlyList<ChartRow> rows)
|
||||
{
|
||||
if (double.IsFinite(Maximum) && Maximum > 0) return Maximum;
|
||||
var max = 0.0;
|
||||
for (var r = 0; r < rows.Count; r++)
|
||||
{
|
||||
var values = rows[r].Values;
|
||||
for (var c = 0; c < values.Count; c++)
|
||||
if (double.IsFinite(values[c])) max = Math.Max(max, values[c]);
|
||||
}
|
||||
return max > 0 ? max : 1;
|
||||
}
|
||||
|
||||
/// <summary>"min ▭ max" right-aligned under the grid, with a gradient from the zero opacity to full colour.</summary>
|
||||
private void DrawScale(DrawingContext dc, Brush fill, double max)
|
||||
{
|
||||
var muted = GetBrush("Brush.TextMuted");
|
||||
var low = CreateText(Format(0), LabelSize, muted);
|
||||
var high = CreateText(Format(max), LabelSize, muted);
|
||||
var right = _grid.Left + _grid.Width;
|
||||
var y = _grid.Top + _grid.Height + 8;
|
||||
var x = right - high.Width;
|
||||
dc.DrawText(high, new Point(x, y));
|
||||
x -= 66;
|
||||
var color = fill is SolidColorBrush solid ? solid.Color : Colors.Transparent;
|
||||
var gradient = new LinearGradientBrush(Color.FromArgb((byte)(color.A * MinimumOpacity), color.R, color.G, color.B), color, 0);
|
||||
gradient.Freeze();
|
||||
dc.DrawRoundedRectangle(gradient, null, new Rect(x, y + (high.Height - 8) / 2, 60, 8), 2, 2);
|
||||
dc.DrawText(low, new Point(x - 6 - low.Width, y));
|
||||
}
|
||||
|
||||
private string ReadoutText(int row, int column)
|
||||
{
|
||||
var data = Rows![row];
|
||||
if (data.ToolTips is { } tips && column < tips.Count && !string.IsNullOrEmpty(tips[column])) return tips[column]!;
|
||||
var value = column < data.Values.Count ? data.Values[column] : double.NaN;
|
||||
var columnLabel = ColumnLabels is { } labels && column < labels.Count ? " " + labels[column] : string.Empty;
|
||||
return data.Label + columnLabel + (double.IsFinite(value) ? " · " + Format(value) : string.Empty);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,428 @@
|
||||
using System.Text;
|
||||
using System.Windows;
|
||||
using System.Windows.Input;
|
||||
using System.Windows.Media;
|
||||
using Titano.Core.Localization;
|
||||
|
||||
namespace Titano.Ui.Visuals;
|
||||
|
||||
/// <summary>
|
||||
/// Per-frame line chart of the editor (BRIEF §12.3: measured luminance in Sun, target curve in Accent, sky region
|
||||
/// dashed in Region…). Draws a legend row (series titles or <see cref="Legend"/>, plus a right-aligned
|
||||
/// <see cref="Summary"/>), gridlines on nice Y ticks with labels, dashed vertical markers, and every series
|
||||
/// decimated to at most two points per device-pixel column so 100k+ frames stay fast. The playhead follows
|
||||
/// <see cref="CurrentIndex"/>; clicking or dragging in the plot seeks; hovering shows a crosshair, dots on the
|
||||
/// series and a readout tooltip with the values under the cursor. The Y range is automatic with padding unless
|
||||
/// <see cref="YMinimum"/>/<see cref="YMaximum"/> are set.
|
||||
/// </summary>
|
||||
public sealed class SeriesChart : DrawingElement
|
||||
{
|
||||
public static readonly DependencyProperty SeriesProperty = DependencyProperty.Register(
|
||||
nameof(Series), typeof(IReadOnlyList<ChartSeries>), typeof(SeriesChart), new PropertyMetadata(null, OnDataPropertyChanged));
|
||||
|
||||
public static readonly DependencyProperty MarkersProperty = DependencyProperty.Register(
|
||||
nameof(Markers), typeof(IReadOnlyList<TimelineMarker>), typeof(SeriesChart), new PropertyMetadata(null, OnDataPropertyChanged));
|
||||
|
||||
public static readonly DependencyProperty LegendProperty = DependencyProperty.Register(
|
||||
nameof(Legend), typeof(IReadOnlyList<ChartLegendItem>), typeof(SeriesChart), new PropertyMetadata(null, OnDataPropertyChanged));
|
||||
|
||||
public static readonly DependencyProperty SummaryProperty = DependencyProperty.Register(
|
||||
nameof(Summary), typeof(string), typeof(SeriesChart), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty ShowLegendProperty = DependencyProperty.Register(
|
||||
nameof(ShowLegend), typeof(bool), typeof(SeriesChart), new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty ShowYLabelsProperty = DependencyProperty.Register(
|
||||
nameof(ShowYLabels), typeof(bool), typeof(SeriesChart), new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty CurrentIndexProperty = DependencyProperty.Register(
|
||||
nameof(CurrentIndex), typeof(int), typeof(SeriesChart),
|
||||
new FrameworkPropertyMetadata(-1, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnOverlayPropertyChanged));
|
||||
|
||||
public static readonly DependencyProperty IsSeekEnabledProperty = DependencyProperty.Register(
|
||||
nameof(IsSeekEnabled), typeof(bool), typeof(SeriesChart), new PropertyMetadata(true));
|
||||
|
||||
public static readonly DependencyProperty YMinimumProperty = DependencyProperty.Register(
|
||||
nameof(YMinimum), typeof(double), typeof(SeriesChart), new FrameworkPropertyMetadata(double.NaN, FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty YMaximumProperty = DependencyProperty.Register(
|
||||
nameof(YMaximum), typeof(double), typeof(SeriesChart), new FrameworkPropertyMetadata(double.NaN, FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty YPaddingProperty = DependencyProperty.Register(
|
||||
nameof(YPadding), typeof(double), typeof(SeriesChart), new FrameworkPropertyMetadata(0.08, FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty YLabelFormatterProperty = DependencyProperty.Register(
|
||||
nameof(YLabelFormatter), typeof(Func<double, string>), typeof(SeriesChart), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty XLabelFormatterProperty = DependencyProperty.Register(
|
||||
nameof(XLabelFormatter), typeof(Func<double, string>), typeof(SeriesChart), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure));
|
||||
|
||||
private const double LabelSize = 11;
|
||||
private const double LegendHeight = 24;
|
||||
private const double XAxisHeight = 18;
|
||||
|
||||
private int[] _decimated = [];
|
||||
private Rect _plot;
|
||||
private double _yLow;
|
||||
private double _yHigh = 1;
|
||||
private int _count;
|
||||
private double _dataMin;
|
||||
private double _dataMax;
|
||||
private int _hover = -1;
|
||||
private string? _hoverText;
|
||||
private bool _dragging;
|
||||
|
||||
public SeriesChart()
|
||||
: base(hasOverlay: true)
|
||||
{
|
||||
}
|
||||
|
||||
/// <summary>Lines to draw; replace the list (or use an observable collection) to update.</summary>
|
||||
public IReadOnlyList<ChartSeries>? Series { get => (IReadOnlyList<ChartSeries>?)GetValue(SeriesProperty); set => SetValue(SeriesProperty, value); }
|
||||
|
||||
/// <summary>Frame markers drawn as dashed vertical lines in the marker colour.</summary>
|
||||
public IReadOnlyList<TimelineMarker>? Markers { get => (IReadOnlyList<TimelineMarker>?)GetValue(MarkersProperty); set => SetValue(MarkersProperty, value); }
|
||||
|
||||
/// <summary>Explicit legend entries; null lists the titled series.</summary>
|
||||
public IReadOnlyList<ChartLegendItem>? Legend { get => (IReadOnlyList<ChartLegendItem>?)GetValue(LegendProperty); set => SetValue(LegendProperty, value); }
|
||||
|
||||
/// <summary>Right-aligned text of the legend row (e.g. "flicker −67 % · max step 0.21 EV").</summary>
|
||||
public string? Summary { get => (string?)GetValue(SummaryProperty); set => SetValue(SummaryProperty, value); }
|
||||
|
||||
public bool ShowLegend { get => (bool)GetValue(ShowLegendProperty); set => SetValue(ShowLegendProperty, value); }
|
||||
|
||||
public bool ShowYLabels { get => (bool)GetValue(ShowYLabelsProperty); set => SetValue(ShowYLabelsProperty, value); }
|
||||
|
||||
/// <summary>Playhead frame (two-way); −1 hides it.</summary>
|
||||
public int CurrentIndex { get => (int)GetValue(CurrentIndexProperty); set => SetValue(CurrentIndexProperty, value); }
|
||||
|
||||
/// <summary>Whether clicking or dragging sets <see cref="CurrentIndex"/>.</summary>
|
||||
public bool IsSeekEnabled { get => (bool)GetValue(IsSeekEnabledProperty); set => SetValue(IsSeekEnabledProperty, value); }
|
||||
|
||||
/// <summary>Fixed bottom of the Y axis; NaN = automatic.</summary>
|
||||
public double YMinimum { get => (double)GetValue(YMinimumProperty); set => SetValue(YMinimumProperty, value); }
|
||||
|
||||
/// <summary>Fixed top of the Y axis; NaN = automatic.</summary>
|
||||
public double YMaximum { get => (double)GetValue(YMaximumProperty); set => SetValue(YMaximumProperty, value); }
|
||||
|
||||
/// <summary>Fraction of the data span added above and below an automatic range.</summary>
|
||||
public double YPadding { get => (double)GetValue(YPaddingProperty); set => SetValue(YPaddingProperty, value); }
|
||||
|
||||
/// <summary>Culture-aware formatting of values (axis labels and readout).</summary>
|
||||
public Func<double, string>? YLabelFormatter { get => (Func<double, string>?)GetValue(YLabelFormatterProperty); set => SetValue(YLabelFormatterProperty, value); }
|
||||
|
||||
/// <summary>Formatting of frame indices (readout header and, when set, X axis labels).</summary>
|
||||
public Func<double, string>? XLabelFormatter { get => (Func<double, string>?)GetValue(XLabelFormatterProperty); set => SetValue(XLabelFormatterProperty, value); }
|
||||
|
||||
protected override Size MeasureOverride(Size availableSize) => new(0, 160);
|
||||
|
||||
protected override void OnDataChanged()
|
||||
{
|
||||
_count = 0;
|
||||
_dataMin = double.PositiveInfinity;
|
||||
_dataMax = double.NegativeInfinity;
|
||||
if (Series is { } series)
|
||||
{
|
||||
for (var s = 0; s < series.Count; s++)
|
||||
{
|
||||
var values = series[s].Values.Span;
|
||||
_count = Math.Max(_count, values.Length);
|
||||
for (var i = 0; i < values.Length; i++)
|
||||
{
|
||||
var v = values[i];
|
||||
if (!double.IsFinite(v)) continue;
|
||||
if (v < _dataMin) _dataMin = v;
|
||||
if (v > _dataMax) _dataMax = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
_hover = -1;
|
||||
_hoverText = null;
|
||||
base.OnDataChanged();
|
||||
}
|
||||
|
||||
protected override void OnRender(DrawingContext dc)
|
||||
{
|
||||
DrawHitArea(dc);
|
||||
var size = RenderSize;
|
||||
var scale = PixelScale;
|
||||
var top = ShowLegend ? DrawLegendRow(dc, size.Width) : 0;
|
||||
var bottom = size.Height - (XLabelFormatter is null ? 0 : XAxisHeight);
|
||||
(_yLow, _yHigh) = YRange();
|
||||
|
||||
var ticks = NiceScale.Inner(_yLow, _yHigh, Math.Max(2, (int)((bottom - top) / 36)));
|
||||
var format = YLabelFormatter ?? DefaultFormat;
|
||||
var labels = new FormattedText?[ticks.Count];
|
||||
var labelWidth = 0.0;
|
||||
if (ShowYLabels)
|
||||
{
|
||||
var labelBrush = GetBrush("Brush.TextFaint");
|
||||
for (var i = 0; i < ticks.Count; i++)
|
||||
{
|
||||
labels[i] = CreateText(format(ticks[i]), LabelSize, labelBrush);
|
||||
labelWidth = Math.Max(labelWidth, labels[i]!.Width);
|
||||
}
|
||||
}
|
||||
var left = labelWidth > 0 ? Math.Ceiling(labelWidth) + 8 : 0;
|
||||
_plot = new Rect(left, top, Math.Max(0, size.Width - left), Math.Max(0, bottom - top));
|
||||
if (_plot.Width < 1 || _plot.Height < 1)
|
||||
{
|
||||
RenderOverlay();
|
||||
return;
|
||||
}
|
||||
|
||||
var grid = GetHairline("Brush.Stroke");
|
||||
for (var i = 0; i < ticks.Count; i++)
|
||||
{
|
||||
var y = PixelGrid.SnapLine(Y(ticks[i]), grid.Thickness, scale);
|
||||
dc.DrawLine(grid, new Point(_plot.Left, y), new Point(_plot.Right, y));
|
||||
if (labels[i] is { } label) dc.DrawText(label, new Point(left - 8 - label.Width, y - label.Height / 2));
|
||||
}
|
||||
if (XLabelFormatter is { } xFormat) DrawXLabels(dc, xFormat);
|
||||
DrawMarkers(dc, scale);
|
||||
|
||||
dc.PushClip(new RectangleGeometry(_plot));
|
||||
if (Series is { } series)
|
||||
for (var s = 0; s < series.Count; s++) DrawSeries(dc, series[s], scale);
|
||||
dc.Pop();
|
||||
RenderOverlay();
|
||||
}
|
||||
|
||||
protected override void OnRenderOverlay(DrawingContext dc)
|
||||
{
|
||||
if (_plot.Width < 1 || _count == 0) return;
|
||||
var scale = PixelScale;
|
||||
if (_hover >= 0)
|
||||
{
|
||||
var hair = GetHairline("Brush.TextFaint");
|
||||
var x = PixelGrid.SnapLine(X(_hover), hair.Thickness, scale);
|
||||
dc.DrawLine(hair, new Point(x, _plot.Top), new Point(x, _plot.Bottom));
|
||||
if (Series is { } series)
|
||||
{
|
||||
for (var s = 0; s < series.Count; s++)
|
||||
{
|
||||
var values = series[s].Values.Span;
|
||||
if (_hover >= values.Length || !double.IsFinite(values[_hover])) continue;
|
||||
dc.DrawEllipse(GetBrush(series[s].BrushKey), null, new Point(X(_hover), Y(values[_hover])), 3, 3);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (CurrentIndex >= 0 && CurrentIndex < _count)
|
||||
{
|
||||
var pen = GetHairline("Brush.Accent");
|
||||
var x = PixelGrid.SnapLine(X(CurrentIndex), pen.Thickness, scale);
|
||||
dc.DrawLine(pen, new Point(x, _plot.Top), new Point(x, _plot.Bottom));
|
||||
}
|
||||
}
|
||||
|
||||
protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
|
||||
{
|
||||
base.OnMouseLeftButtonDown(e);
|
||||
var p = e.GetPosition(this);
|
||||
if (!IsSeekEnabled || _count == 0 || !_plot.Contains(p)) return;
|
||||
_dragging = CaptureMouse();
|
||||
SetCurrentValue(CurrentIndexProperty, IndexAt(p.X));
|
||||
e.Handled = true;
|
||||
}
|
||||
|
||||
protected override void OnMouseMove(MouseEventArgs e)
|
||||
{
|
||||
base.OnMouseMove(e);
|
||||
var p = e.GetPosition(this);
|
||||
if (_dragging) SetCurrentValue(CurrentIndexProperty, IndexAt(p.X));
|
||||
if (_count == 0 || !_plot.Contains(p))
|
||||
{
|
||||
ClearHover();
|
||||
return;
|
||||
}
|
||||
var index = IndexAt(p.X);
|
||||
if (index != _hover)
|
||||
{
|
||||
_hover = index;
|
||||
_hoverText = ReadoutText(index, p.X);
|
||||
RenderOverlay();
|
||||
}
|
||||
Readout.Show(_hoverText, p);
|
||||
}
|
||||
|
||||
protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
|
||||
{
|
||||
base.OnMouseLeftButtonUp(e);
|
||||
if (_dragging) ReleaseMouseCapture();
|
||||
}
|
||||
|
||||
protected override void OnLostMouseCapture(MouseEventArgs e)
|
||||
{
|
||||
base.OnLostMouseCapture(e);
|
||||
_dragging = false;
|
||||
}
|
||||
|
||||
protected override void OnMouseLeave(MouseEventArgs e)
|
||||
{
|
||||
base.OnMouseLeave(e);
|
||||
ClearHover();
|
||||
}
|
||||
|
||||
private static string DefaultFormat(double value) => value.ToString("G4", Loc.Culture);
|
||||
|
||||
private static void OnOverlayPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) => ((SeriesChart)d).RenderOverlay();
|
||||
|
||||
private (double Low, double High) YRange()
|
||||
{
|
||||
var (low, high) = _dataMin <= _dataMax ? NiceScale.Pad(_dataMin, _dataMax, YPadding) : (0.0, 1.0);
|
||||
if (double.IsFinite(YMinimum)) low = YMinimum;
|
||||
if (double.IsFinite(YMaximum)) high = YMaximum;
|
||||
return high > low ? (low, high) : NiceScale.Pad(low, low, 0);
|
||||
}
|
||||
|
||||
private double X(double index) => _count <= 1 ? _plot.Left + _plot.Width / 2 : _plot.Left + index * _plot.Width / (_count - 1);
|
||||
|
||||
private double Y(double value) => _plot.Bottom - (value - _yLow) / (_yHigh - _yLow) * _plot.Height;
|
||||
|
||||
private int IndexAt(double x)
|
||||
{
|
||||
if (_count <= 1 || _plot.Width <= 0) return 0;
|
||||
return (int)Math.Clamp(Math.Round((x - _plot.Left) / _plot.Width * (_count - 1)), 0, _count - 1);
|
||||
}
|
||||
|
||||
/// <summary>Draws the legend row and returns the plot top.</summary>
|
||||
private double DrawLegendRow(DrawingContext dc, double width)
|
||||
{
|
||||
var items = Legend ?? AutoLegend();
|
||||
if (items.Count == 0 && string.IsNullOrEmpty(Summary)) return 0;
|
||||
var right = width;
|
||||
if (!string.IsNullOrEmpty(Summary))
|
||||
{
|
||||
var summary = CreateText(Summary, LabelSize, GetBrush("Brush.TextMuted"));
|
||||
right -= summary.Width;
|
||||
dc.DrawText(summary, new Point(right, 0));
|
||||
right -= 16;
|
||||
}
|
||||
DrawLegend(dc, items, new Point(0, 0), right, LabelSize);
|
||||
return LegendHeight;
|
||||
}
|
||||
|
||||
private List<ChartLegendItem> AutoLegend()
|
||||
{
|
||||
var items = new List<ChartLegendItem>();
|
||||
if (Series is not { } series) return items;
|
||||
for (var s = 0; s < series.Count; s++)
|
||||
{
|
||||
var item = series[s];
|
||||
if (!item.ShowInLegend || string.IsNullOrEmpty(item.Title)) continue;
|
||||
var swatch = item.Dash switch
|
||||
{
|
||||
LineDash.Dashed => LegendSwatch.DashedLine,
|
||||
LineDash.Dotted => LegendSwatch.DottedLine,
|
||||
_ => LegendSwatch.Line,
|
||||
};
|
||||
items.Add(new ChartLegendItem(item.Title, item.BrushKey, swatch));
|
||||
}
|
||||
return items;
|
||||
}
|
||||
|
||||
private void DrawXLabels(DrawingContext dc, Func<double, string> format)
|
||||
{
|
||||
if (_count < 2) return;
|
||||
var ticks = NiceScale.Inner(0, _count - 1, Math.Max(2, (int)(_plot.Width / 90)));
|
||||
var brush = GetBrush("Brush.TextFaint");
|
||||
var lastRight = double.NegativeInfinity;
|
||||
for (var i = 0; i < ticks.Count; i++)
|
||||
{
|
||||
var v = ticks[i];
|
||||
if (Math.Abs(v - Math.Round(v)) > 1e-9) continue;
|
||||
var text = CreateText(format(v), LabelSize, brush);
|
||||
var x = Math.Clamp(X(v) - text.Width / 2, 0, Math.Max(0, ActualWidth - text.Width));
|
||||
if (x < lastRight + 8) continue;
|
||||
dc.DrawText(text, new Point(x, _plot.Bottom + 4));
|
||||
lastRight = x + text.Width;
|
||||
}
|
||||
}
|
||||
|
||||
private void DrawMarkers(DrawingContext dc, double scale)
|
||||
{
|
||||
if (Markers is not { Count: > 0 } markers) return;
|
||||
var thickness = PixelGrid.SnapThickness(1, scale);
|
||||
for (var i = 0; i < markers.Count; i++)
|
||||
{
|
||||
var m = markers[i];
|
||||
if (m.Index < 0 || m.Index >= _count) continue;
|
||||
var pen = GetPen(TimelineMarker.BrushKeyOf(m.Kind), thickness, LineDash.Dashed);
|
||||
var x = PixelGrid.SnapLine(X(m.Index), thickness, scale);
|
||||
dc.DrawLine(pen, new Point(x, _plot.Top), new Point(x, _plot.Bottom));
|
||||
}
|
||||
}
|
||||
|
||||
private void DrawSeries(DrawingContext dc, ChartSeries series, double scale)
|
||||
{
|
||||
var values = series.Values.Span;
|
||||
if (values.Length == 0) return;
|
||||
var columns = Math.Max(1, (int)Math.Ceiling(_plot.Width * scale));
|
||||
var capacity = MinMaxDecimator.Capacity(values.Length, columns);
|
||||
if (_decimated.Length < capacity) _decimated = new int[capacity];
|
||||
var n = MinMaxDecimator.Decimate(values, columns, _decimated);
|
||||
|
||||
var geometry = new StreamGeometry();
|
||||
using (var ctx = geometry.Open())
|
||||
{
|
||||
var open = false;
|
||||
for (var k = 0; k < n; k++)
|
||||
{
|
||||
var i = _decimated[k];
|
||||
if (i == MinMaxDecimator.Gap)
|
||||
{
|
||||
open = false;
|
||||
continue;
|
||||
}
|
||||
var p = new Point(X(i), Y(values[i]));
|
||||
if (open)
|
||||
{
|
||||
ctx.LineTo(p, true, true);
|
||||
}
|
||||
else
|
||||
{
|
||||
ctx.BeginFigure(p, false, false);
|
||||
open = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
geometry.Freeze();
|
||||
dc.DrawGeometry(null, GetPen(series.BrushKey, series.Thickness, series.Dash), geometry);
|
||||
}
|
||||
|
||||
private string? ReadoutText(int index, double x)
|
||||
{
|
||||
var format = YLabelFormatter ?? DefaultFormat;
|
||||
var text = new StringBuilder(XLabelFormatter?.Invoke(index) ?? index.ToString("N0", Loc.Culture));
|
||||
if (Series is { } series)
|
||||
{
|
||||
for (var s = 0; s < series.Count; s++)
|
||||
{
|
||||
var values = series[s].Values.Span;
|
||||
if (index >= values.Length || !double.IsFinite(values[index])) continue;
|
||||
text.AppendLine();
|
||||
if (!string.IsNullOrEmpty(series[s].Title)) text.Append(series[s].Title).Append(": ");
|
||||
text.Append(format(values[index]));
|
||||
}
|
||||
}
|
||||
if (Markers is { } markers)
|
||||
{
|
||||
for (var i = 0; i < markers.Count; i++)
|
||||
{
|
||||
var m = markers[i];
|
||||
if (string.IsNullOrEmpty(m.Label) || m.Index < 0 || m.Index >= _count || Math.Abs(X(m.Index) - x) > 4) continue;
|
||||
text.AppendLine().Append(m.Label);
|
||||
}
|
||||
}
|
||||
return text.ToString();
|
||||
}
|
||||
|
||||
private void ClearHover()
|
||||
{
|
||||
Readout.Hide();
|
||||
if (_hover < 0) return;
|
||||
_hover = -1;
|
||||
_hoverText = null;
|
||||
RenderOverlay();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,203 @@
|
||||
using System.Windows;
|
||||
using System.Windows.Input;
|
||||
using System.Windows.Media;
|
||||
using Titano.Core.Localization;
|
||||
|
||||
namespace Titano.Ui.Visuals;
|
||||
|
||||
/// <summary>
|
||||
/// One bar split into proportional segments (by camera, by format) with a wrapping legend underneath
|
||||
/// ("■ label share"). Segments share one theme colour and fade by rank (items may set their own brush), so no new
|
||||
/// colours are introduced; 2-px gaps separate them. Hovering a segment or legend entry reads it out; clicking
|
||||
/// raises <see cref="ItemActivatedEvent"/>.
|
||||
/// </summary>
|
||||
public sealed class StackedBar : DrawingElement
|
||||
{
|
||||
public static readonly DependencyProperty ItemsProperty = DependencyProperty.Register(
|
||||
nameof(Items), typeof(IReadOnlyList<ChartItem>), typeof(StackedBar), new PropertyMetadata(null, OnDataPropertyChanged));
|
||||
|
||||
public static readonly DependencyProperty BrushKeyProperty = DependencyProperty.Register(
|
||||
nameof(BrushKey), typeof(string), typeof(StackedBar), new FrameworkPropertyMetadata("Brush.Accent", FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty BarHeightProperty = DependencyProperty.Register(
|
||||
nameof(BarHeight), typeof(double), typeof(StackedBar),
|
||||
new FrameworkPropertyMetadata(12.0, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure));
|
||||
|
||||
public static readonly DependencyProperty ShowLegendProperty = DependencyProperty.Register(
|
||||
nameof(ShowLegend), typeof(bool), typeof(StackedBar),
|
||||
new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure));
|
||||
|
||||
public static readonly DependencyProperty ShareFormatterProperty = DependencyProperty.Register(
|
||||
nameof(ShareFormatter), typeof(Func<double, string>), typeof(StackedBar),
|
||||
new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure));
|
||||
|
||||
public static readonly RoutedEvent ItemActivatedEvent = EventManager.RegisterRoutedEvent(
|
||||
nameof(ItemActivated), RoutingStrategy.Bubble, typeof(ChartItemEventHandler), typeof(StackedBar));
|
||||
|
||||
private const double LabelSize = 11;
|
||||
private const double SegmentGap = 2;
|
||||
private const double LegendGap = 10;
|
||||
private const double LegendLine = 18;
|
||||
private const double EntryGap = 14;
|
||||
|
||||
private readonly List<Rect> _segments = [];
|
||||
private readonly List<Rect> _entries = [];
|
||||
private int _hover = -1;
|
||||
|
||||
/// <summary>Parts in display order (largest first reads best).</summary>
|
||||
public IReadOnlyList<ChartItem>? Items { get => (IReadOnlyList<ChartItem>?)GetValue(ItemsProperty); set => SetValue(ItemsProperty, value); }
|
||||
|
||||
public string BrushKey { get => (string)GetValue(BrushKeyProperty); set => SetValue(BrushKeyProperty, value); }
|
||||
|
||||
public double BarHeight { get => (double)GetValue(BarHeightProperty); set => SetValue(BarHeightProperty, value); }
|
||||
|
||||
public bool ShowLegend { get => (bool)GetValue(ShowLegendProperty); set => SetValue(ShowLegendProperty, value); }
|
||||
|
||||
/// <summary>Formats a share 0…1 for the legend (default: culture percent without decimals).</summary>
|
||||
public Func<double, string>? ShareFormatter { get => (Func<double, string>?)GetValue(ShareFormatterProperty); set => SetValue(ShareFormatterProperty, value); }
|
||||
|
||||
public event ChartItemEventHandler ItemActivated
|
||||
{
|
||||
add => AddHandler(ItemActivatedEvent, value);
|
||||
remove => RemoveHandler(ItemActivatedEvent, value);
|
||||
}
|
||||
|
||||
protected override Size MeasureOverride(Size availableSize)
|
||||
{
|
||||
if (Items is not { Count: > 0 } items) return new Size(0, 0);
|
||||
var lines = ShowLegend ? LayoutLegend(items, availableSize.Width, null) : 0;
|
||||
return new Size(0, BarHeight + (lines > 0 ? LegendGap + lines * LegendLine : 0));
|
||||
}
|
||||
|
||||
protected override void OnDataChanged()
|
||||
{
|
||||
_hover = -1;
|
||||
base.OnDataChanged();
|
||||
}
|
||||
|
||||
protected override void OnRender(DrawingContext dc)
|
||||
{
|
||||
DrawHitArea(dc);
|
||||
_segments.Clear();
|
||||
_entries.Clear();
|
||||
if (Items is not { Count: > 0 } items) return;
|
||||
var total = Total(items);
|
||||
var width = ActualWidth;
|
||||
var radius = Math.Min(3, BarHeight / 2);
|
||||
dc.PushClip(new RectangleGeometry(new Rect(0, 0, width, BarHeight), radius, radius));
|
||||
dc.DrawRectangle(GetBrush("Brush.Track"), null, new Rect(0, 0, width, BarHeight));
|
||||
var available = Math.Max(0, width - SegmentGap * (items.Count - 1));
|
||||
var x = 0.0;
|
||||
for (var i = 0; i < items.Count; i++)
|
||||
{
|
||||
var share = total > 0 ? Math.Max(0, items[i].Value) / total : 0;
|
||||
var segment = new Rect(x, 0, available * share, BarHeight);
|
||||
_segments.Add(segment);
|
||||
dc.PushOpacity(OpacityOf(i, items));
|
||||
dc.DrawRectangle(GetBrush(items[i].BrushKey ?? BrushKey), null, segment);
|
||||
dc.Pop();
|
||||
x = segment.Right + SegmentGap;
|
||||
}
|
||||
dc.Pop();
|
||||
if (ShowLegend) LayoutLegend(items, width, dc);
|
||||
}
|
||||
|
||||
protected override void OnMouseMove(MouseEventArgs e)
|
||||
{
|
||||
base.OnMouseMove(e);
|
||||
var p = e.GetPosition(this);
|
||||
_hover = HitTest(p);
|
||||
Readout.Show(_hover >= 0 ? ReadoutText(_hover) : null, p);
|
||||
}
|
||||
|
||||
protected override void OnMouseLeave(MouseEventArgs e)
|
||||
{
|
||||
base.OnMouseLeave(e);
|
||||
_hover = -1;
|
||||
Readout.Hide();
|
||||
}
|
||||
|
||||
protected override void OnQueryCursor(QueryCursorEventArgs e)
|
||||
{
|
||||
base.OnQueryCursor(e);
|
||||
if (e.Handled || _hover < 0) return;
|
||||
e.Cursor = Cursors.Hand;
|
||||
e.Handled = true;
|
||||
}
|
||||
|
||||
protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
|
||||
{
|
||||
base.OnMouseLeftButtonUp(e);
|
||||
var index = HitTest(e.GetPosition(this));
|
||||
if (index < 0) return;
|
||||
RaiseEvent(new ChartItemEventArgs(ItemActivatedEvent, index, -1));
|
||||
e.Handled = true;
|
||||
}
|
||||
|
||||
private static double Total(IReadOnlyList<ChartItem> items)
|
||||
{
|
||||
var total = 0.0;
|
||||
for (var i = 0; i < items.Count; i++) total += Math.Max(0, items[i].Value);
|
||||
return total;
|
||||
}
|
||||
|
||||
/// <summary>Rank fade 1 → 0.35 for items in the shared colour; items with their own brush stay opaque.</summary>
|
||||
private static double OpacityOf(int index, IReadOnlyList<ChartItem> items) =>
|
||||
items[index].BrushKey is not null || items.Count < 2 ? 1 : 1 - 0.65 * index / (items.Count - 1);
|
||||
|
||||
private string Share(double share) => ShareFormatter?.Invoke(share) ?? share.ToString("P0", Loc.Culture);
|
||||
|
||||
/// <summary>Flows legend entries into lines of the given width; draws them when <paramref name="dc"/> is set. Returns the line count.</summary>
|
||||
private int LayoutLegend(IReadOnlyList<ChartItem> items, double width, DrawingContext? dc)
|
||||
{
|
||||
var total = Total(items);
|
||||
var muted = GetBrush("Brush.TextMuted");
|
||||
var text = GetBrush("Brush.Text");
|
||||
double x = 0;
|
||||
var line = 0;
|
||||
var top = BarHeight + LegendGap;
|
||||
for (var i = 0; i < items.Count; i++)
|
||||
{
|
||||
var label = CreateText(items[i].Label, LabelSize, muted);
|
||||
var value = CreateText(items[i].ValueText ?? Share(total > 0 ? Math.Max(0, items[i].Value) / total : 0), LabelSize, text);
|
||||
var entryWidth = 8 + 6 + label.Width + 4 + value.Width;
|
||||
if (x > 0 && double.IsFinite(width) && x + entryWidth > width)
|
||||
{
|
||||
x = 0;
|
||||
line++;
|
||||
}
|
||||
if (dc is not null)
|
||||
{
|
||||
var y = top + line * LegendLine;
|
||||
var cy = y + label.Height / 2;
|
||||
dc.PushOpacity(OpacityOf(i, items));
|
||||
dc.DrawRoundedRectangle(GetBrush(items[i].BrushKey ?? BrushKey), null, new Rect(x, cy - 4, 8, 8), 2, 2);
|
||||
dc.Pop();
|
||||
dc.DrawText(label, new Point(x + 14, y));
|
||||
dc.DrawText(value, new Point(x + 14 + label.Width + 4, y));
|
||||
_entries.Add(new Rect(x, y, entryWidth, LegendLine));
|
||||
}
|
||||
x += entryWidth + EntryGap;
|
||||
}
|
||||
return line + 1;
|
||||
}
|
||||
|
||||
private int HitTest(Point p)
|
||||
{
|
||||
for (var i = 0; i < _segments.Count; i++)
|
||||
if (p.Y >= 0 && p.Y <= BarHeight && p.X >= _segments[i].Left && p.X <= _segments[i].Right + SegmentGap) return i;
|
||||
for (var i = 0; i < _entries.Count; i++)
|
||||
if (_entries[i].Contains(p)) return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
private string ReadoutText(int index)
|
||||
{
|
||||
var items = Items!;
|
||||
var item = items[index];
|
||||
if (item.ToolTip is not null) return item.ToolTip;
|
||||
var total = Total(items);
|
||||
var share = Share(total > 0 ? Math.Max(0, item.Value) / total : 0);
|
||||
return item.Label + " · " + (item.ValueText is null ? share : item.ValueText + " · " + share);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,202 @@
|
||||
using System.Windows;
|
||||
using System.Windows.Input;
|
||||
using System.Windows.Media;
|
||||
using Titano.Core.Localization;
|
||||
|
||||
namespace Titano.Ui.Visuals;
|
||||
|
||||
/// <summary>
|
||||
/// Library timeline mode (BRIEF §12.2): one band per year with its label on the left and a density bar per slot
|
||||
/// (month) on a scale shared by all bands, slot labels underneath and a divider between bands. The current slot
|
||||
/// (<see cref="CurrentBand"/>, <see cref="CurrentSlot"/>) is outlined in Accent; clicking a slot makes it current
|
||||
/// and raises <see cref="SlotActivatedEvent"/>. Desired height = bands × <see cref="BandHeight"/>, so the control
|
||||
/// scrolls inside a ScrollViewer.
|
||||
/// </summary>
|
||||
public sealed class TimelineBands : DrawingElement
|
||||
{
|
||||
public static readonly DependencyProperty BandsProperty = DependencyProperty.Register(
|
||||
nameof(Bands), typeof(IReadOnlyList<ChartRow>), typeof(TimelineBands), new PropertyMetadata(null, OnDataPropertyChanged));
|
||||
|
||||
public static readonly DependencyProperty SlotLabelsProperty = DependencyProperty.Register(
|
||||
nameof(SlotLabels), typeof(IReadOnlyList<string>), typeof(TimelineBands), new PropertyMetadata(null, OnDataPropertyChanged));
|
||||
|
||||
public static readonly DependencyProperty BrushKeyProperty = DependencyProperty.Register(
|
||||
nameof(BrushKey), typeof(string), typeof(TimelineBands), new FrameworkPropertyMetadata("Brush.Accent", FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty BandHeightProperty = DependencyProperty.Register(
|
||||
nameof(BandHeight), typeof(double), typeof(TimelineBands),
|
||||
new FrameworkPropertyMetadata(64.0, FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure), v => v is double d && d >= 24);
|
||||
|
||||
public static readonly DependencyProperty CurrentBandProperty = DependencyProperty.Register(
|
||||
nameof(CurrentBand), typeof(int), typeof(TimelineBands),
|
||||
new FrameworkPropertyMetadata(-1, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault | FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty CurrentSlotProperty = DependencyProperty.Register(
|
||||
nameof(CurrentSlot), typeof(int), typeof(TimelineBands),
|
||||
new FrameworkPropertyMetadata(-1, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault | FrameworkPropertyMetadataOptions.AffectsRender));
|
||||
|
||||
public static readonly DependencyProperty ValueFormatterProperty = DependencyProperty.Register(
|
||||
nameof(ValueFormatter), typeof(Func<double, string>), typeof(TimelineBands), new PropertyMetadata(null));
|
||||
|
||||
public static readonly RoutedEvent SlotActivatedEvent = EventManager.RegisterRoutedEvent(
|
||||
nameof(SlotActivated), RoutingStrategy.Bubble, typeof(ChartItemEventHandler), typeof(TimelineBands));
|
||||
|
||||
private const double LabelColumn = 64;
|
||||
private const double LabelSize = 11;
|
||||
|
||||
private (int Band, int Slot) _hover = (-1, -1);
|
||||
|
||||
/// <summary>One band per year: label + one value per slot.</summary>
|
||||
public IReadOnlyList<ChartRow>? Bands { get => (IReadOnlyList<ChartRow>?)GetValue(BandsProperty); set => SetValue(BandsProperty, value); }
|
||||
|
||||
/// <summary>Slot captions (culture-aware month initials); also fixes the slot count.</summary>
|
||||
public IReadOnlyList<string>? SlotLabels { get => (IReadOnlyList<string>?)GetValue(SlotLabelsProperty); set => SetValue(SlotLabelsProperty, value); }
|
||||
|
||||
public string BrushKey { get => (string)GetValue(BrushKeyProperty); set => SetValue(BrushKeyProperty, value); }
|
||||
|
||||
public double BandHeight { get => (double)GetValue(BandHeightProperty); set => SetValue(BandHeightProperty, value); }
|
||||
|
||||
/// <summary>Band of the current slot (two-way); −1 = none.</summary>
|
||||
public int CurrentBand { get => (int)GetValue(CurrentBandProperty); set => SetValue(CurrentBandProperty, value); }
|
||||
|
||||
/// <summary>Current slot inside <see cref="CurrentBand"/> (two-way); −1 = none.</summary>
|
||||
public int CurrentSlot { get => (int)GetValue(CurrentSlotProperty); set => SetValue(CurrentSlotProperty, value); }
|
||||
|
||||
/// <summary>Culture-aware value formatting for readouts.</summary>
|
||||
public Func<double, string>? ValueFormatter { get => (Func<double, string>?)GetValue(ValueFormatterProperty); set => SetValue(ValueFormatterProperty, value); }
|
||||
|
||||
public event ChartItemEventHandler SlotActivated
|
||||
{
|
||||
add => AddHandler(SlotActivatedEvent, value);
|
||||
remove => RemoveHandler(SlotActivatedEvent, value);
|
||||
}
|
||||
|
||||
private int SlotCount
|
||||
{
|
||||
get
|
||||
{
|
||||
if (SlotLabels is { Count: > 0 } labels) return labels.Count;
|
||||
var max = 0;
|
||||
if (Bands is { } bands)
|
||||
for (var b = 0; b < bands.Count; b++) max = Math.Max(max, bands[b].Values.Count);
|
||||
return max;
|
||||
}
|
||||
}
|
||||
|
||||
private double SlotPitch => SlotCount == 0 ? 0 : Math.Max(0, ActualWidth - LabelColumn) / SlotCount;
|
||||
|
||||
protected override Size MeasureOverride(Size availableSize) => new(0, (Bands?.Count ?? 0) * BandHeight);
|
||||
|
||||
protected override void OnDataChanged()
|
||||
{
|
||||
_hover = (-1, -1);
|
||||
base.OnDataChanged();
|
||||
}
|
||||
|
||||
protected override void OnRender(DrawingContext dc)
|
||||
{
|
||||
DrawHitArea(dc);
|
||||
if (Bands is not { Count: > 0 } bands || SlotCount == 0) return;
|
||||
var slots = SlotCount;
|
||||
var pitch = SlotPitch;
|
||||
var scale = PixelScale;
|
||||
var max = 0.0;
|
||||
for (var b = 0; b < bands.Count; b++)
|
||||
for (var s = 0; s < bands[b].Values.Count; s++)
|
||||
if (double.IsFinite(bands[b].Values[s])) max = Math.Max(max, bands[b].Values[s]);
|
||||
if (max <= 0) max = 1;
|
||||
|
||||
var text = GetBrush("Brush.Text");
|
||||
var faint = GetBrush("Brush.TextFaint");
|
||||
var fill = GetBrush(BrushKey);
|
||||
var divider = GetHairline("Brush.Stroke");
|
||||
var captionHeight = Math.Ceiling(CreateText("0", LabelSize, faint).Height);
|
||||
var barWidth = Math.Max(1, Math.Min(pitch * 0.6, 28));
|
||||
|
||||
for (var b = 0; b < bands.Count; b++)
|
||||
{
|
||||
var band = bands[b];
|
||||
var top = b * BandHeight;
|
||||
var baseline = top + BandHeight - captionHeight - 8;
|
||||
var barSpace = baseline - top - 8;
|
||||
var title = CreateText(band.Label, 13, text, semiBold: true);
|
||||
dc.DrawText(title, new Point(0, top + (BandHeight - title.Height) / 2));
|
||||
for (var s = 0; s < slots; s++)
|
||||
{
|
||||
var cx = LabelColumn + pitch * (s + 0.5);
|
||||
var value = s < band.Values.Count ? band.Values[s] : double.NaN;
|
||||
if (double.IsFinite(value) && value > 0)
|
||||
{
|
||||
var h = Math.Max(1, barSpace * Math.Clamp(value / max, 0, 1));
|
||||
dc.DrawRoundedRectangle(fill, null, new Rect(cx - barWidth / 2, baseline - h, barWidth, h), 2, 2);
|
||||
}
|
||||
if (SlotLabels is { } labels && s < labels.Count)
|
||||
{
|
||||
var caption = CreateText(labels[s], LabelSize, faint);
|
||||
dc.DrawText(caption, new Point(cx - caption.Width / 2, baseline + 4));
|
||||
}
|
||||
if (b == CurrentBand && s == CurrentSlot)
|
||||
dc.DrawRoundedRectangle(null, GetPen("Brush.Accent", 1.5), new Rect(cx - pitch / 2 + 2, top + 4, pitch - 4, BandHeight - 8), 4, 4);
|
||||
}
|
||||
if (b < bands.Count - 1)
|
||||
{
|
||||
var y = PixelGrid.SnapLine(top + BandHeight, divider.Thickness, scale);
|
||||
dc.DrawLine(divider, new Point(0, y), new Point(ActualWidth, y));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected override void OnMouseMove(MouseEventArgs e)
|
||||
{
|
||||
base.OnMouseMove(e);
|
||||
var p = e.GetPosition(this);
|
||||
_hover = HitTest(p);
|
||||
Readout.Show(_hover.Band >= 0 ? ReadoutText(_hover.Band, _hover.Slot) : null, p);
|
||||
}
|
||||
|
||||
protected override void OnMouseLeave(MouseEventArgs e)
|
||||
{
|
||||
base.OnMouseLeave(e);
|
||||
_hover = (-1, -1);
|
||||
Readout.Hide();
|
||||
}
|
||||
|
||||
protected override void OnQueryCursor(QueryCursorEventArgs e)
|
||||
{
|
||||
base.OnQueryCursor(e);
|
||||
if (e.Handled || _hover.Band < 0) return;
|
||||
e.Cursor = Cursors.Hand;
|
||||
e.Handled = true;
|
||||
}
|
||||
|
||||
protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
|
||||
{
|
||||
base.OnMouseLeftButtonUp(e);
|
||||
var (band, slot) = HitTest(e.GetPosition(this));
|
||||
if (band < 0) return;
|
||||
SetCurrentValue(CurrentBandProperty, band);
|
||||
SetCurrentValue(CurrentSlotProperty, slot);
|
||||
RaiseEvent(new ChartItemEventArgs(SlotActivatedEvent, band, slot));
|
||||
e.Handled = true;
|
||||
}
|
||||
|
||||
private (int Band, int Slot) HitTest(Point p)
|
||||
{
|
||||
var count = Bands?.Count ?? 0;
|
||||
var pitch = SlotPitch;
|
||||
if (count == 0 || pitch <= 0 || p.X < LabelColumn) return (-1, -1);
|
||||
var band = (int)Math.Floor(p.Y / BandHeight);
|
||||
var slot = (int)Math.Floor((p.X - LabelColumn) / pitch);
|
||||
return band >= 0 && band < count && slot >= 0 && slot < SlotCount ? (band, slot) : (-1, -1);
|
||||
}
|
||||
|
||||
private string ReadoutText(int band, int slot)
|
||||
{
|
||||
var row = Bands![band];
|
||||
if (row.ToolTips is { } tips && slot < tips.Count && !string.IsNullOrEmpty(tips[slot])) return tips[slot]!;
|
||||
var value = slot < row.Values.Count ? row.Values[slot] : double.NaN;
|
||||
var caption = SlotLabels is { } labels && slot < labels.Count ? " " + labels[slot] : string.Empty;
|
||||
var format = ValueFormatter ?? (v => v.ToString("N0", Loc.Culture));
|
||||
return row.Label + caption + (double.IsFinite(value) ? " · " + format(value) : string.Empty);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user