From 661be6c94bb7dd5de938b9b8ded6e4e9a9db5658 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 10:03:20 +0000 Subject: [PATCH 01/13] feat(ui-visuals): add layout, scale, decimation, viewport and curve math kernels WPF-free geometry behind the visual controls: wrapped-grid layout with O(1) index/offset mapping and keyboard targets, nice axis ticks, min/max decimation, zoom/pan transforms, monotone curve editing rules, filmstrip and heatmap cell layout, an LRU cache and device-pixel snapping, with tests. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- src/Titano.Ui/Visuals/CurveMath.cs | 77 ++++++++ src/Titano.Ui/Visuals/LruCache.cs | 81 ++++++++ src/Titano.Ui/Visuals/MinMaxDecimator.cs | 80 ++++++++ src/Titano.Ui/Visuals/NiceScale.cs | 91 +++++++++ src/Titano.Ui/Visuals/PixelGrid.cs | 32 ++++ src/Titano.Ui/Visuals/StripLayout.cs | 123 ++++++++++++ src/Titano.Ui/Visuals/ViewportMath.cs | 70 +++++++ src/Titano.Ui/Visuals/WrapLayout.cs | 180 ++++++++++++++++++ .../Visuals/CurveMathTests.cs | 85 +++++++++ .../Titano.App.Tests/Visuals/LruCacheTests.cs | 59 ++++++ .../Visuals/MinMaxDecimatorTests.cs | 106 +++++++++++ .../Visuals/NiceScaleTests.cs | 91 +++++++++ .../Visuals/PixelGridTests.cs | 34 ++++ .../Visuals/StripLayoutTests.cs | 85 +++++++++ .../Visuals/ViewportMathTests.cs | 72 +++++++ .../Visuals/WrapLayoutTests.cs | 144 ++++++++++++++ 16 files changed, 1410 insertions(+) create mode 100644 src/Titano.Ui/Visuals/CurveMath.cs create mode 100644 src/Titano.Ui/Visuals/LruCache.cs create mode 100644 src/Titano.Ui/Visuals/MinMaxDecimator.cs create mode 100644 src/Titano.Ui/Visuals/NiceScale.cs create mode 100644 src/Titano.Ui/Visuals/PixelGrid.cs create mode 100644 src/Titano.Ui/Visuals/StripLayout.cs create mode 100644 src/Titano.Ui/Visuals/ViewportMath.cs create mode 100644 src/Titano.Ui/Visuals/WrapLayout.cs create mode 100644 tests/Titano.App.Tests/Visuals/CurveMathTests.cs create mode 100644 tests/Titano.App.Tests/Visuals/LruCacheTests.cs create mode 100644 tests/Titano.App.Tests/Visuals/MinMaxDecimatorTests.cs create mode 100644 tests/Titano.App.Tests/Visuals/NiceScaleTests.cs create mode 100644 tests/Titano.App.Tests/Visuals/PixelGridTests.cs create mode 100644 tests/Titano.App.Tests/Visuals/StripLayoutTests.cs create mode 100644 tests/Titano.App.Tests/Visuals/ViewportMathTests.cs create mode 100644 tests/Titano.App.Tests/Visuals/WrapLayoutTests.cs diff --git a/src/Titano.Ui/Visuals/CurveMath.cs b/src/Titano.Ui/Visuals/CurveMath.cs new file mode 100644 index 00000000..846ce462 --- /dev/null +++ b/src/Titano.Ui/Visuals/CurveMath.cs @@ -0,0 +1,77 @@ +namespace Titano.Ui.Visuals; + +/// +/// Editing rules of in normalised [0, 1]² space: control points stay ordered by X with +/// a minimum gap, optionally with the end points pinned to X = 0 and X = 1 (time remap). +/// +public static class CurveMath +{ + /// Default minimum X distance between two control points. + public const double DefaultMinGap = 0.001; + + /// + /// X the point may take when dragged to : strictly between its + /// neighbours (by at least ), inside [0, 1], and fixed at 0 or 1 for the end points + /// when . + /// + public static double ConstrainX(ReadOnlySpan xs, int index, double proposedX, double minGap, bool pinEnds) + { + var n = xs.Length; + if (index < 0 || index >= n) throw new ArgumentOutOfRangeException(nameof(index)); + if (pinEnds && n > 1) + { + if (index == 0) return 0; + if (index == n - 1) return 1; + } + var gap = Math.Max(0, minGap); + var low = index > 0 ? xs[index - 1] + gap : 0; + var high = index < n - 1 ? xs[index + 1] - gap : 1; + low = Math.Max(0, low); + high = Math.Min(1, high); + if (low > high) return Math.Clamp((low + high) / 2, 0, 1); + return Math.Clamp(double.IsNaN(proposedX) ? xs[index] : proposedX, low, high); + } + + /// Clamps a Y value to [0, 1]. + public static double ConstrainY(double y) => double.IsNaN(y) ? 0 : Math.Clamp(y, 0, 1); + + /// + /// Index at which a new point at keeps ascending, or −1 when it would + /// sit closer than to an existing point, outside [0, 1], or outside the pinned ends. + /// + public static int InsertionIndex(ReadOnlySpan xs, double x, double minGap, bool pinEnds) + { + if (double.IsNaN(x) || x < 0 || x > 1) return -1; + var gap = Math.Max(0, minGap); + var index = 0; + while (index < xs.Length && xs[index] < x) index++; + if (index > 0 && x - xs[index - 1] < gap) return -1; + if (index < xs.Length && xs[index] - x < gap) return -1; + if (pinEnds && xs.Length >= 2 && (index == 0 || index == xs.Length)) return -1; + return index; + } + + /// Whether point may be deleted: two points always remain and pinned ends stay. + public static bool CanRemove(int count, int index, bool pinEnds) => + count > 2 && index >= 0 && index < count && (!pinEnds || (index > 0 && index < count - 1)); + + /// Index of the point nearest to (, ) within , or −1; coordinates in one space. + public static int HitTest(ReadOnlySpan xs, ReadOnlySpan ys, double x, double y, double radius) + { + var best = -1; + var bestDistance = radius * radius; + var n = Math.Min(xs.Length, ys.Length); + for (var i = 0; i < n; i++) + { + var dx = xs[i] - x; + var dy = ys[i] - y; + var d = dx * dx + dy * dy; + if (d <= bestDistance) + { + bestDistance = d; + best = i; + } + } + return best; + } +} diff --git a/src/Titano.Ui/Visuals/LruCache.cs b/src/Titano.Ui/Visuals/LruCache.cs new file mode 100644 index 00000000..49d43d35 --- /dev/null +++ b/src/Titano.Ui/Visuals/LruCache.cs @@ -0,0 +1,81 @@ +namespace Titano.Ui.Visuals; + +/// Fixed-capacity map that evicts the least recently used entry (decoded thumbnails). +public sealed class LruCache + where TKey : notnull +{ + private readonly Dictionary>> _map; + private readonly LinkedList> _order = new(); + private int _capacity; + + public LruCache(int capacity) + { + ArgumentOutOfRangeException.ThrowIfLessThan(capacity, 1); + _capacity = capacity; + _map = new Dictionary>>(capacity); + } + + public int Count => _map.Count; + + /// Maximum entries; lowering it evicts the oldest entries at once. + public int Capacity + { + get => _capacity; + set + { + ArgumentOutOfRangeException.ThrowIfLessThan(value, 1); + _capacity = value; + Trim(); + } + } + + /// Looks up and marks it as the most recently used. + public bool TryGet(TKey key, out TValue value) + { + if (_map.TryGetValue(key, out var node)) + { + _order.Remove(node); + _order.AddFirst(node); + value = node.Value.Value; + return true; + } + value = default!; + return false; + } + + /// Inserts or replaces as the most recently used entry. + public void Set(TKey key, TValue value) + { + if (_map.TryGetValue(key, out var node)) + { + _order.Remove(node); + node.Value = new KeyValuePair(key, value); + _order.AddFirst(node); + return; + } + _map[key] = _order.AddFirst(new KeyValuePair(key, value)); + Trim(); + } + + public bool Remove(TKey key) + { + if (!_map.Remove(key, out var node)) return false; + _order.Remove(node); + return true; + } + + public void Clear() + { + _map.Clear(); + _order.Clear(); + } + + private void Trim() + { + while (_map.Count > _capacity && _order.Last is { } oldest) + { + _order.RemoveLast(); + _map.Remove(oldest.Value.Key); + } + } +} diff --git a/src/Titano.Ui/Visuals/MinMaxDecimator.cs b/src/Titano.Ui/Visuals/MinMaxDecimator.cs new file mode 100644 index 00000000..4152d027 --- /dev/null +++ b/src/Titano.Ui/Visuals/MinMaxDecimator.cs @@ -0,0 +1,80 @@ +namespace Titano.Ui.Visuals; + +/// +/// Reduces a long series to at most two samples per pixel column (its minimum and maximum, in index order) so a +/// line over 100k+ points draws in time proportional to the plot width while every spike stays visible. +/// +public static class MinMaxDecimator +{ + /// Index written to the output where the line must break (a run without finite samples). + public const int Gap = -1; + + /// Output capacity needed for samples over columns. + public static int Capacity(int count, int columns) => Math.Max(0, Math.Min(count, 2 * Math.Max(1, columns))); + + /// + /// Writes ascending sample indices to draw into and returns how many were written. + /// When the series has at most two samples per column every finite sample is kept; otherwise each column + /// keeps the indices of its minimum and maximum. Non-finite samples are skipped and a run of them (or a + /// column without any finite sample) becomes one entry. + /// + public static int Decimate(ReadOnlySpan values, int columns, Span output) + { + columns = Math.Max(1, columns); + var n = values.Length; + if (output.Length < Capacity(n, columns)) + throw new ArgumentException("Output span is smaller than Capacity(count, columns).", nameof(output)); + + var written = 0; + if (n <= 2 * columns) + { + for (var i = 0; i < n; i++) + { + if (double.IsFinite(values[i])) output[written++] = i; + else if (written > 0 && output[written - 1] != Gap) output[written++] = Gap; + } + return Trim(output, written); + } + + for (var c = 0; c < columns; c++) + { + var start = (int)((long)c * n / columns); + var end = (int)((long)(c + 1) * n / columns); + int minIndex = -1, maxIndex = -1; + double min = double.PositiveInfinity, max = double.NegativeInfinity; + for (var i = start; i < end; i++) + { + var v = values[i]; + if (!double.IsFinite(v)) continue; + if (v < min) + { + min = v; + minIndex = i; + } + if (v > max) + { + max = v; + maxIndex = i; + } + } + if (minIndex < 0) + { + if (written > 0 && output[written - 1] != Gap) output[written++] = Gap; + continue; + } + if (minIndex == maxIndex) + { + output[written++] = minIndex; + } + else + { + output[written++] = Math.Min(minIndex, maxIndex); + output[written++] = Math.Max(minIndex, maxIndex); + } + } + return Trim(output, written); + } + + /// A trailing gap carries no information. + private static int Trim(Span output, int written) => written > 0 && output[written - 1] == Gap ? written - 1 : written; +} diff --git a/src/Titano.Ui/Visuals/NiceScale.cs b/src/Titano.Ui/Visuals/NiceScale.cs new file mode 100644 index 00000000..64c0648f --- /dev/null +++ b/src/Titano.Ui/Visuals/NiceScale.cs @@ -0,0 +1,91 @@ +namespace Titano.Ui.Visuals; + +/// Evenly spaced axis ticks: , + , … up to . +public readonly record struct AxisTicks(double First, double Last, double Step) +{ + /// Number of ticks (0 when the scale is empty). + public int Count => Step > 0 && Last >= First ? (int)Math.Round((Last - First) / Step) + 1 : 0; + + /// Value of tick , computed from integer multiples of the step to limit drift. + public double this[int i] => (Math.Round(First / Step) + i) * Step; +} + +/// "Nice" numbers for axes (1, 2, 5 × 10ⁿ), padded data ranges and tick placement. +public static class NiceScale +{ + /// + /// Heckbert's nice number: the 1/2/5 × 10ⁿ value closest to when + /// , otherwise the smallest one that is ≥ . + /// + public static double NiceNumber(double value, bool round) + { + if (!double.IsFinite(value) || value <= 0) return 1; + var exponent = Math.Floor(Math.Log10(value)); + var magnitude = Math.Pow(10, exponent); + var fraction = value / magnitude; + double nice; + if (round) + nice = fraction < 1.5 ? 1 : fraction < 3 ? 2 : fraction < 7 ? 5 : 10; + else + nice = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10; + return nice * magnitude; + } + + /// Nice tick step giving at most (≥ 2) ticks inside [min, max]. + public static double Step(double min, double max, int maxTicks) + { + var span = max - min; + if (!double.IsFinite(span) || span <= 0) return 1; + var intervals = Math.Max(2, maxTicks) - 1; + var step = NiceNumber(NiceNumber(span, false) / intervals, true); + // Rounding the step down can overshoot the budget (e.g. 1/7 → 0.1); climb the 1-2-5 ladder until it fits. + while (span / step > intervals + 1e-9) step = NextNice(step); + return step; + } + + /// Ticks inside [min, max] (none outside), for gridlines over a fixed data range. + public static AxisTicks Inner(double min, double max, int maxTicks) + { + if (!double.IsFinite(min) || !double.IsFinite(max) || max <= min) return default; + var step = Step(min, max, maxTicks); + var first = Math.Ceiling(min / step - 1e-9) * step; + var last = Math.Floor(max / step + 1e-9) * step; + return last < first ? default : new AxisTicks(first, last, step); + } + + /// Range widened outward to whole steps, for axes that should start and end on a tick (e.g. bars from zero). + public static AxisTicks Outer(double min, double max, int maxTicks) + { + if (!double.IsFinite(min) || !double.IsFinite(max)) return default; + if (max <= min) (min, max) = Expand(min); + var step = Step(min, max, maxTicks); + return new AxisTicks(Math.Floor(min / step + 1e-9) * step, Math.Ceiling(max / step - 1e-9) * step, step); + } + + /// + /// Data range padded by of its span on both sides; a flat range is widened around + /// its value so the line sits in the middle. + /// + public static (double Min, double Max) Pad(double min, double max, double fraction) + { + if (!double.IsFinite(min) || !double.IsFinite(max)) return (0, 1); + if (max < min) (min, max) = (max, min); + if (max == min) return Expand(min); + var pad = (max - min) * Math.Max(0, fraction); + return (min - pad, max + pad); + } + + /// The next value of the 1-2-5 ladder above . + private static double NextNice(double step) + { + var magnitude = Math.Pow(10, Math.Floor(Math.Log10(step))); + var fraction = step / magnitude; + return (fraction < 1.5 ? 2 : fraction < 3.5 ? 5 : 10) * magnitude; + } + + private static (double Min, double Max) Expand(double v) + { + var half = v == 0 ? 1 : Math.Abs(v) * 0.1; + return (v - half, v + half); + } +} diff --git a/src/Titano.Ui/Visuals/PixelGrid.cs b/src/Titano.Ui/Visuals/PixelGrid.cs new file mode 100644 index 00000000..99ce0114 --- /dev/null +++ b/src/Titano.Ui/Visuals/PixelGrid.cs @@ -0,0 +1,32 @@ +namespace Titano.Ui.Visuals; + +/// Device-pixel alignment for drawn lines and edges (scale = device pixels per DIP). +public static class PixelGrid +{ + /// Rounds to the nearest device-pixel boundary. + public static double Snap(double value, double scale) + { + if (!(scale > 0) || !double.IsFinite(value)) return value; + return Math.Round(value * scale) / scale; + } + + /// + /// Position of the centre of a line DIPs wide drawn at so it + /// covers whole device pixels: odd pixel widths sit on pixel centres, even ones on pixel boundaries. + /// + public static double SnapLine(double value, double thickness, double scale) + { + if (!(scale > 0) || !double.IsFinite(value)) return value; + var pixels = Math.Max(1, Math.Round(thickness * scale)); + var device = value * scale; + var snapped = pixels % 2 == 1 ? Math.Floor(device) + 0.5 : Math.Round(device); + return snapped / scale; + } + + /// Line thickness in DIPs that renders as whole device pixels (at least one). + public static double SnapThickness(double thickness, double scale) + { + if (!(scale > 0)) return thickness; + return Math.Max(1, Math.Round(thickness * scale)) / scale; + } +} diff --git a/src/Titano.Ui/Visuals/StripLayout.cs b/src/Titano.Ui/Visuals/StripLayout.cs new file mode 100644 index 00000000..80d554d1 --- /dev/null +++ b/src/Titano.Ui/Visuals/StripLayout.cs @@ -0,0 +1,123 @@ +namespace Titano.Ui.Visuals; + +/// +/// Cells of a filmstrip: as many cells of about the target width as fit, each standing for a contiguous run of +/// frames and showing the frame in the middle of its run; X positions map continuously to frames for seeking. +/// +public readonly struct StripLayout +{ + public StripLayout(double width, double targetCellWidth, double gap, int frameCount) + { + Width = double.IsFinite(width) ? Math.Max(0, width) : 0; + Gap = double.IsFinite(gap) ? Math.Max(0, gap) : 0; + FrameCount = Math.Max(0, frameCount); + var target = double.IsFinite(targetCellWidth) && targetCellWidth > 1 ? targetCellWidth : 1; + CellCount = FrameCount == 0 || Width <= 0 + ? 0 + : (int)Math.Min(FrameCount, Math.Max(1, Math.Floor((Width + Gap) / (target + Gap)))); + CellWidth = CellCount == 0 ? 0 : Math.Max(0, (Width - Gap * (CellCount - 1)) / CellCount); + } + + public double Width { get; } + + public double Gap { get; } + + public int FrameCount { get; } + + public int CellCount { get; } + + public double CellWidth { get; } + + public double CellLeft(int cell) => cell * (CellWidth + Gap); + + /// Cell whose run contains . + public int CellForFrame(int frame) + { + if (CellCount == 0) return -1; + return (int)((long)Math.Clamp(frame, 0, FrameCount - 1) * CellCount / FrameCount); + } + + /// Frame shown by : the middle of the frames that map to it. + public int FrameForCell(int cell) + { + if (CellCount == 0) return -1; + cell = Math.Clamp(cell, 0, CellCount - 1); + var first = FirstFrame(cell); + var last = FirstFrame(cell + 1) - 1; + return first + (last - first) / 2; + } + + /// Frame under (continuous across cells and gaps), clamped to the sequence. + public int FrameAt(double x) + { + if (FrameCount == 0 || Width <= 0) return -1; + return (int)Math.Clamp(Math.Floor(x / Width * FrameCount), 0, FrameCount - 1); + } + + /// Centre X of on the continuous frame axis. + public double XForFrame(double frame) => FrameCount == 0 ? 0 : (frame + 0.5) / FrameCount * Width; + + /// Smallest frame f with CellForFrame(f) = cell, i.e. ⌈cell · frames / cells⌉. + private int FirstFrame(int cell) => (int)(((long)cell * FrameCount + CellCount - 1) / CellCount); +} + +/// A grid of square cells with gaps (heatmap): cell origins and hit testing that excludes the gaps. +public readonly struct CellGridLayout +{ + public CellGridLayout(double left, double top, int rows, int columns, double cellSize, double gap) + { + Left = left; + Top = top; + Rows = Math.Max(0, rows); + Columns = Math.Max(0, columns); + CellSize = Math.Max(0, cellSize); + Gap = Math.Max(0, gap); + } + + public double Left { get; } + + public double Top { get; } + + public int Rows { get; } + + public int Columns { get; } + + public double CellSize { get; } + + public double Gap { get; } + + public double Pitch => CellSize + Gap; + + public double Width => Columns == 0 ? 0 : Columns * Pitch - Gap; + + public double Height => Rows == 0 ? 0 : Rows * Pitch - Gap; + + public (double X, double Y) CellOrigin(int row, int column) => (Left + column * Pitch, Top + row * Pitch); + + /// Largest square cell (≤ ) letting the grid fit in width × height. + public static double FitCellSize(double width, double height, int rows, int columns, double gap, double maxCell) + { + if (rows <= 0 || columns <= 0) return 0; + var byWidth = double.IsFinite(width) ? (width - gap * (columns - 1)) / columns : double.PositiveInfinity; + var byHeight = double.IsFinite(height) ? (height - gap * (rows - 1)) / rows : double.PositiveInfinity; + var size = Math.Min(Math.Min(byWidth, byHeight), maxCell); + return double.IsFinite(size) ? Math.Max(0, size) : Math.Max(0, maxCell); + } + + /// Cell under (, ); false over gaps and outside the grid. + public bool TryHit(double x, double y, out int row, out int column) + { + row = column = -1; + if (Rows == 0 || Columns == 0 || CellSize <= 0) return false; + var dx = x - Left; + var dy = y - Top; + if (dx < 0 || dy < 0) return false; + var c = (int)Math.Floor(dx / Pitch); + var r = (int)Math.Floor(dy / Pitch); + if (c >= Columns || r >= Rows) return false; + if (dx - c * Pitch > CellSize || dy - r * Pitch > CellSize) return false; + row = r; + column = c; + return true; + } +} diff --git a/src/Titano.Ui/Visuals/ViewportMath.cs b/src/Titano.Ui/Visuals/ViewportMath.cs new file mode 100644 index 00000000..3a5c67f6 --- /dev/null +++ b/src/Titano.Ui/Visuals/ViewportMath.cs @@ -0,0 +1,70 @@ +namespace Titano.Ui.Visuals; + +/// Uniform scale and translation from image pixels to view units: view = image × + offset. +public readonly record struct ViewTransform(double Scale, double OffsetX, double OffsetY) +{ + public (double X, double Y) ToView(double x, double y) => (x * Scale + OffsetX, y * Scale + OffsetY); + + public (double X, double Y) ToImage(double x, double y) => ((x - OffsetX) / Scale, (y - OffsetY) / Scale); +} + +/// Zoom and pan math of the preview: fit, zoom around a fixed point, panning limits and pixel alignment. +public static class ViewportMath +{ + /// Largest scale at which the whole image fits the view (0 when either is empty). + public static double FitScale(double imageWidth, double imageHeight, double viewWidth, double viewHeight) + { + if (!(imageWidth > 0) || !(imageHeight > 0) || !(viewWidth > 0) || !(viewHeight > 0)) return 0; + return Math.Min(viewWidth / imageWidth, viewHeight / imageHeight); + } + + /// The image at , centred in the view. + public static ViewTransform Centered(double scale, double imageWidth, double imageHeight, double viewWidth, double viewHeight) => + new(scale, (viewWidth - imageWidth * scale) / 2, (viewHeight - imageHeight * scale) / 2); + + /// + /// Changes the scale to keeping the image point under (, + /// ) where it is. + /// + public static ViewTransform ZoomAt(ViewTransform t, double scale, double viewX, double viewY) + { + if (!(t.Scale > 0) || !(scale > 0)) return t; + var k = scale / t.Scale; + return new ViewTransform(scale, viewX - (viewX - t.OffsetX) * k, viewY - (viewY - t.OffsetY) * k); + } + + /// + /// Keeps the image covering the view on each axis where it is larger than the view, and centred on each axis + /// where it is smaller, so panning can never lose the picture. + /// + public static ViewTransform Clamp(ViewTransform t, double imageWidth, double imageHeight, double viewWidth, double viewHeight) => + t with + { + OffsetX = ClampAxis(t.OffsetX, imageWidth * t.Scale, viewWidth), + OffsetY = ClampAxis(t.OffsetY, imageHeight * t.Scale, viewHeight), + }; + + /// Moves the offset by (, ) view units. + public static ViewTransform Pan(ViewTransform t, double dx, double dy) => t with { OffsetX = t.OffsetX + dx, OffsetY = t.OffsetY + dy }; + + /// Rounds the offset to whole device pixels ( device pixels per view unit) so 1:1 shows raw pixels. + public static ViewTransform SnapOffset(ViewTransform t, double pixelsPerUnit) + { + if (!(pixelsPerUnit > 0)) return t; + return t with + { + OffsetX = Math.Round(t.OffsetX * pixelsPerUnit) / pixelsPerUnit, + OffsetY = Math.Round(t.OffsetY * pixelsPerUnit) / pixelsPerUnit, + }; + } + + /// Next zoom level for a wheel movement of (positive = in), by a factor of 1.25 per notch. + public static double WheelZoom(double scale, double notches, double minScale, double maxScale) => + Math.Clamp(scale * Math.Pow(1.25, notches), minScale, maxScale); + + private static double ClampAxis(double offset, double size, double view) + { + if (size <= view) return (view - size) / 2; + return Math.Clamp(offset, view - size, 0); + } +} diff --git a/src/Titano.Ui/Visuals/WrapLayout.cs b/src/Titano.Ui/Visuals/WrapLayout.cs new file mode 100644 index 00000000..52a26cab --- /dev/null +++ b/src/Titano.Ui/Visuals/WrapLayout.cs @@ -0,0 +1,180 @@ +namespace Titano.Ui.Visuals; + +/// Keyboard steps inside a wrapped grid. +public enum WrapStep +{ + Left, + Right, + Up, + Down, + PageUp, + PageDown, + First, + Last, +} + +/// +/// Geometry of a grid of fixed-size items wrapped into rows: O(1) mapping between item index, row, column and +/// pixel offset, visible ranges, minimal scroll to reveal an item and keyboard navigation targets. +/// +public readonly struct WrapLayout +{ + private const double Epsilon = 1e-9; + + /// Number of items. + /// Width available for the rows; infinite puts every item on one row. + /// Slot width of one item. + /// Slot height of one item. + /// Gap between columns and between rows. + /// Spread the leftover width over the column gaps so the grid spans the viewport. + public WrapLayout(int itemCount, double viewportWidth, double itemWidth, double itemHeight, double spacing, bool justify = false) + { + ItemCount = Math.Max(0, itemCount); + ItemWidth = Positive(itemWidth); + ItemHeight = Positive(itemHeight); + Spacing = double.IsFinite(spacing) ? Math.Max(0, spacing) : 0; + var finiteWidth = double.IsFinite(viewportWidth); + Columns = finiteWidth ? ColumnsFor(viewportWidth, ItemWidth, Spacing) : Math.Max(1, ItemCount); + Rows = ItemCount == 0 ? 0 : (ItemCount + Columns - 1) / Columns; + RowPitch = ItemHeight + Spacing; + ColumnPitch = justify && finiteWidth && Columns > 1 + ? Math.Max(ItemWidth + Spacing, (viewportWidth - ItemWidth) / (Columns - 1)) + : ItemWidth + Spacing; + } + + public int ItemCount { get; } + + public double ItemWidth { get; } + + public double ItemHeight { get; } + + public double Spacing { get; } + + public int Columns { get; } + + public int Rows { get; } + + /// Distance between the tops of two consecutive rows. + public double RowPitch { get; } + + /// Distance between the left edges of two consecutive columns. + public double ColumnPitch { get; } + + /// Height of all rows, without a trailing gap. + public double ExtentHeight => Rows == 0 ? 0 : Rows * RowPitch - Spacing; + + /// Width spanned by the columns, without a trailing gap. + public double ExtentWidth => ItemCount == 0 ? 0 : (Math.Min(Columns, ItemCount) - 1) * ColumnPitch + ItemWidth; + + /// Columns that fit in (at least one). + public static int ColumnsFor(double width, double itemWidth, double spacing) + { + if (!double.IsFinite(width) || width <= 0) return 1; + var pitch = Positive(itemWidth) + Math.Max(0, spacing); + return Math.Max(1, (int)Math.Floor((width + Math.Max(0, spacing)) / pitch + Epsilon)); + } + + public int RowOf(int index) => index / Columns; + + public int ColumnOf(int index) => index % Columns; + + public double LeftOf(int index) => ColumnOf(index) * ColumnPitch; + + public double TopOf(int index) => RowOf(index) * RowPitch; + + /// Row whose slot band [top, top + pitch) contains , clamped to the rows. + public int RowAt(double y) + { + if (Rows == 0) return -1; + if (!(y > 0)) return 0; + return (int)Math.Min(Rows - 1, Math.Floor(y / RowPitch)); + } + + /// + /// First and last item index whose slot intersects [offset, offset + viewportHeight), widened by + /// rows on each side. Returns (0, −1) when nothing is visible. + /// + public (int First, int Last) VisibleRange(double offset, double viewportHeight, int cacheRows = 0) + { + if (Rows == 0 || !(viewportHeight > 0)) return (0, -1); + if (double.IsInfinity(viewportHeight)) return (0, ItemCount - 1); + // Row r occupies [r·pitch, r·pitch + itemHeight): visible when it starts before the bottom edge and ends after the top edge. + var firstRow = (long)Math.Floor((offset - ItemHeight) / RowPitch + Epsilon) + 1; + var lastRow = (long)Math.Ceiling((offset + viewportHeight) / RowPitch - Epsilon) - 1; + firstRow = Math.Max(0, firstRow - Math.Max(0, cacheRows)); + lastRow = Math.Min(Rows - 1, lastRow + Math.Max(0, cacheRows)); + if (firstRow > lastRow) return (0, -1); + var first = (int)(firstRow * Columns); + var last = (int)Math.Min(ItemCount - 1, (lastRow + 1) * Columns - 1); + return (first, last); + } + + /// Clamps a vertical offset to [0, extent − viewport]. + public double ClampOffset(double offset, double viewportHeight) + { + var max = Math.Max(0, ExtentHeight - Math.Max(0, viewportHeight)); + return double.IsNaN(offset) ? 0 : Math.Clamp(offset, 0, max); + } + + /// Smallest change of that shows [top, top + height) fully; a band taller than the viewport is aligned to its top. + public static double OffsetToReveal(double top, double height, double offset, double viewportHeight) + { + if (top < offset || height >= viewportHeight) return top; + if (top + height > offset + viewportHeight) return top + height - viewportHeight; + return offset; + } + + /// Clamped offset that shows item fully with the least scrolling. + public double OffsetToReveal(int index, double offset, double viewportHeight) + { + if (index < 0 || index >= ItemCount) return ClampOffset(offset, viewportHeight); + return ClampOffset(OffsetToReveal(TopOf(index), ItemHeight, offset, viewportHeight), viewportHeight); + } + + /// Whole rows that fit in the viewport (at least one): the PageUp/PageDown step. + public int PageRows(double viewportHeight) => + double.IsFinite(viewportHeight) ? Math.Max(1, (int)Math.Floor((viewportHeight + Spacing) / RowPitch + Epsilon)) : Math.Max(1, Rows); + + /// + /// Target of a keyboard step from . Left/Right walk the reading order (wrapping across + /// rows); Up/Down keep the column; Down from a row above a shorter last row lands on the last item; page steps + /// move rows in the same column. Returns −1 when there are no items. + /// + public int Navigate(int index, WrapStep step, int pageRows) + { + if (ItemCount == 0) return -1; + index = Math.Clamp(index, 0, ItemCount - 1); + var last = ItemCount - 1; + var page = Math.Max(1, pageRows); + switch (step) + { + case WrapStep.Left: + return Math.Max(0, index - 1); + case WrapStep.Right: + return Math.Min(last, index + 1); + case WrapStep.Up: + return index >= Columns ? index - Columns : index; + case WrapStep.Down: + if (index + Columns <= last) return index + Columns; + return RowOf(index) < Rows - 1 ? last : index; + case WrapStep.PageUp: + { + var row = Math.Max(0, RowOf(index) - page); + return row * Columns + ColumnOf(index); + } + case WrapStep.PageDown: + { + var row = Math.Min(Rows - 1, RowOf(index) + page); + return Math.Min(last, row * Columns + ColumnOf(index)); + } + case WrapStep.First: + return 0; + case WrapStep.Last: + return last; + default: + return index; + } + } + + private static double Positive(double v) => double.IsFinite(v) && v > 0 ? v : 1; +} diff --git a/tests/Titano.App.Tests/Visuals/CurveMathTests.cs b/tests/Titano.App.Tests/Visuals/CurveMathTests.cs new file mode 100644 index 00000000..ee5b9abf --- /dev/null +++ b/tests/Titano.App.Tests/Visuals/CurveMathTests.cs @@ -0,0 +1,85 @@ +using Titano.Testing; +using Titano.Ui.Visuals; + +namespace Titano.App.Tests.Visuals; + +public sealed class CurveMathTests +{ + private const double Gap = CurveMath.DefaultMinGap; + + [Test] + public void DraggedPointCannotPassItsNeighbours() + { + double[] xs = [0, 0.3, 0.6, 1]; + Assert.Approximately(0.6 - Gap, CurveMath.ConstrainX(xs, 1, 0.9, Gap, pinEnds: true), 1e-12); + Assert.Approximately(0 + Gap, CurveMath.ConstrainX(xs, 1, -0.4, Gap, pinEnds: true), 1e-12); + Assert.Approximately(0.45, CurveMath.ConstrainX(xs, 1, 0.45, Gap, pinEnds: true), 1e-12); + } + + [Test] + public void PinnedEndsStayAtZeroAndOne() + { + double[] xs = [0, 0.5, 1]; + Assert.Approximately(0, CurveMath.ConstrainX(xs, 0, 0.2, Gap, pinEnds: true), 0); + Assert.Approximately(1, CurveMath.ConstrainX(xs, 2, 0.7, Gap, pinEnds: true), 0); + } + + [Test] + public void FreeEndsMoveInsideTheUnitInterval() + { + double[] xs = [0.1, 0.5, 0.9]; + Assert.Approximately(0, CurveMath.ConstrainX(xs, 0, -3, Gap, pinEnds: false), 0); + Assert.Approximately(0.5 - Gap, CurveMath.ConstrainX(xs, 0, 0.8, Gap, pinEnds: false), 1e-12); + Assert.Approximately(1, CurveMath.ConstrainX(xs, 2, 4, Gap, pinEnds: false), 0); + } + + [Test] + public void AnySequenceOfDragsKeepsXStrictlyIncreasing() + { + var random = new Random(11); + double[] xs = [0, 0.2, 0.4, 0.6, 0.8, 1]; + for (var step = 0; step < 10_000; step++) + { + var i = random.Next(xs.Length); + xs[i] = CurveMath.ConstrainX(xs, i, random.NextDouble() * 1.4 - 0.2, Gap, pinEnds: true); + for (var k = 1; k < xs.Length; k++) Assert.True(xs[k] - xs[k - 1] >= Gap - 1e-12, $"x[{k - 1}]={xs[k - 1]} x[{k}]={xs[k]}"); + Assert.Approximately(0, xs[0], 0); + Assert.Approximately(1, xs[^1], 0); + } + } + + [Test] + public void InsertionKeepsOrderAndRespectsGapAndPins() + { + double[] xs = [0, 0.5, 1]; + Assert.Equal(1, CurveMath.InsertionIndex(xs, 0.25, Gap, pinEnds: true)); + Assert.Equal(2, CurveMath.InsertionIndex(xs, 0.75, Gap, pinEnds: true)); + Assert.Equal(-1, CurveMath.InsertionIndex(xs, 0.5 + Gap / 2, Gap, pinEnds: true)); + Assert.Equal(-1, CurveMath.InsertionIndex(xs, 1.2, Gap, pinEnds: false)); + + double[] free = [0.2, 0.6]; + Assert.Equal(0, CurveMath.InsertionIndex(free, 0.1, Gap, pinEnds: false)); + Assert.Equal(2, CurveMath.InsertionIndex(free, 0.9, Gap, pinEnds: false)); + Assert.Equal(-1, CurveMath.InsertionIndex(free, 0.1, Gap, pinEnds: true)); + } + + [Test] + public void RemovalKeepsTwoPointsAndPinnedEnds() + { + Assert.False(CurveMath.CanRemove(2, 1, pinEnds: false)); + Assert.True(CurveMath.CanRemove(3, 0, pinEnds: false)); + Assert.False(CurveMath.CanRemove(3, 0, pinEnds: true)); + Assert.True(CurveMath.CanRemove(3, 1, pinEnds: true)); + Assert.False(CurveMath.CanRemove(3, 2, pinEnds: true)); + } + + [Test] + public void HitTestPicksTheNearestPointWithinRadius() + { + double[] xs = [10, 50, 54]; + double[] ys = [10, 10, 10]; + Assert.Equal(2, CurveMath.HitTest(xs, ys, 53, 11, 6)); + Assert.Equal(1, CurveMath.HitTest(xs, ys, 51, 10, 6)); + Assert.Equal(-1, CurveMath.HitTest(xs, ys, 30, 10, 6)); + } +} diff --git a/tests/Titano.App.Tests/Visuals/LruCacheTests.cs b/tests/Titano.App.Tests/Visuals/LruCacheTests.cs new file mode 100644 index 00000000..21186f4f --- /dev/null +++ b/tests/Titano.App.Tests/Visuals/LruCacheTests.cs @@ -0,0 +1,59 @@ +using Titano.Testing; +using Titano.Ui.Visuals; + +namespace Titano.App.Tests.Visuals; + +public sealed class LruCacheTests +{ + [Test] + public void EvictsTheLeastRecentlyUsedEntry() + { + var cache = new LruCache(2); + cache.Set(1, "a"); + cache.Set(2, "b"); + Assert.True(cache.TryGet(1, out _)); + cache.Set(3, "c"); + Assert.False(cache.TryGet(2, out _)); + Assert.True(cache.TryGet(1, out var one)); + Assert.Equal("a", one); + Assert.True(cache.TryGet(3, out _)); + Assert.Equal(2, cache.Count); + } + + [Test] + public void ReplacingAValueRefreshesItsRecency() + { + var cache = new LruCache(2); + cache.Set(1, "a"); + cache.Set(2, "b"); + cache.Set(1, "a2"); + cache.Set(3, "c"); + Assert.True(cache.TryGet(1, out var value)); + Assert.Equal("a2", value); + Assert.False(cache.TryGet(2, out _)); + } + + [Test] + public void ShrinkingCapacityEvictsOldestFirst() + { + var cache = new LruCache(10); + for (var i = 0; i < 10; i++) cache.Set(i, i); + cache.Capacity = 3; + Assert.Equal(3, cache.Count); + for (var i = 0; i < 7; i++) Assert.False(cache.TryGet(i, out _)); + for (var i = 7; i < 10; i++) Assert.True(cache.TryGet(i, out _)); + } + + [Test] + public void RemoveAndClear() + { + var cache = new LruCache(4); + cache.Set("x", 1); + cache.Set("y", 2); + Assert.True(cache.Remove("x")); + Assert.False(cache.Remove("x")); + cache.Clear(); + Assert.Equal(0, cache.Count); + Assert.Throws(() => _ = new LruCache(0)); + } +} diff --git a/tests/Titano.App.Tests/Visuals/MinMaxDecimatorTests.cs b/tests/Titano.App.Tests/Visuals/MinMaxDecimatorTests.cs new file mode 100644 index 00000000..ba7df1d9 --- /dev/null +++ b/tests/Titano.App.Tests/Visuals/MinMaxDecimatorTests.cs @@ -0,0 +1,106 @@ +using Titano.Testing; +using Titano.Ui.Visuals; + +namespace Titano.App.Tests.Visuals; + +public sealed class MinMaxDecimatorTests +{ + [Test] + public void ShortSeriesKeepsEverySample() + { + double[] values = [3, 1, 4, 1, 5]; + var output = new int[MinMaxDecimator.Capacity(values.Length, 10)]; + var n = MinMaxDecimator.Decimate(values, 10, output); + Assert.SequenceEqual([0, 1, 2, 3, 4], output[..n]); + } + + [Test] + public void LongSeriesKeepsAtMostTwoSamplesPerColumn() + { + var values = Noise(200_000, seed: 1); + const int columns = 800; + var output = new int[MinMaxDecimator.Capacity(values.Length, columns)]; + var n = MinMaxDecimator.Decimate(values, columns, output); + Assert.LessOrEqual(n, 2 * columns); + Assert.Monotonic(output[..n].Select(i => (double)i), strict: true); + } + + [Test] + public void EveryColumnPreservesItsMinimumAndMaximum() + { + var values = Noise(123_457, seed: 2); + // Plant spikes that a naive stride sampler would miss. + values[50_001] = 1000; + values[99_999] = -1000; + const int columns = 640; + var output = new int[MinMaxDecimator.Capacity(values.Length, columns)]; + var n = MinMaxDecimator.Decimate(values, columns, output); + var kept = output[..n]; + + for (var c = 0; c < columns; c++) + { + var start = (int)((long)c * values.Length / columns); + var end = (int)((long)(c + 1) * values.Length / columns); + double min = double.PositiveInfinity, max = double.NegativeInfinity; + double keptMin = double.PositiveInfinity, keptMax = double.NegativeInfinity; + for (var i = start; i < end; i++) + { + min = Math.Min(min, values[i]); + max = Math.Max(max, values[i]); + } + foreach (var i in kept) + { + if (i < start || i >= end) continue; + keptMin = Math.Min(keptMin, values[i]); + keptMax = Math.Max(keptMax, values[i]); + } + Assert.Equal(min, keptMin, $"column {c} min"); + Assert.Equal(max, keptMax, $"column {c} max"); + } + Assert.Contains(50_001, kept); + Assert.Contains(99_999, kept); + } + + [Test] + public void NonFiniteRunsBecomeSingleGaps() + { + double[] values = [1, double.NaN, double.NaN, 2, double.PositiveInfinity, 3, double.NaN]; + var output = new int[values.Length]; + var n = MinMaxDecimator.Decimate(values, 100, output); + Assert.SequenceEqual([0, MinMaxDecimator.Gap, 3, MinMaxDecimator.Gap, 5], output[..n]); + } + + [Test] + public void EmptyColumnsBreakTheLineInDecimatedMode() + { + var values = new double[1000]; + for (var i = 0; i < values.Length; i++) values[i] = i < 400 || i >= 600 ? i : double.NaN; + var output = new int[MinMaxDecimator.Capacity(values.Length, 10)]; + var n = MinMaxDecimator.Decimate(values, 10, output); + // Columns 4 and 5 (indices 400–599) hold no finite sample: exactly one gap between columns 3 and 6. + Assert.SequenceEqual([0, 99, 100, 199, 200, 299, 300, 399, MinMaxDecimator.Gap, 600, 699, 700, 799, 800, 899, 900, 999], output[..n]); + } + + [Test] + public void FlatColumnsEmitOneSample() + { + var values = Enumerable.Repeat(5.0, 1000).ToArray(); + var output = new int[MinMaxDecimator.Capacity(values.Length, 4)]; + var n = MinMaxDecimator.Decimate(values, 4, output); + Assert.SequenceEqual([0, 250, 500, 750], output[..n]); + } + + [Test] + public void UndersizedOutputIsRejected() + { + Assert.Throws(() => MinMaxDecimator.Decimate(new double[100], 10, new int[5])); + } + + private static double[] Noise(int count, int seed) + { + var random = new Random(seed); + var values = new double[count]; + for (var i = 0; i < count; i++) values[i] = Math.Sin(i * 0.001) + random.NextDouble() * 0.2; + return values; + } +} diff --git a/tests/Titano.App.Tests/Visuals/NiceScaleTests.cs b/tests/Titano.App.Tests/Visuals/NiceScaleTests.cs new file mode 100644 index 00000000..cc83c820 --- /dev/null +++ b/tests/Titano.App.Tests/Visuals/NiceScaleTests.cs @@ -0,0 +1,91 @@ +using Titano.Testing; +using Titano.Ui.Visuals; + +namespace Titano.App.Tests.Visuals; + +public sealed class NiceScaleTests +{ + [Theory] + [Case(0.6, true, 0.5)] + [Case(1.2, true, 1.0)] + [Case(2.9, true, 2.0)] + [Case(3.1, true, 5.0)] + [Case(7.5, true, 10.0)] + [Case(1.2, false, 2.0)] + [Case(4.0, false, 5.0)] + [Case(5.0, false, 5.0)] + [Case(1234.0, false, 2000.0)] + [Case(0.025, true, 0.02)] + public void NiceNumbersAreOneTwoOrFiveTimesAPowerOfTen(double value, bool round, double expected) + { + Assert.Approximately(expected, NiceScale.NiceNumber(value, round), expected * 1e-12); + } + + [Test] + public void InnerTicksStayInsideTheRangeOnNiceMultiples() + { + var ticks = NiceScale.Inner(0.13, 0.87, 5); + Assert.Approximately(0.2, ticks.Step, 1e-12); + Assert.Equal(4, ticks.Count); + Assert.Approximately(0.2, ticks[0], 1e-12); + Assert.Approximately(0.8, ticks[3], 1e-12); + for (var i = 0; i < ticks.Count; i++) Assert.InRange(ticks[i], 0.13, 0.87); + } + + [Test] + public void OuterTicksEncloseTheRange() + { + var ticks = NiceScale.Outer(3, 1870, 5); + Assert.Approximately(500, ticks.Step, 1e-9); + Assert.Approximately(0, ticks.First, 1e-9); + Assert.Approximately(2000, ticks.Last, 1e-9); + Assert.Equal(5, ticks.Count); + } + + [Test] + public void TickValuesDoNotDriftOverManySteps() + { + var ticks = NiceScale.Inner(-1e6, 1e6, 11); + Assert.Approximately(200_000, ticks.Step, 1e-6); + Assert.Approximately(0, ticks[5], 1e-6); + Assert.Approximately(1e6, ticks[ticks.Count - 1], 1e-6); + } + + [Test] + public void TickCountNeverExceedsTheRequest() + { + var random = new Random(7); + for (var i = 0; i < 1000; i++) + { + var a = (random.NextDouble() - 0.5) * Math.Pow(10, random.Next(-3, 7)); + var b = a + random.NextDouble() * Math.Pow(10, random.Next(-3, 7)) + 1e-9; + var max = random.Next(2, 12); + var ticks = NiceScale.Inner(a, b, max); + Assert.LessOrEqual(ticks.Count, max); + } + } + + [Test] + public void PadWidensBothSidesAndCentresFlatData() + { + var (min, max) = NiceScale.Pad(10, 20, 0.1); + Assert.Approximately(9, min, 1e-12); + Assert.Approximately(21, max, 1e-12); + + var (flatMin, flatMax) = NiceScale.Pad(5, 5, 0.1); + Assert.Approximately(5, (flatMin + flatMax) / 2, 1e-12); + Assert.Greater(flatMax - flatMin, 0); + + var (zeroMin, zeroMax) = NiceScale.Pad(0, 0, 0.1); + Assert.Approximately(-1, zeroMin, 1e-12); + Assert.Approximately(1, zeroMax, 1e-12); + Assert.Equal((0.0, 1.0), NiceScale.Pad(double.NaN, 3, 0.1)); + } + + [Test] + public void DegenerateRangesGiveNoInnerTicks() + { + Assert.Equal(0, NiceScale.Inner(4, 4, 5).Count); + Assert.Equal(0, NiceScale.Inner(double.NaN, 4, 5).Count); + } +} diff --git a/tests/Titano.App.Tests/Visuals/PixelGridTests.cs b/tests/Titano.App.Tests/Visuals/PixelGridTests.cs new file mode 100644 index 00000000..871fbeb1 --- /dev/null +++ b/tests/Titano.App.Tests/Visuals/PixelGridTests.cs @@ -0,0 +1,34 @@ +using Titano.Testing; +using Titano.Ui.Visuals; + +namespace Titano.App.Tests.Visuals; + +public sealed class PixelGridTests +{ + [Theory] + [Case(1.0)] + [Case(1.25)] + [Case(1.5)] + [Case(2.0)] + public void HairlinesCoverWholeDevicePixels(double scale) + { + var thickness = PixelGrid.SnapThickness(1, scale); + var devicePixels = thickness * scale; + Assert.Approximately(Math.Round(devicePixels), devicePixels, 1e-9); + for (var v = 0.0; v < 50; v += 0.37) + { + var centre = PixelGrid.SnapLine(v, thickness, scale) * scale; + var left = centre - devicePixels / 2; + Assert.Approximately(Math.Round(left), left, 1e-9, $"v={v}"); + Assert.LessOrEqual(Math.Abs(centre - v * scale), 1); + } + } + + [Test] + public void SnapRoundsToDevicePixelBoundaries() + { + Assert.Approximately(10, PixelGrid.Snap(10.2, 1), 1e-12); + Assert.Approximately(10 + 2 / 3.0, PixelGrid.Snap(10.6, 1.5), 1e-12); + Assert.Approximately(3.3, PixelGrid.Snap(3.3, 0), 0); + } +} diff --git a/tests/Titano.App.Tests/Visuals/StripLayoutTests.cs b/tests/Titano.App.Tests/Visuals/StripLayoutTests.cs new file mode 100644 index 00000000..030a191a --- /dev/null +++ b/tests/Titano.App.Tests/Visuals/StripLayoutTests.cs @@ -0,0 +1,85 @@ +using Titano.Testing; +using Titano.Ui.Visuals; + +namespace Titano.App.Tests.Visuals; + +public sealed class StripLayoutTests +{ + [Test] + public void CellsFillTheWidthExactly() + { + var strip = new StripLayout(898, 36, 2, 3600); + Assert.Equal(23, strip.CellCount); + Assert.Approximately(898, strip.CellLeft(strip.CellCount - 1) + strip.CellWidth, 1e-9); + } + + [Test] + public void ShortSequencesGetOneCellPerFrame() + { + var strip = new StripLayout(898, 36, 2, 5); + Assert.Equal(5, strip.CellCount); + for (var c = 0; c < 5; c++) Assert.Equal(c, strip.FrameForCell(c)); + } + + [Theory] + [Case(3600, 23)] + [Case(5, 4)] + [Case(7, 7)] + [Case(1001, 24)] + [Case(24, 23)] + public void EachCellShowsAFrameFromItsOwnRun(int frames, int cells) + { + var strip = new StripLayout(cells * 40 - 2, 38, 2, frames); + Assert.Equal(Math.Min(cells, frames), strip.CellCount); + var previous = -1; + for (var c = 0; c < strip.CellCount; c++) + { + var frame = strip.FrameForCell(c); + Assert.Equal(c, strip.CellForFrame(frame)); + Assert.Greater(frame, previous); + previous = frame; + } + } + + [Test] + public void SeekingMapsXToFramesContinuously() + { + var strip = new StripLayout(900, 36, 2, 3600); + Assert.Equal(0, strip.FrameAt(-5)); + Assert.Equal(0, strip.FrameAt(0)); + Assert.Equal(1800, strip.FrameAt(450)); + Assert.Equal(3599, strip.FrameAt(900)); + Assert.Equal(3599, strip.FrameAt(5000)); + Assert.Equal(412, strip.FrameAt(strip.XForFrame(412))); + } + + [Test] + public void EmptyStripHasNoCells() + { + var strip = new StripLayout(900, 36, 2, 0); + Assert.Equal(0, strip.CellCount); + Assert.Equal(-1, strip.FrameAt(10)); + Assert.Equal(-1, strip.FrameForCell(0)); + } + + [Test] + public void HeatmapHitTestExcludesGaps() + { + var grid = new CellGridLayout(30, 20, 8, 12, 16, 3); + Assert.True(grid.TryHit(30 + 19 * 2 + 5, 20 + 19 * 7 + 15.5, out var row, out var column)); + Assert.Equal(7, row); + Assert.Equal(2, column); + Assert.False(grid.TryHit(30 + 16.5, 25, out _, out _)); + Assert.False(grid.TryHit(29, 25, out _, out _)); + Assert.False(grid.TryHit(30 + grid.Width + 1, 25, out _, out _)); + Assert.Approximately(12 * 19 - 3, grid.Width, 1e-12); + } + + [Test] + public void HeatmapCellsFitTheSmallerAxis() + { + Assert.Approximately(16, CellGridLayout.FitCellSize(500, 149, 8, 12, 3, 24), 1e-9); + Assert.Approximately(24, CellGridLayout.FitCellSize(5000, 5000, 8, 12, 3, 24), 1e-9); + Assert.Approximately((260 - 33) / 12.0, CellGridLayout.FitCellSize(260, double.PositiveInfinity, 8, 12, 3, 24), 1e-9); + } +} diff --git a/tests/Titano.App.Tests/Visuals/ViewportMathTests.cs b/tests/Titano.App.Tests/Visuals/ViewportMathTests.cs new file mode 100644 index 00000000..cea6efe8 --- /dev/null +++ b/tests/Titano.App.Tests/Visuals/ViewportMathTests.cs @@ -0,0 +1,72 @@ +using Titano.Testing; +using Titano.Ui.Visuals; + +namespace Titano.App.Tests.Visuals; + +public sealed class ViewportMathTests +{ + [Test] + public void FitUsesTheLimitingAxisAndCentres() + { + // 8192×5464 into 900×430: height limits. + var scale = ViewportMath.FitScale(8192, 5464, 900, 430); + Assert.Approximately(430.0 / 5464, scale, 1e-12); + var t = ViewportMath.Centered(scale, 8192, 5464, 900, 430); + Assert.Approximately(0, t.OffsetY, 1e-9); + Assert.Approximately((900 - 8192 * scale) / 2, t.OffsetX, 1e-9); + Assert.Approximately(0, ViewportMath.FitScale(0, 100, 900, 430), 0); + } + + [Test] + public void ZoomAtKeepsThePointUnderTheCursorFixed() + { + var t = new ViewTransform(0.25, 37, -12); + var (ix, iy) = t.ToImage(410, 220); + var zoomed = ViewportMath.ZoomAt(t, 1.7, 410, 220); + var (vx, vy) = zoomed.ToView(ix, iy); + Assert.Within(410, 220, vx, vy, 1e-9); + Assert.Approximately(1.7, zoomed.Scale, 0); + } + + [Test] + public void WheelZoomStepsGeometricallyAndClamps() + { + Assert.Approximately(1.25, ViewportMath.WheelZoom(1, 1, 0.01, 32), 1e-12); + Assert.Approximately(1 / 1.5625, ViewportMath.WheelZoom(1, -2, 0.01, 32), 1e-12); + Assert.Approximately(32, ViewportMath.WheelZoom(30, 3, 0.01, 32), 0); + } + + [Test] + public void ClampCentresSmallImagesAndCoversWithLargeOnes() + { + // Image 400×300 at scale 1 inside 900×430: centred on both axes whatever the offset. + var small = ViewportMath.Clamp(new ViewTransform(1, -500, 999), 400, 300, 900, 430); + Assert.Approximately(250, small.OffsetX, 1e-9); + Assert.Approximately(65, small.OffsetY, 1e-9); + + // Image 4000×3000 at scale 1: the view must stay covered. + var large = ViewportMath.Clamp(new ViewTransform(1, 100, -5000), 4000, 3000, 900, 430); + Assert.Approximately(0, large.OffsetX, 1e-9); + Assert.Approximately(430 - 3000, large.OffsetY, 1e-9); + } + + [Test] + public void PanMovesAndRoundTripsThroughImageCoordinates() + { + var t = ViewportMath.Pan(new ViewTransform(2, 10, 20), -4, 6); + Assert.Approximately(6, t.OffsetX, 0); + Assert.Approximately(26, t.OffsetY, 0); + var (x, y) = t.ToView(123.5, 77.25); + var (ix, iy) = t.ToImage(x, y); + Assert.Within(123.5, 77.25, ix, iy, 1e-12); + } + + [Test] + public void SnapOffsetAlignsToDevicePixels() + { + // 150 % DPI: 1.5 device pixels per DIP. + var t = ViewportMath.SnapOffset(new ViewTransform(1, 10.4, -3.1), 1.5); + Assert.Approximately(Math.Round(10.4 * 1.5), t.OffsetX * 1.5, 1e-9); + Assert.Approximately(Math.Round(-3.1 * 1.5), t.OffsetY * 1.5, 1e-9); + } +} diff --git a/tests/Titano.App.Tests/Visuals/WrapLayoutTests.cs b/tests/Titano.App.Tests/Visuals/WrapLayoutTests.cs new file mode 100644 index 00000000..2492e1e2 --- /dev/null +++ b/tests/Titano.App.Tests/Visuals/WrapLayoutTests.cs @@ -0,0 +1,144 @@ +using Titano.Testing; +using Titano.Ui.Visuals; + +namespace Titano.App.Tests.Visuals; + +public sealed class WrapLayoutTests +{ + [Theory] + [Case(0.0, 1)] + [Case(235.0, 1)] + [Case(236.0, 1)] + [Case(487.0, 1)] + [Case(488.0, 2)] + [Case(1252.0, 5)] + [Case(1255.0, 5)] + public void ColumnsCountWholeItemsWithGapsBetween(double width, int expected) + { + // 236-px cards with 16-px gaps: n columns need n·236 + (n−1)·16 px. + Assert.Equal(expected, WrapLayout.ColumnsFor(width, 236, 16)); + } + + [Test] + public void RowsAndExtentLeaveNoTrailingGap() + { + var layout = new WrapLayout(11, 1252, 236, 208, 16); + Assert.Equal(5, layout.Columns); + Assert.Equal(3, layout.Rows); + Assert.Approximately(3 * 224 - 16, layout.ExtentHeight, 1e-9); + Assert.Approximately(5 * 236 + 4 * 16, layout.ExtentWidth, 1e-9); + Assert.Approximately(0, new WrapLayout(0, 1252, 236, 208, 16).ExtentHeight, 1e-9); + } + + [Test] + public void IndexMapsToRowColumnAndPixelOrigin() + { + var layout = new WrapLayout(500_000, 1252, 236, 208, 16); + Assert.Equal(1234, layout.RowOf(6172)); + Assert.Equal(2, layout.ColumnOf(6172)); + Assert.Approximately(2 * 252, layout.LeftOf(6172), 1e-9); + Assert.Approximately(1234 * 224, layout.TopOf(6172), 1e-6); + Assert.Equal(100_000, layout.Rows); + } + + [Test] + public void VisibleRangeIsConstantTimeAndCoversPartialRows() + { + var layout = new WrapLayout(500_000, 1252, 236, 208, 16); + // Offset in the middle of row 50 000's gap: row 50 000 has ended, row 50 001 starts at 50 001·224. + var offset = 50_000 * 224.0 + 210; + var (first, last) = layout.VisibleRange(offset, 600); + Assert.Equal(50_001 * 5, first); + // Bottom edge at offset + 600 = 50 000·224 + 810 → rows up to 50 003 (starts at +672) are visible. + Assert.Equal(50_004 * 5 - 1, last); + + var (cachedFirst, cachedLast) = layout.VisibleRange(offset, 600, cacheRows: 1); + Assert.Equal(first - 5, cachedFirst); + Assert.Equal(last + 5, cachedLast); + } + + [Test] + public void VisibleRangeExcludesRowStartingAtBottomEdge() + { + var layout = new WrapLayout(100, 1252, 236, 208, 16); + var (first, last) = layout.VisibleRange(0, 224); + Assert.Equal(0, first); + Assert.Equal(4, last); + } + + [Test] + public void VisibleRangeClampsToLastPartialRow() + { + var layout = new WrapLayout(12, 1252, 236, 208, 16); + var (first, last) = layout.VisibleRange(0, 10_000, cacheRows: 2); + Assert.Equal(0, first); + Assert.Equal(11, last); + Assert.Equal((0, -1), new WrapLayout(0, 1252, 236, 208, 16).VisibleRange(0, 500)); + } + + [Test] + public void OffsetToRevealScrollsTheLeastAmount() + { + var layout = new WrapLayout(100, 1252, 236, 208, 16); + // Row 3 spans [672, 880): below a viewport [0, 600) → bottom-aligned. + Assert.Approximately(880 - 600, layout.OffsetToReveal(15, 0, 600), 1e-9); + // Already visible → unchanged. + Assert.Approximately(300, layout.OffsetToReveal(15, 300, 600), 1e-9); + // Above the viewport → top-aligned. + Assert.Approximately(224, layout.OffsetToReveal(5, 1000, 600), 1e-9); + // Taller than the viewport → top-aligned. + Assert.Approximately(672, WrapLayout.OffsetToReveal(672, 208, 0, 100), 1e-9); + } + + [Test] + public void ClampOffsetKeepsViewportInsideExtent() + { + var layout = new WrapLayout(10, 1252, 236, 208, 16); + Assert.Approximately(432 - 300, layout.ClampOffset(5000, 300), 1e-9); + Assert.Approximately(0, layout.ClampOffset(-20, 300), 1e-9); + Assert.Approximately(0, layout.ClampOffset(50, 1000), 1e-9); + } + + [Test] + public void JustifySpreadsLeftoverWidthOverGaps() + { + var layout = new WrapLayout(10, 1300, 236, 208, 16, justify: true); + Assert.Equal(5, layout.Columns); + Assert.Approximately(1300, layout.LeftOf(4) + 236, 1e-9); + Assert.Approximately(1300, layout.ExtentWidth, 1e-9); + } + + [Theory] + [Case(7, WrapStep.Left, 6)] + [Case(5, WrapStep.Left, 4)] + [Case(0, WrapStep.Left, 0)] + [Case(4, WrapStep.Right, 5)] + [Case(11, WrapStep.Right, 11)] + [Case(7, WrapStep.Up, 2)] + [Case(2, WrapStep.Up, 2)] + [Case(2, WrapStep.Down, 7)] + [Case(9, WrapStep.Down, 11)] + [Case(11, WrapStep.Down, 11)] + [Case(7, WrapStep.First, 0)] + [Case(7, WrapStep.Last, 11)] + public void KeyboardStepsFollowReadingOrderAndColumns(int from, WrapStep step, int expected) + { + // 12 items in rows of 5: 0–4, 5–9, 10–11. + var layout = new WrapLayout(12, 1252, 236, 208, 16); + Assert.Equal(expected, layout.Navigate(from, step, pageRows: 2)); + } + + [Test] + public void PageStepsMoveWholeViewportRowsInTheSameColumn() + { + var layout = new WrapLayout(1000, 1252, 236, 208, 16); + var pageRows = layout.PageRows(700); + Assert.Equal(3, pageRows); + Assert.Equal(2 + 3 * 5, layout.Navigate(2, WrapStep.PageDown, pageRows)); + Assert.Equal(2, layout.Navigate(2 + 3 * 5, WrapStep.PageUp, pageRows)); + Assert.Equal(3, layout.Navigate(8, WrapStep.PageUp, pageRows)); + // From row 198 a page down is clamped to the last row, same column. + Assert.Equal(999, layout.Navigate(994, WrapStep.PageDown, pageRows)); + Assert.Equal(-1, new WrapLayout(0, 1252, 236, 208, 16).Navigate(0, WrapStep.Down, 1)); + } +} From 2328c2b32e00f093d05398265c89dba1bff2d239 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 10:26:49 +0000 Subject: [PATCH 02/13] feat(ui-visuals): add retained-mode drawing base and chart data types DrawingElement resolves theme brushes by key (re-resolved on theme swap via a resource-reference probe), caches frozen pens per theme and DPI, lays out text in the UI font and offers an overlay layer redrawn without touching the static content. HoverReadout is a mouse-following tooltip for values. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- src/Titano.Ui/Visuals/ChartTypes.cs | 116 ++++++++++++ src/Titano.Ui/Visuals/DrawingElement.cs | 242 ++++++++++++++++++++++++ src/Titano.Ui/Visuals/HoverReadout.cs | 51 +++++ 3 files changed, 409 insertions(+) create mode 100644 src/Titano.Ui/Visuals/ChartTypes.cs create mode 100644 src/Titano.Ui/Visuals/DrawingElement.cs create mode 100644 src/Titano.Ui/Visuals/HoverReadout.cs diff --git a/src/Titano.Ui/Visuals/ChartTypes.cs b/src/Titano.Ui/Visuals/ChartTypes.cs new file mode 100644 index 00000000..1e67e4b4 --- /dev/null +++ b/src/Titano.Ui/Visuals/ChartTypes.cs @@ -0,0 +1,116 @@ +using System.Windows; + +namespace Titano.Ui.Visuals; + +/// Stroke pattern of a series or legend swatch. +public enum LineDash +{ + Solid, + + /// 5–4 dashes (sky region curve). + Dashed, + + /// 2–3 dots. + Dotted, +} + +/// One per-frame line of a . Values are indexed by frame; NaN leaves a gap. +public sealed class ChartSeries +{ + public ChartSeries(string? title, ReadOnlyMemory values, string brushKey) + { + Title = title; + Values = values; + BrushKey = brushKey; + } + + /// Legend and readout text (localized by the caller). + public string? Title { get; init; } + + public ReadOnlyMemory Values { get; init; } + + /// Theme brush resource key, e.g. Brush.Sun; re-resolved when the theme changes. + public string BrushKey { get; init; } + + /// Stroke width in DIPs. + public double Thickness { get; init; } = 1.5; + + public LineDash Dash { get; init; } = LineDash.Solid; + + /// Whether the automatic legend lists this series. + public bool ShowInLegend { get; init; } = true; +} + +/// Shape drawn before a legend entry. +public enum LegendSwatch +{ + Line, + DashedLine, + DottedLine, + + /// ▼ (exposure steps). + Triangle, + + /// ◆ (keyframes). + Diamond, + + Square, +} + +/// A legend entry: swatch in a theme brush followed by text. +public sealed record ChartLegendItem(string Text, string BrushKey, LegendSwatch Swatch = LegendSwatch.Line); + +/// What a timeline marker stands for; the kind fixes its colour and glyph. +public enum MarkerKind +{ + /// ISO/shutter/aperture step as received: ▼ in Sun. + ExposureStep, + + /// ▼ in Warning. + Warning, + + /// ▼ in Error. + Error, + + /// Virtual-camera or remap keyframe: ◆ in Accent. + Keyframe, +} + +/// A frame-anchored marker shown above the filmstrip and as a dashed line in series charts. +public readonly record struct TimelineMarker(int Index, MarkerKind Kind, string? Label = null) +{ + /// Theme brush key of a marker kind. + public static string BrushKeyOf(MarkerKind kind) => kind switch + { + MarkerKind.ExposureStep => "Brush.Sun", + MarkerKind.Warning => "Brush.Warning", + MarkerKind.Error => "Brush.Error", + _ => "Brush.Accent", + }; +} + +/// A labelled value of a bar or proportion chart. +/// Category text (year, camera, format…). +/// Magnitude; negative values draw as zero. +/// Formatted value shown next to the bar; null uses the chart formatter. +/// Hover text; null shows label and value. +/// Theme brush key overriding the chart brush. +public sealed record ChartItem(string Label, double Value, string? ValueText = null, string? ToolTip = null, string? BrushKey = null); + +/// A labelled row of values (a heatmap year, a timeline band); NaN marks "no data". +/// Row text (e.g. the year). +/// One value per column (e.g. 12 months). +/// Optional hover text per column. +public sealed record ChartRow(string Label, IReadOnlyList Values, IReadOnlyList? ToolTips = null); + +/// Identifies the item a chart interaction refers to. +public sealed class ChartItemEventArgs(RoutedEvent routedEvent, int row, int column) : RoutedEventArgs(routedEvent) +{ + /// Item index (bars, segments) or row index (heatmap, bands). + public int Row { get; } = row; + + /// Column index for grids (heatmap month, band slot); −1 for single-index charts. + public int Column { get; } = column; +} + +public delegate void ChartItemEventHandler(object sender, ChartItemEventArgs e); diff --git a/src/Titano.Ui/Visuals/DrawingElement.cs b/src/Titano.Ui/Visuals/DrawingElement.cs new file mode 100644 index 00000000..9126bb54 --- /dev/null +++ b/src/Titano.Ui/Visuals/DrawingElement.cs @@ -0,0 +1,242 @@ +using System.Collections.Specialized; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Media; +using Titano.Core.Localization; + +namespace Titano.Ui.Visuals; + +/// +/// Base of the retained-mode visuals. Brushes are looked up by theme resource key and re-resolved when the token +/// dictionary is swapped (frozen pens are cached per theme); text is laid out with the UI font at the element's +/// DPI; an optional overlay layer (playhead, hover) is redrawn without re-rendering the static content drawn in +/// . Time axes and images never mirror, so the element is always left-to-right. +/// +public abstract class DrawingElement : FrameworkElement +{ + /// Follows a token brush; its change signals a theme switch. + private static readonly DependencyProperty ThemeProbeProperty = DependencyProperty.Register( + "ThemeProbe", typeof(object), typeof(DrawingElement), new PropertyMetadata(null, OnThemeProbeChanged)); + + private readonly Dictionary _brushes = new(StringComparer.Ordinal); + private readonly Dictionary<(string Key, double Thickness, LineDash Dash), Pen> _pens = []; + private readonly DrawingVisual? _overlay; + private HoverReadout? _readout; + private Typeface? _regular; + private Typeface? _semiBold; + + /// Creates the overlay layer drawn by . + protected DrawingElement(bool hasOverlay = false) + { + if (hasOverlay) + { + _overlay = new DrawingVisual(); + AddVisualChild(_overlay); + } + FlowDirection = FlowDirection.LeftToRight; + SetResourceReference(ThemeProbeProperty, "Brush.Text"); + Unloaded += (_, _) => _readout?.Hide(); + } + + /// Device pixels per DIP on the monitor showing the element. + protected double PixelScale => VisualTreeHelper.GetDpi(this).DpiScaleX; + + /// Tooltip-styled readout that follows the mouse. + protected HoverReadout Readout => _readout ??= new HoverReadout(this); + + protected override int VisualChildrenCount => _overlay is null ? 0 : 1; + + protected override Visual GetVisualChild(int index) => + _overlay is not null && index == 0 ? _overlay : throw new ArgumentOutOfRangeException(nameof(index)); + + /// Frozen theme brush for (transparent when the key is unknown). + protected Brush GetBrush(string key) + { + if (_brushes.TryGetValue(key, out var brush)) return brush; + // A frozen copy: drawing never notifies, and freezing pens never freezes the shared resource itself. + brush = TryFindResource(key) switch + { + Brush { IsFrozen: true } frozen => frozen, + Brush { CanFreeze: true } live => (Brush)live.GetCurrentValueAsFrozen(), + Brush live => live, + _ => Brushes.Transparent, + }; + _brushes[key] = brush; + return brush; + } + + /// Frozen pen in the theme brush , cached until the theme or DPI changes. + protected Pen GetPen(string key, double thickness, LineDash dash = LineDash.Solid) + { + if (_pens.TryGetValue((key, thickness, dash), out var pen)) return pen; + pen = CreatePen(key, thickness, dash); + _pens[(key, thickness, dash)] = pen; + return pen; + } + + /// Uncached frozen pen, for thicknesses that vary continuously (e.g. compensating a zoom). + protected Pen CreatePen(string key, double thickness, LineDash dash = LineDash.Solid) + { + var pen = new Pen(GetBrush(key), thickness) + { + DashStyle = DashFor(dash, thickness), + LineJoin = PenLineJoin.Round, + StartLineCap = dash == LineDash.Solid ? PenLineCap.Round : PenLineCap.Flat, + EndLineCap = dash == LineDash.Solid ? PenLineCap.Round : PenLineCap.Flat, + }; + if (pen.CanFreeze) pen.Freeze(); + return pen; + } + + /// Pen covering whole device pixels, for gridlines and edges drawn at positions. + protected Pen GetHairline(string key, LineDash dash = LineDash.Solid) => GetPen(key, PixelGrid.SnapThickness(1, PixelScale), dash); + + /// Single-line text in the UI font, laid out for this element's DPI and text formatting mode. + protected FormattedText CreateText(string text, double emSize, Brush brush, bool semiBold = false) + { + var typeface = semiBold ? _semiBold ??= CreateTypeface(FontWeights.SemiBold) : _regular ??= CreateTypeface(FontWeights.Normal); + return new FormattedText(text, Loc.Culture, FlowDirection.LeftToRight, typeface, emSize, brush, null, + TextOptions.GetTextFormattingMode(this), VisualTreeHelper.GetDpi(this).PixelsPerDip); + } + + /// Redraws the overlay layer; call after any change that only affects playhead or hover state. + protected void RenderOverlay() + { + if (_overlay is null) return; + using var dc = _overlay.RenderOpen(); + if (ActualWidth > 0 && ActualHeight > 0) OnRenderOverlay(dc); + } + + /// Draws the overlay layer (above the static content). + protected virtual void OnRenderOverlay(DrawingContext dc) + { + } + + /// Called after the theme brushes changed; the default redraws everything. + protected virtual void OnThemeChanged() + { + InvalidateVisual(); + if (_overlay is not null) RenderOverlay(); + } + + /// Called when a data property or a watched collection changed; the default re-measures and redraws. + protected virtual void OnDataChanged() + { + InvalidateMeasure(); + InvalidateVisual(); + } + + /// Property-changed callback for data properties: watches observable collections weakly and calls . + protected static void OnDataPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) + { + var element = (DrawingElement)d; + if (e.OldValue is INotifyCollectionChanged oldCollection) CollectionChangedEventManager.RemoveHandler(oldCollection, element.OnWatchedCollectionChanged); + if (e.NewValue is INotifyCollectionChanged newCollection) CollectionChangedEventManager.AddHandler(newCollection, element.OnWatchedCollectionChanged); + element.OnDataChanged(); + } + + protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi) + { + base.OnDpiChanged(oldDpi, newDpi); + _pens.Clear(); + _regular = _semiBold = null; + OnThemeChanged(); + } + + /// Fills the whole element with a transparent brush so empty areas still receive the mouse. + protected void DrawHitArea(DrawingContext dc) => dc.DrawRectangle(Brushes.Transparent, null, new Rect(RenderSize)); + + /// Adds a ▼ of width whose top edge is centred at (, ). + protected static void AddTriangleDown(StreamGeometryContext ctx, double cx, double top, double size) + { + ctx.BeginFigure(new Point(cx - size / 2, top), true, true); + ctx.LineTo(new Point(cx + size / 2, top), false, false); + ctx.LineTo(new Point(cx, top + size * 0.8), false, false); + } + + /// Adds a ◆ of width centred at (, ). + protected static void AddDiamond(StreamGeometryContext ctx, double cx, double cy, double size) + { + var h = size / 2; + ctx.BeginFigure(new Point(cx, cy - h), true, true); + ctx.LineTo(new Point(cx + h, cy), false, false); + ctx.LineTo(new Point(cx, cy + h), false, false); + ctx.LineTo(new Point(cx - h, cy), false, false); + } + + /// + /// Draws legend entries left to right from (swatch, 6 px, text in the entry colour, + /// 16 px between entries) and stops before . Returns the right edge reached. + /// + protected double DrawLegend(DrawingContext dc, IReadOnlyList items, Point origin, double maxRight, double emSize) + { + var x = origin.X; + for (var i = 0; i < items.Count; i++) + { + var item = items[i]; + var brush = GetBrush(item.BrushKey); + var text = CreateText(item.Text, emSize, brush); + var width = 16 + 6 + text.Width; + if (x + width > maxRight) break; + var cy = origin.Y + text.Height / 2; + DrawSwatch(dc, item.Swatch, item.BrushKey, new Rect(x, cy - 5, 16, 10)); + dc.DrawText(text, new Point(x + 22, origin.Y)); + x += width + 16; + } + return x; + } + + /// Draws a legend swatch centred in . + protected void DrawSwatch(DrawingContext dc, LegendSwatch swatch, string brushKey, Rect box) + { + var cy = box.Top + box.Height / 2; + var cx = box.Left + box.Width / 2; + switch (swatch) + { + case LegendSwatch.Line: + case LegendSwatch.DashedLine: + case LegendSwatch.DottedLine: + var dash = swatch == LegendSwatch.Line ? LineDash.Solid : swatch == LegendSwatch.DashedLine ? LineDash.Dashed : LineDash.Dotted; + dc.DrawLine(GetPen(brushKey, 2, dash), new Point(box.Left + 1, cy), new Point(box.Right - 1, cy)); + break; + case LegendSwatch.Square: + dc.DrawRoundedRectangle(GetBrush(brushKey), null, new Rect(cx - 4, cy - 4, 8, 8), 2, 2); + break; + default: + var geometry = new StreamGeometry(); + using (var ctx = geometry.Open()) + { + if (swatch == LegendSwatch.Triangle) AddTriangleDown(ctx, cx, cy - 3.5, 9); + else AddDiamond(ctx, cx, cy, 9); + } + geometry.Freeze(); + dc.DrawGeometry(GetBrush(brushKey), null, geometry); + break; + } + } + + private static DashStyle DashFor(LineDash dash, double thickness) + { + if (dash == LineDash.Solid || !(thickness > 0)) return DashStyles.Solid; + // DashStyle lengths are multiples of the pen thickness; the patterns are specified in DIPs. + var style = dash == LineDash.Dashed + ? new DashStyle([5 / thickness, 4 / thickness], 0) + : new DashStyle([2 / thickness, 3 / thickness], 0); + style.Freeze(); + return style; + } + + private static void OnThemeProbeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) + { + var element = (DrawingElement)d; + element._brushes.Clear(); + element._pens.Clear(); + element._regular = element._semiBold = null; + element.OnThemeChanged(); + } + + private Typeface CreateTypeface(FontWeight weight) => + new(TryFindResource("Font.Ui") as FontFamily ?? SystemFonts.MessageFontFamily, FontStyles.Normal, weight, FontStretches.Normal); + + private void OnWatchedCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e) => OnDataChanged(); +} diff --git a/src/Titano.Ui/Visuals/HoverReadout.cs b/src/Titano.Ui/Visuals/HoverReadout.cs new file mode 100644 index 00000000..53d50b80 --- /dev/null +++ b/src/Titano.Ui/Visuals/HoverReadout.cs @@ -0,0 +1,51 @@ +using System.Windows; +using System.Windows.Controls; +using System.Windows.Controls.Primitives; + +namespace Titano.Ui.Visuals; + +/// +/// A tooltip (same style as every other) that opens at once and follows the mouse to read out the value under +/// the cursor. While it shows, the owner's own tooltip (which describes the action) is suppressed. +/// +public sealed class HoverReadout(FrameworkElement owner) +{ + private ToolTip? _tip; + private object? _savedEnabled; + + public bool IsOpen => _tip?.IsOpen == true; + + /// Shows next to (owner coordinates); empty text hides the readout. + public void Show(string? text, Point position) + { + if (string.IsNullOrEmpty(text)) + { + Hide(); + return; + } + _tip ??= new ToolTip + { + Placement = PlacementMode.Relative, + PlacementTarget = owner, + IsHitTestVisible = false, + Focusable = false, + }; + if (!Equals(_tip.Content, text)) _tip.Content = text; + // Below-right of the cursor so the popup never sits under the mouse (which would end the hover). + _tip.HorizontalOffset = position.X + 12; + _tip.VerticalOffset = position.Y + 18; + if (_tip.IsOpen) return; + _savedEnabled = owner.ReadLocalValue(ToolTipService.IsEnabledProperty); + ToolTipService.SetIsEnabled(owner, false); + _tip.IsOpen = true; + } + + public void Hide() + { + if (_tip is not { IsOpen: true }) return; + _tip.IsOpen = false; + if (_savedEnabled is null || _savedEnabled == DependencyProperty.UnsetValue) owner.ClearValue(ToolTipService.IsEnabledProperty); + else owner.SetValue(ToolTipService.IsEnabledProperty, _savedEnabled); + _savedEnabled = null; + } +} From 0e2f9fd4f43236a6154df750d62f6bdc275dcc3e Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 10:26:49 +0000 Subject: [PATCH 03/13] feat(ui-visuals): add VirtualizingWrapPanel for the Library grid Fixed-size wrapped items with pixel scrolling (IScrollInfo), one cached row per side, container recycling, O(1) index/offset mapping, scrolling padding, reflow anchoring on resize and grid keyboard navigation with selection. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- .../Visuals/VirtualizingWrapPanel.cs | 412 ++++++++++++++++++ 1 file changed, 412 insertions(+) create mode 100644 src/Titano.Ui/Visuals/VirtualizingWrapPanel.cs diff --git a/src/Titano.Ui/Visuals/VirtualizingWrapPanel.cs b/src/Titano.Ui/Visuals/VirtualizingWrapPanel.cs new file mode 100644 index 00000000..c100bb56 --- /dev/null +++ b/src/Titano.Ui/Visuals/VirtualizingWrapPanel.cs @@ -0,0 +1,412 @@ +using System.Collections.Specialized; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Controls.Primitives; +using System.Windows.Input; +using System.Windows.Media; + +namespace Titano.Ui.Visuals; + +/// +/// Items host that wraps fixed-size items into rows and scrolls vertically by pixels (BRIEF §12.2: Library grid, +/// 60 fps over 500k items). Only the rows in view plus one row above and below have containers; containers are +/// recycled when the owner's is Recycling. Index ↔ offset +/// mapping is O(1) (). Arrow keys, PageUp/PageDown and Home/End move focus and selection +/// in grid order (Ctrl moves focus only, Shift extends an Extended selection). Requires a ScrollViewer with +/// CanContentScroll="True"; grouping is not supported. +/// +public sealed class VirtualizingWrapPanel : VirtualizingPanel, IScrollInfo +{ + public static readonly DependencyProperty ItemWidthProperty = DependencyProperty.Register( + nameof(ItemWidth), typeof(double), typeof(VirtualizingWrapPanel), + new FrameworkPropertyMetadata(236.0, FrameworkPropertyMetadataOptions.AffectsMeasure), IsPositive); + + public static readonly DependencyProperty ItemHeightProperty = DependencyProperty.Register( + nameof(ItemHeight), typeof(double), typeof(VirtualizingWrapPanel), + new FrameworkPropertyMetadata(208.0, FrameworkPropertyMetadataOptions.AffectsMeasure), IsPositive); + + public static readonly DependencyProperty SpacingProperty = DependencyProperty.Register( + nameof(Spacing), typeof(double), typeof(VirtualizingWrapPanel), + new FrameworkPropertyMetadata(16.0, FrameworkPropertyMetadataOptions.AffectsMeasure), IsNonNegative); + + public static readonly DependencyProperty JustifyProperty = DependencyProperty.Register( + nameof(Justify), typeof(bool), typeof(VirtualizingWrapPanel), + new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.AffectsMeasure)); + + public static readonly DependencyProperty PaddingProperty = DependencyProperty.Register( + nameof(Padding), typeof(Thickness), typeof(VirtualizingWrapPanel), + new FrameworkPropertyMetadata(default(Thickness), FrameworkPropertyMetadataOptions.AffectsMeasure)); + + /// Rows realized beyond each edge of the viewport so the next row is ready before it scrolls in. + private const int CacheRows = 1; + + private WrapLayout _layout; + private Thickness _padding; + private Size _viewport; + private Size _extent; + private double _offset; + private int _realizedFirst; + private int _realizedLast = -1; + private bool _generationDirty = true; + private int _anchor = -1; + private int _rangeAnchor = -1; + private int _rangeEnd = -1; + + /// Slot width of one item container (DESIGN §4: cards are 236 px). + public double ItemWidth { get => (double)GetValue(ItemWidthProperty); set => SetValue(ItemWidthProperty, value); } + + /// Slot height of one item container. + public double ItemHeight { get => (double)GetValue(ItemHeightProperty); set => SetValue(ItemHeightProperty, value); } + + /// Gap between columns and between rows. + public double Spacing { get => (double)GetValue(SpacingProperty); set => SetValue(SpacingProperty, value); } + + /// Spread leftover width over the column gaps so the grid spans the full width. + public bool Justify { get => (bool)GetValue(JustifyProperty); set => SetValue(JustifyProperty, value); } + + /// Space around the grid that scrolls with the items (unlike a ScrollViewer padding, which clips them). + public Thickness Padding { get => (Thickness)GetValue(PaddingProperty); set => SetValue(PaddingProperty, value); } + + public bool CanHorizontallyScroll { get; set; } + + public bool CanVerticallyScroll { get; set; } + + public double ExtentWidth => _extent.Width; + + public double ExtentHeight => _extent.Height; + + public double ViewportWidth => _viewport.Width; + + public double ViewportHeight => _viewport.Height; + + public double HorizontalOffset => 0; + + public double VerticalOffset => _offset; + + public ScrollViewer? ScrollOwner { get; set; } + + /// Scroll distance of one line: a quarter row, at least 16 px. + private double LineSize => Math.Max(16, _layout.RowPitch / 4); + + public void LineUp() => SetVerticalOffset(_offset - LineSize); + + public void LineDown() => SetVerticalOffset(_offset + LineSize); + + public void PageUp() => SetVerticalOffset(_offset - _viewport.Height); + + public void PageDown() => SetVerticalOffset(_offset + _viewport.Height); + + public void MouseWheelUp() => SetVerticalOffset(_offset - WheelDistance()); + + public void MouseWheelDown() => SetVerticalOffset(_offset + WheelDistance()); + + public void LineLeft() + { + } + + public void LineRight() + { + } + + public void PageLeft() + { + } + + public void PageRight() + { + } + + public void MouseWheelLeft() + { + } + + public void MouseWheelRight() + { + } + + /// Only vertical scrolling exists: rows always fit the width. + public void SetHorizontalOffset(double offset) + { + } + + public void SetVerticalOffset(double offset) + { + offset = ClampOffset(offset); + if (offset == _offset) return; + _offset = offset; + ScrollOwner?.InvalidateScrollInfo(); + InvalidateMeasure(); + } + + public Rect MakeVisible(Visual visual, Rect rectangle) + { + if (rectangle.IsEmpty || visual is null || ReferenceEquals(visual, this) || !IsAncestorOf(visual)) return Rect.Empty; + var bounds = visual.TransformToAncestor(this).TransformBounds(rectangle); + var top = bounds.Top + _offset; + SetVerticalOffset(WrapLayout.OffsetToReveal(top, bounds.Height, _offset, _viewport.Height)); + bounds.Y = top - _offset; + return bounds; + } + + protected override void BringIndexIntoView(int index) + { + var owner = ItemsControl.GetItemsOwner(this); + if (owner is null || index < 0 || index >= owner.Items.Count) return; + if (_layout.Columns == 0) UpdateLayout(); + if (_layout.Columns == 0) return; + SetVerticalOffset(WrapLayout.OffsetToReveal(_padding.Top + _layout.TopOf(index), _layout.ItemHeight, _offset, _viewport.Height)); + UpdateLayout(); + } + + protected override Size MeasureOverride(Size availableSize) + { + var owner = ItemsControl.GetItemsOwner(this); + var count = owner?.Items.Count ?? 0; + var previous = _layout; + var previousTop = _padding.Top; + _padding = Padding; + var horizontal = _padding.Left + _padding.Right; + var vertical = _padding.Top + _padding.Bottom; + _layout = new WrapLayout(count, Math.Max(0, availableSize.Width - horizontal), ItemWidth, ItemHeight, Spacing, Justify); + KeepTopItemOnReflow(previous, previousTop); + + var extent = new Size(_layout.ExtentWidth + horizontal, _layout.ExtentHeight + vertical); + var viewportHeight = double.IsInfinity(availableSize.Height) ? extent.Height : availableSize.Height; + var viewportWidth = double.IsInfinity(availableSize.Width) ? extent.Width : availableSize.Width; + UpdateScrollInfo(new Size(viewportWidth, viewportHeight), new Size(Math.Max(viewportWidth, extent.Width), extent.Height)); + + if (owner is not null) + { + var (first, last) = _layout.VisibleRange(_offset - _padding.Top, viewportHeight, CacheRows); + if (_generationDirty || first != _realizedFirst || last != _realizedLast) + { + CleanUp(owner, first, last); + Realize(first, last); + _realizedFirst = first; + _realizedLast = last; + _generationDirty = false; + } + var slot = new Size(ItemWidth, ItemHeight); + var children = InternalChildren; + for (var i = 0; i < children.Count; i++) children[i].Measure(slot); + } + return new Size(viewportWidth, viewportHeight); + } + + protected override Size ArrangeOverride(Size finalSize) + { + var generator = ItemContainerGenerator; + var children = InternalChildren; + if (generator is null) return finalSize; + for (var i = 0; i < children.Count; i++) + { + var index = generator.IndexFromGeneratorPosition(new GeneratorPosition(i, 0)); + if (index < 0) continue; + children[i].Arrange(new Rect(_padding.Left + _layout.LeftOf(index), _padding.Top + _layout.TopOf(index) - _offset, ItemWidth, ItemHeight)); + } + return finalSize; + } + + protected override void OnItemsChanged(object sender, ItemsChangedEventArgs args) + { + base.OnItemsChanged(sender, args); + switch (args.Action) + { + case NotifyCollectionChangedAction.Remove: + case NotifyCollectionChangedAction.Replace: + RemoveChildRange(args.Position, args.ItemUICount); + break; + case NotifyCollectionChangedAction.Move: + RemoveChildRange(args.OldPosition, args.ItemUICount); + break; + } + _generationDirty = true; + _anchor = _rangeAnchor = _rangeEnd = -1; + InvalidateMeasure(); + } + + protected override void OnClearChildren() + { + base.OnClearChildren(); + _generationDirty = true; + _realizedFirst = 0; + _realizedLast = -1; + } + + /// Wheel scrolling proportional to the delta, so precision touchpads scroll smoothly. + protected override void OnMouseWheel(MouseWheelEventArgs e) + { + base.OnMouseWheel(e); + if (e.Handled || ScrollOwner is null) return; + var before = _offset; + SetVerticalOffset(_offset - e.Delta / (double)Mouse.MouseWheelDeltaForOneLine * WheelDistance()); + e.Handled = _offset != before; + } + + protected override void OnKeyDown(KeyEventArgs e) + { + base.OnKeyDown(e); + if (e.Handled || (Keyboard.Modifiers & ModifierKeys.Alt) != 0) return; + var step = StepFor(e.Key); + var owner = ItemsControl.GetItemsOwner(this); + if (step is null || owner is null || _layout.ItemCount == 0) return; + var current = FocusedIndex(owner); + if (current < 0) return; + e.Handled = true; + var target = _layout.Navigate(current, step.Value, _layout.PageRows(_viewport.Height)); + if (target != current) NavigateTo(owner, current, target); + } + + private static bool IsPositive(object value) => value is double d && double.IsFinite(d) && d > 0; + + private static bool IsNonNegative(object value) => value is double d && double.IsFinite(d) && d >= 0; + + private double WheelDistance() + { + var lines = SystemParameters.WheelScrollLines; + return lines < 0 ? _viewport.Height : lines * LineSize; + } + + /// When the column count changes (resize), keeps the first visible item at the same height in the viewport. + private void KeepTopItemOnReflow(WrapLayout previous, double previousTop) + { + if (previous.Columns == _layout.Columns || previous.ItemCount == 0 || _layout.ItemCount == 0) return; + var (top, _) = previous.VisibleRange(_offset - previousTop, Math.Max(1, _viewport.Height)); + if (top < 0 || top >= _layout.ItemCount) return; + var delta = _offset - (previousTop + previous.TopOf(top)); + _offset = _padding.Top + _layout.TopOf(top) + delta; + } + + private double ClampOffset(double offset) => + double.IsNaN(offset) ? 0 : Math.Clamp(offset, 0, Math.Max(0, _extent.Height - _viewport.Height)); + + private void UpdateScrollInfo(Size viewport, Size extent) + { + var changed = viewport != _viewport || extent != _extent; + _viewport = viewport; + _extent = extent; + var clamped = ClampOffset(_offset); + if (clamped != _offset) + { + _offset = clamped; + changed = true; + } + if (changed) ScrollOwner?.InvalidateScrollInfo(); + } + + /// Recycles (or removes) containers outside [first, last]; a container holding keyboard focus is kept. + private void CleanUp(ItemsControl owner, int first, int last) + { + var generator = ItemContainerGenerator; + if (generator is null) return; + var recycling = GetVirtualizationMode(owner) == VirtualizationMode.Recycling; + var children = InternalChildren; + for (var i = children.Count - 1; i >= 0; i--) + { + var position = new GeneratorPosition(i, 0); + var index = generator.IndexFromGeneratorPosition(position); + if ((index >= first && index <= last) || children[i].IsKeyboardFocusWithin) continue; + if (recycling) ((IRecyclingItemContainerGenerator)generator).Recycle(position, 1); + else generator.Remove(position, 1); + RemoveInternalChildRange(i, 1); + } + } + + /// Generates containers for [first, last], inserting them so children stay in item order. + private void Realize(int first, int last) + { + var generator = ItemContainerGenerator; + if (generator is null || last < first) return; + var start = generator.GeneratorPositionFromIndex(first); + var childIndex = start.Offset == 0 ? start.Index : start.Index + 1; + using (generator.StartAt(start, GeneratorDirection.Forward, true)) + { + for (var i = first; i <= last; i++, childIndex++) + { + if (generator.GenerateNext(out var newlyRealized) is not UIElement child) break; + if (!newlyRealized) continue; + if (childIndex >= InternalChildren.Count) AddInternalChild(child); + else InsertInternalChild(childIndex, child); + generator.PrepareItemContainer(child); + } + } + } + + private void RemoveChildRange(GeneratorPosition position, int uiCount) + { + if (uiCount <= 0) return; + var index = position.Offset > 0 ? position.Index + 1 : position.Index; + var children = InternalChildren; + if (index < children.Count) RemoveInternalChildRange(index, Math.Min(uiCount, children.Count - index)); + } + + private WrapStep? StepFor(Key key) + { + var rtl = FlowDirection == FlowDirection.RightToLeft; + return key switch + { + Key.Left => rtl ? WrapStep.Right : WrapStep.Left, + Key.Right => rtl ? WrapStep.Left : WrapStep.Right, + Key.Up => WrapStep.Up, + Key.Down => WrapStep.Down, + Key.PageUp => WrapStep.PageUp, + Key.PageDown => WrapStep.PageDown, + Key.Home => WrapStep.First, + Key.End => WrapStep.Last, + _ => null, + }; + } + + private static int FocusedIndex(ItemsControl owner) + { + if (Keyboard.FocusedElement is not DependencyObject focused) return -1; + var container = owner.ContainerFromElement(focused); + return container is null ? -1 : owner.ItemContainerGenerator.IndexFromContainer(container); + } + + private void NavigateTo(ItemsControl owner, int from, int to) + { + BringIndexIntoView(to); + if (owner.ItemContainerGenerator.ContainerFromIndex(to) is not UIElement container) return; + container.Focus(); + if (owner is not Selector selector) return; + + var modifiers = Keyboard.Modifiers; + var mode = owner is ListBox listBox ? listBox.SelectionMode : SelectionMode.Single; + if (mode == SelectionMode.Multiple || (mode == SelectionMode.Extended && (modifiers & ModifierKeys.Control) != 0)) return; + if (mode == SelectionMode.Extended && (modifiers & ModifierKeys.Shift) != 0) + { + SelectRange((ListBox)owner, from, to); + return; + } + selector.SelectedIndex = to; + _anchor = to; + _rangeAnchor = _rangeEnd = -1; + } + + /// Selects anchor…, touching only the items that enter or leave the previous range. + private void SelectRange(ListBox listBox, int from, int to) + { + var items = listBox.Items; + var anchor = _anchor >= 0 && _anchor < items.Count && listBox.SelectedItems.Contains(items[_anchor]) ? _anchor : from; + _anchor = anchor; + var newLow = Math.Min(anchor, to); + var newHigh = Math.Max(anchor, to); + if (_rangeAnchor != anchor || _rangeEnd < 0) + { + listBox.SelectedItems.Clear(); + for (var i = newLow; i <= newHigh; i++) listBox.SelectedItems.Add(items[i]); + } + else + { + var oldLow = Math.Min(anchor, _rangeEnd); + var oldHigh = Math.Max(anchor, _rangeEnd); + for (var i = oldLow; i <= oldHigh; i++) + if (i < newLow || i > newHigh) listBox.SelectedItems.Remove(items[i]); + for (var i = newLow; i <= newHigh; i++) + if (i < oldLow || i > oldHigh) listBox.SelectedItems.Add(items[i]); + } + _rangeAnchor = anchor; + _rangeEnd = to; + } +} From 0ac73793c7f56cbfde0c7257327e320099d2752e Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 10:26:50 +0000 Subject: [PATCH 04/13] feat(ui-visuals): add SequenceCard with asynchronous hover scrubbing Card control for the Library (16:9 thumbnail, badge, selection box, title, secondary line, status glyphs) whose thumbnail scrubs through the sequence from an IThumbnailSource, cancelling stale requests. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- src/Titano.Ui/Visuals/AspectRatioDecorator.cs | 36 ++++ src/Titano.Ui/Visuals/IThumbnailSource.cs | 17 ++ src/Titano.Ui/Visuals/SequenceCard.cs | 185 ++++++++++++++++++ 3 files changed, 238 insertions(+) create mode 100644 src/Titano.Ui/Visuals/AspectRatioDecorator.cs create mode 100644 src/Titano.Ui/Visuals/IThumbnailSource.cs create mode 100644 src/Titano.Ui/Visuals/SequenceCard.cs diff --git a/src/Titano.Ui/Visuals/AspectRatioDecorator.cs b/src/Titano.Ui/Visuals/AspectRatioDecorator.cs new file mode 100644 index 00000000..97023853 --- /dev/null +++ b/src/Titano.Ui/Visuals/AspectRatioDecorator.cs @@ -0,0 +1,36 @@ +using System.Windows; +using System.Windows.Controls; + +namespace Titano.Ui.Visuals; + +/// Sizes its child to the available width and a height of width ÷ (card thumbnails are 16:9). +public sealed class AspectRatioDecorator : Decorator +{ + public static readonly DependencyProperty RatioProperty = DependencyProperty.Register( + nameof(Ratio), typeof(double), typeof(AspectRatioDecorator), + new FrameworkPropertyMetadata(16.0 / 9.0, FrameworkPropertyMetadataOptions.AffectsMeasure), + v => v is double d && double.IsFinite(d) && d > 0); + + /// Width ÷ height. + public double Ratio { get => (double)GetValue(RatioProperty); set => SetValue(RatioProperty, value); } + + protected override Size MeasureOverride(Size constraint) + { + var size = Fit(constraint); + Child?.Measure(size); + return size; + } + + protected override Size ArrangeOverride(Size arrangeSize) + { + var size = Fit(arrangeSize); + Child?.Arrange(new Rect(size)); + return size; + } + + private Size Fit(Size available) + { + var width = double.IsInfinity(available.Width) ? 0 : available.Width; + return new Size(width, width / Ratio); + } +} diff --git a/src/Titano.Ui/Visuals/IThumbnailSource.cs b/src/Titano.Ui/Visuals/IThumbnailSource.cs new file mode 100644 index 00000000..09634142 --- /dev/null +++ b/src/Titano.Ui/Visuals/IThumbnailSource.cs @@ -0,0 +1,17 @@ +using System.Windows.Media; + +namespace Titano.Ui.Visuals; + +/// +/// Frames of a sequence as decoded thumbnails, loaded off the UI thread (filmstrip cells, card hover scrubbing). +/// Implementations return frozen images (or images created on the UI thread) and honour cancellation: a request +/// is cancelled as soon as the control no longer needs it. +/// +public interface IThumbnailSource +{ + /// Number of frames. + int Count { get; } + + /// Thumbnail of frame (0…Count−1) at least device pixels wide; null when unavailable. + ValueTask GetAsync(int index, int pixelWidth, CancellationToken cancellationToken); +} diff --git a/src/Titano.Ui/Visuals/SequenceCard.cs b/src/Titano.Ui/Visuals/SequenceCard.cs new file mode 100644 index 00000000..636fdf8a --- /dev/null +++ b/src/Titano.Ui/Visuals/SequenceCard.cs @@ -0,0 +1,185 @@ +using System.Collections; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Input; +using System.Windows.Media; +using Titano.Core.Diagnostics; +using Titano.Ui.Controls; + +namespace Titano.Ui.Visuals; + +/// One entry of a card's status row: glyph in the status colour, optional text (a count) and tooltip. +public sealed record CardStatus(StatusKind Kind, string? Text = null, string? ToolTip = null); + +/// +/// Library card (DESIGN §4 Cards): 236 px wide, 16:9 thumbnail with a count badge top-right and a selection check +/// box top-left (shown on hover or when selected), title, secondary line and status glyph row. Selected = accent +/// border with an AccentSelected glow. Moving the mouse across the thumbnail scrubs through the sequence: the +/// horizontal position picks a frame of , which is loaded asynchronously; stale requests +/// are cancelled and the last frame stays until the next one arrives. +/// +[TemplatePart(Name = PartThumbnail, Type = typeof(FrameworkElement))] +public class SequenceCard : Control +{ + public const string PartThumbnail = "PART_Thumbnail"; + + public static readonly DependencyProperty TitleProperty = DependencyProperty.Register(nameof(Title), typeof(string), typeof(SequenceCard)); + public static readonly DependencyProperty SubtitleProperty = DependencyProperty.Register(nameof(Subtitle), typeof(string), typeof(SequenceCard)); + public static readonly DependencyProperty BadgeProperty = DependencyProperty.Register(nameof(Badge), typeof(string), typeof(SequenceCard)); + public static readonly DependencyProperty StatusesProperty = DependencyProperty.Register(nameof(Statuses), typeof(IEnumerable), typeof(SequenceCard)); + public static readonly DependencyProperty SelectToolTipProperty = DependencyProperty.Register(nameof(SelectToolTip), typeof(object), typeof(SequenceCard)); + public static readonly DependencyProperty ActionsContentProperty = DependencyProperty.Register(nameof(ActionsContent), typeof(object), typeof(SequenceCard)); + + public static readonly DependencyProperty IsSelectedProperty = DependencyProperty.Register( + nameof(IsSelected), typeof(bool), typeof(SequenceCard), + new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault)); + + public static readonly DependencyProperty ThumbnailProperty = DependencyProperty.Register( + nameof(Thumbnail), typeof(ImageSource), typeof(SequenceCard), new PropertyMetadata(null, OnThumbnailChanged)); + + public static readonly DependencyProperty ScrubSourceProperty = DependencyProperty.Register( + nameof(ScrubSource), typeof(IThumbnailSource), typeof(SequenceCard), new PropertyMetadata(null, OnScrubSourceChanged)); + + private static readonly DependencyPropertyKey DisplayedThumbnailKey = DependencyProperty.RegisterReadOnly( + nameof(DisplayedThumbnail), typeof(ImageSource), typeof(SequenceCard), new PropertyMetadata(null)); + + private static readonly DependencyPropertyKey IsScrubbingKey = DependencyProperty.RegisterReadOnly( + nameof(IsScrubbing), typeof(bool), typeof(SequenceCard), new PropertyMetadata(false)); + + private static readonly DependencyPropertyKey ScrubPositionKey = DependencyProperty.RegisterReadOnly( + nameof(ScrubPosition), typeof(double), typeof(SequenceCard), new PropertyMetadata(0.0)); + + public static readonly DependencyProperty DisplayedThumbnailProperty = DisplayedThumbnailKey.DependencyProperty; + public static readonly DependencyProperty IsScrubbingProperty = IsScrubbingKey.DependencyProperty; + public static readonly DependencyProperty ScrubPositionProperty = ScrubPositionKey.DependencyProperty; + + private FrameworkElement? _thumbnailPart; + private CancellationTokenSource? _scrubCancellation; + private int _scrubIndex = -1; + + static SequenceCard() + { + DefaultStyleKeyProperty.OverrideMetadata(typeof(SequenceCard), new FrameworkPropertyMetadata(typeof(SequenceCard))); + } + + public SequenceCard() + { + DataContextChanged += (_, _) => StopScrub(); + } + + /// User title or "{date} {camera}". + public string? Title { get => (string?)GetValue(TitleProperty); set => SetValue(TitleProperty, value); } + + /// Secondary line: count · camera · span. + public string? Subtitle { get => (string?)GetValue(SubtitleProperty); set => SetValue(SubtitleProperty, value); } + + /// Count badge text (top-right of the thumbnail); hidden when empty. + public string? Badge { get => (string?)GetValue(BadgeProperty); set => SetValue(BadgeProperty, value); } + + /// entries of the status row. + public IEnumerable? Statuses { get => (IEnumerable?)GetValue(StatusesProperty); set => SetValue(StatusesProperty, value); } + + /// Tooltip of the selection check box. + public object? SelectToolTip { get => GetValue(SelectToolTipProperty); set => SetValue(SelectToolTipProperty, value); } + + /// Quick actions shown bottom-right of the thumbnail on hover (Open, Analyse, Render, Sync). + public object? ActionsContent { get => GetValue(ActionsContentProperty); set => SetValue(ActionsContentProperty, value); } + + /// Selection state; bind two-way to the container's IsSelected so the check box toggles it. + public bool IsSelected { get => (bool)GetValue(IsSelectedProperty); set => SetValue(IsSelectedProperty, value); } + + /// Hero thumbnail; may arrive later (asynchronous loading), a placeholder shows until then. + public ImageSource? Thumbnail { get => (ImageSource?)GetValue(ThumbnailProperty); set => SetValue(ThumbnailProperty, value); } + + /// Frames for hover scrubbing; null disables scrubbing. + public IThumbnailSource? ScrubSource { get => (IThumbnailSource?)GetValue(ScrubSourceProperty); set => SetValue(ScrubSourceProperty, value); } + + /// Image on screen: the scrubbed frame while scrubbing, otherwise . + public ImageSource? DisplayedThumbnail { get => (ImageSource?)GetValue(DisplayedThumbnailProperty); private set => SetValue(DisplayedThumbnailKey, value); } + + /// True while the mouse scrubs over the thumbnail. + public bool IsScrubbing { get => (bool)GetValue(IsScrubbingProperty); private set => SetValue(IsScrubbingKey, value); } + + /// Scrubbed position 0…1 along the sequence (drives the progress hairline). + public double ScrubPosition { get => (double)GetValue(ScrubPositionProperty); private set => SetValue(ScrubPositionKey, value); } + + public override void OnApplyTemplate() + { + base.OnApplyTemplate(); + _thumbnailPart = GetTemplateChild(PartThumbnail) as FrameworkElement; + } + + protected override void OnMouseMove(MouseEventArgs e) + { + base.OnMouseMove(e); + if (ScrubSource is not { Count: > 0 } source || _thumbnailPart is not { ActualWidth: > 0 } part) + { + StopScrub(); + return; + } + var p = e.GetPosition(part); + if (p.X < 0 || p.Y < 0 || p.X >= part.ActualWidth || p.Y >= part.ActualHeight) + { + StopScrub(); + return; + } + var count = source.Count; + var index = Math.Clamp((int)(p.X / part.ActualWidth * count), 0, count - 1); + IsScrubbing = true; + ScrubPosition = (index + 1.0) / count; + if (index == _scrubIndex) return; + _scrubIndex = index; + var pixelWidth = (int)Math.Ceiling(part.ActualWidth * VisualTreeHelper.GetDpi(this).DpiScaleX); + _ = LoadScrubFrameAsync(source, index, pixelWidth); + } + + protected override void OnMouseLeave(MouseEventArgs e) + { + base.OnMouseLeave(e); + StopScrub(); + } + + private static void OnThumbnailChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) + { + var card = (SequenceCard)d; + if (!card.IsScrubbing) card.DisplayedThumbnail = (ImageSource?)e.NewValue; + } + + private static void OnScrubSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) => ((SequenceCard)d).StopScrub(); + + private async Task LoadScrubFrameAsync(IThumbnailSource source, int index, int pixelWidth) + { + _scrubCancellation?.Cancel(); + var cancellation = new CancellationTokenSource(); + _scrubCancellation = cancellation; + try + { + // Continues on the UI thread: the result is applied only if this is still the frame under the mouse. + var image = await source.GetAsync(index, pixelWidth, cancellation.Token); + if (!cancellation.IsCancellationRequested && index == _scrubIndex && image is not null) DisplayedThumbnail = image; + } + catch (OperationCanceledException) + { + } + catch (Exception ex) + { + Log.Warning("ui.card", $"Scrub frame {index} failed", ex); + } + finally + { + if (ReferenceEquals(_scrubCancellation, cancellation)) _scrubCancellation = null; + cancellation.Dispose(); + } + } + + private void StopScrub() + { + _scrubCancellation?.Cancel(); + _scrubCancellation = null; + _scrubIndex = -1; + if (!IsScrubbing) return; + IsScrubbing = false; + ScrubPosition = 0; + DisplayedThumbnail = Thumbnail; + } +} From 3ba68fef1d376e6b734c8c106b08d7e2954f1a39 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 10:27:09 +0000 Subject: [PATCH 05/13] feat(ui-visuals): add Filmstrip with frame markers and thumbnail cache Cells sampled across the sequence load asynchronously into an LRU cache; exposure-step and keyframe markers sit above; click, drag, wheel and keys seek CurrentIndex, whose cell is outlined in Accent. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- src/Titano.Ui/Visuals/Filmstrip.cs | 337 +++++++++++++++++++++++++++++ 1 file changed, 337 insertions(+) create mode 100644 src/Titano.Ui/Visuals/Filmstrip.cs diff --git a/src/Titano.Ui/Visuals/Filmstrip.cs b/src/Titano.Ui/Visuals/Filmstrip.cs new file mode 100644 index 00000000..efa9001a --- /dev/null +++ b/src/Titano.Ui/Visuals/Filmstrip.cs @@ -0,0 +1,337 @@ +using System.Diagnostics.CodeAnalysis; +using System.Windows; +using System.Windows.Input; +using System.Windows.Media; +using Titano.Core.Diagnostics; + +namespace Titano.Ui.Visuals; + +/// +/// Strip of thumbnails sampled across a sequence (BRIEF §12.3, Editor mockup) with frame markers above it +/// (exposure steps ▼ in Sun/Warning, keyframes ◆ in Accent). The cell holding is outlined +/// in Accent and an accent ▼ marks the exact frame. Click or drag seeks, the wheel and arrow keys step one frame +/// (PageUp/PageDown one cell, Home/End the ends). Thumbnails load asynchronously from into an +/// LRU cache; cells show a placeholder until their image arrives. Hovering a marker reads out its label. +/// +public sealed class Filmstrip : DrawingElement +{ + public static readonly DependencyProperty SourceProperty = DependencyProperty.Register( + nameof(Source), typeof(IThumbnailSource), typeof(Filmstrip), new PropertyMetadata(null, OnSourceChanged)); + + public static readonly DependencyProperty CurrentIndexProperty = DependencyProperty.Register( + nameof(CurrentIndex), typeof(int), typeof(Filmstrip), + new FrameworkPropertyMetadata(0, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnCurrentIndexChanged, CoerceCurrentIndex)); + + public static readonly DependencyProperty MarkersProperty = DependencyProperty.Register( + nameof(Markers), typeof(IReadOnlyList), typeof(Filmstrip), new PropertyMetadata(null, OnDataPropertyChanged)); + + public static readonly DependencyProperty CellWidthProperty = DependencyProperty.Register( + nameof(CellWidth), typeof(double), typeof(Filmstrip), + new FrameworkPropertyMetadata(38.0, FrameworkPropertyMetadataOptions.AffectsRender), v => v is double d && d >= 4); + + public static readonly DependencyProperty CacheCapacityProperty = DependencyProperty.Register( + nameof(CacheCapacity), typeof(int), typeof(Filmstrip), new PropertyMetadata(256, OnCacheCapacityChanged), v => v is int i && i > 0); + + private const double MarkerRow = 11; + private const double Gap = 2; + private const double Radius = 4; + private const double CellHeight = 44; + + private static readonly MarkerKind[] Kinds = Enum.GetValues(); + + private LruCache _cache = new(256); + private readonly HashSet _pending = []; + private CancellationTokenSource _loads = new(); + private StripLayout _strip; + private Rect _cells; + private bool _dragging; + private int _wheelDelta; + + static Filmstrip() + { + FocusableProperty.OverrideMetadata(typeof(Filmstrip), new FrameworkPropertyMetadata(true)); + CursorProperty.OverrideMetadata(typeof(Filmstrip), new FrameworkPropertyMetadata(Cursors.Hand)); + } + + public Filmstrip() + : base(hasOverlay: true) + { + } + + /// Frames of the sequence. + public IThumbnailSource? Source { get => (IThumbnailSource?)GetValue(SourceProperty); set => SetValue(SourceProperty, value); } + + /// Current frame (two-way): set by clicks, drags, wheel and keys. + public int CurrentIndex { get => (int)GetValue(CurrentIndexProperty); set => SetValue(CurrentIndexProperty, value); } + + /// Markers drawn above the cells. + public IReadOnlyList? Markers { get => (IReadOnlyList?)GetValue(MarkersProperty); set => SetValue(MarkersProperty, value); } + + /// Target cell width; the cells stretch to fill the strip exactly. + public double CellWidth { get => (double)GetValue(CellWidthProperty); set => SetValue(CellWidthProperty, value); } + + /// Decoded thumbnails kept in memory. + public int CacheCapacity { get => (int)GetValue(CacheCapacityProperty); set => SetValue(CacheCapacityProperty, value); } + + private int FrameCount => Source?.Count ?? 0; + + protected override Size MeasureOverride(Size availableSize) => new(0, MarkerRow + 3 + CellHeight); + + protected override void OnRender(DrawingContext dc) + { + DrawHitArea(dc); + var width = ActualWidth; + _cells = new Rect(0, MarkerRow + 3, width, Math.Max(0, ActualHeight - MarkerRow - 3)); + _strip = new StripLayout(width, CellWidth, Gap, FrameCount); + if (_strip.CellCount == 0 || _cells.Height <= 0) + { + dc.DrawRoundedRectangle(GetBrush("Brush.Card"), null, _cells, Radius, Radius); + RenderOverlay(); + return; + } + + var scale = PixelScale; + // Request enough pixels to cover the cell for frames up to 16:9 (UniformToFill crop). + var pixelWidth = (int)Math.Ceiling(Math.Max(_strip.CellWidth, _cells.Height * 16 / 9) * scale); + var placeholder = GetBrush("Brush.Card"); + dc.PushClip(new RectangleGeometry(_cells, Radius, Radius)); + for (var c = 0; c < _strip.CellCount; c++) + { + var cell = new Rect(PixelGrid.Snap(_strip.CellLeft(c), scale), _cells.Top, 0, _cells.Height); + cell.Width = PixelGrid.Snap(_strip.CellLeft(c) + _strip.CellWidth, scale) - cell.Left; + var frame = _strip.FrameForCell(c); + if (TryGetFrame(frame, pixelWidth, out var image)) DrawCover(dc, image, cell); + else dc.DrawRectangle(placeholder, null, cell); + } + dc.Pop(); + DrawMarkers(dc); + RenderOverlay(); + } + + protected override void OnRenderOverlay(DrawingContext dc) + { + if (_strip.CellCount == 0) return; + var frame = Math.Clamp(CurrentIndex, 0, _strip.FrameCount - 1); + var cellIndex = _strip.CellForFrame(frame); + var scale = PixelScale; + var left = PixelGrid.Snap(_strip.CellLeft(cellIndex), scale); + var right = PixelGrid.Snap(_strip.CellLeft(cellIndex) + _strip.CellWidth, scale); + // 2-px accent outline drawn inside the cell. + var outline = new Rect(left + 1, _cells.Top + 1, Math.Max(0, right - left - 2), Math.Max(0, _cells.Height - 2)); + dc.DrawRectangle(null, GetPen("Brush.Accent", 2), outline); + + var marker = new StreamGeometry(); + using (var ctx = marker.Open()) AddTriangleDown(ctx, _strip.XForFrame(frame), 1, 9); + marker.Freeze(); + dc.DrawGeometry(GetBrush("Brush.Accent"), null, marker); + } + + protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e) + { + base.OnMouseLeftButtonDown(e); + if (_strip.FrameCount == 0) return; + Focus(); + _dragging = CaptureMouse(); + Seek(e.GetPosition(this).X); + e.Handled = true; + } + + protected override void OnMouseMove(MouseEventArgs e) + { + base.OnMouseMove(e); + var p = e.GetPosition(this); + if (_dragging) + { + Seek(p.X); + Readout.Hide(); + return; + } + Readout.Show(p.Y < _cells.Top ? MarkerLabelAt(p.X) : null, 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); + Readout.Hide(); + } + + protected override void OnMouseWheel(MouseWheelEventArgs e) + { + base.OnMouseWheel(e); + if (_strip.FrameCount == 0) return; + // Accumulate so precision touchpads step once per notch-equivalent; wheel down moves forward. + _wheelDelta += e.Delta; + var steps = _wheelDelta / Mouse.MouseWheelDeltaForOneLine; + _wheelDelta -= steps * Mouse.MouseWheelDeltaForOneLine; + if (steps != 0) SetCurrentValue(CurrentIndexProperty, CurrentIndex - steps); + e.Handled = true; + } + + protected override void OnKeyDown(KeyEventArgs e) + { + base.OnKeyDown(e); + var count = FrameCount; + if (count == 0) return; + var cellFrames = Math.Max(1, count / Math.Max(1, _strip.CellCount)); + int? target = e.Key switch + { + Key.Left => CurrentIndex - 1, + Key.Right => CurrentIndex + 1, + Key.PageUp => CurrentIndex - cellFrames, + Key.PageDown => CurrentIndex + cellFrames, + Key.Home => 0, + Key.End => count - 1, + _ => null, + }; + if (target is null) return; + SetCurrentValue(CurrentIndexProperty, target.Value); + e.Handled = true; + } + + private static void OnSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) + { + var strip = (Filmstrip)d; + strip.ResetCache(); + strip.CoerceValue(CurrentIndexProperty); + strip.InvalidateVisual(); + } + + private static void OnCurrentIndexChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) => ((Filmstrip)d).RenderOverlay(); + + private static object CoerceCurrentIndex(DependencyObject d, object value) + { + var count = ((Filmstrip)d).FrameCount; + return count == 0 ? 0 : Math.Clamp((int)value, 0, count - 1); + } + + private static void OnCacheCapacityChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) => + ((Filmstrip)d)._cache.Capacity = (int)e.NewValue; + + /// Draws scaled to cover , centred and cropped. + private static void DrawCover(DrawingContext dc, ImageSource image, Rect cell) + { + var w = image.Width; + var h = image.Height; + if (!(w > 0) || !(h > 0)) return; + var s = Math.Max(cell.Width / w, cell.Height / h); + var target = new Rect(cell.Left + (cell.Width - w * s) / 2, cell.Top + (cell.Height - h * s) / 2, w * s, h * s); + dc.PushClip(new RectangleGeometry(cell)); + dc.DrawImage(image, target); + dc.Pop(); + } + + private void DrawMarkers(DrawingContext dc) + { + if (Markers is not { Count: > 0 } markers) return; + foreach (var kind in Kinds) + { + StreamGeometry? geometry = null; + StreamGeometryContext? ctx = null; + for (var i = 0; i < markers.Count; i++) + { + var m = markers[i]; + if (m.Kind != kind || m.Index < 0 || m.Index >= _strip.FrameCount) continue; + if (ctx is null) + { + geometry = new StreamGeometry(); + ctx = geometry.Open(); + } + var x = _strip.XForFrame(m.Index); + if (kind == MarkerKind.Keyframe) AddDiamond(ctx, x, MarkerRow / 2, 8); + else AddTriangleDown(ctx, x, 1, 9); + } + if (ctx is null || geometry is null) continue; + ctx.Close(); + geometry.Freeze(); + dc.DrawGeometry(GetBrush(TimelineMarker.BrushKeyOf(kind)), null, geometry); + } + } + + /// Labels of the markers within 5 px of , one per line. + private string? MarkerLabelAt(double x) + { + if (Markers is not { Count: > 0 } markers || _strip.FrameCount == 0) return null; + string? text = null; + for (var i = 0; i < markers.Count; i++) + { + var m = markers[i]; + if (string.IsNullOrEmpty(m.Label) || Math.Abs(_strip.XForFrame(m.Index) - x) > 5) continue; + text = text is null ? m.Label : text + Environment.NewLine + m.Label; + } + return text; + } + + private void Seek(double x) + { + var frame = _strip.FrameAt(x); + if (frame >= 0) SetCurrentValue(CurrentIndexProperty, frame); + } + + private bool TryGetFrame(int frame, int pixelWidth, [NotNullWhen(true)] out ImageSource? image) + { + if (_cache.TryGet(frame, out var cached)) + { + // An image narrower than 80 % of the need (e.g. after a resize) stays on screen while a sharper one loads. + if (cached.PixelWidth < pixelWidth * 0.8) Request(frame, pixelWidth); + image = cached.Image; + return true; + } + Request(frame, pixelWidth); + image = null; + return false; + } + + private void Request(int frame, int pixelWidth) + { + if (Source is not { } source || !_pending.Add(frame)) return; + _ = LoadAsync(source, frame, pixelWidth, _loads.Token); + } + + private async Task LoadAsync(IThumbnailSource source, int frame, int pixelWidth, CancellationToken token) + { + try + { + // Requests are issued while rendering; leave the render pass before touching the cache. + await Task.Yield(); + token.ThrowIfCancellationRequested(); + var image = await source.GetAsync(frame, pixelWidth, token); + if (token.IsCancellationRequested || image is null) return; + _cache.Set(frame, new CachedFrame(image, pixelWidth)); + InvalidateVisual(); + } + catch (OperationCanceledException) + { + } + catch (Exception ex) + { + Log.Warning("ui.filmstrip", $"Thumbnail {frame} failed", ex); + } + finally + { + if (!token.IsCancellationRequested) _pending.Remove(frame); + } + } + + private void ResetCache() + { + // Not disposed: loads still in flight may observe the token after this point. + _loads.Cancel(); + _loads = new CancellationTokenSource(); + _pending.Clear(); + _cache = new LruCache(CacheCapacity); + } + + private readonly record struct CachedFrame(ImageSource Image, int PixelWidth); +} From df4af1013ac365a07bab7b1c4c678e64673765bf Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 10:27:09 +0000 Subject: [PATCH 06/13] 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 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- src/Titano.Ui/Visuals/BarChart.cs | 277 ++++++++++++++++ src/Titano.Ui/Visuals/HeatmapStrip.cs | 241 ++++++++++++++ src/Titano.Ui/Visuals/SeriesChart.cs | 428 +++++++++++++++++++++++++ src/Titano.Ui/Visuals/StackedBar.cs | 203 ++++++++++++ src/Titano.Ui/Visuals/TimelineBands.cs | 202 ++++++++++++ 5 files changed, 1351 insertions(+) create mode 100644 src/Titano.Ui/Visuals/BarChart.cs create mode 100644 src/Titano.Ui/Visuals/HeatmapStrip.cs create mode 100644 src/Titano.Ui/Visuals/SeriesChart.cs create mode 100644 src/Titano.Ui/Visuals/StackedBar.cs create mode 100644 src/Titano.Ui/Visuals/TimelineBands.cs diff --git a/src/Titano.Ui/Visuals/BarChart.cs b/src/Titano.Ui/Visuals/BarChart.cs new file mode 100644 index 00000000..2d075d32 --- /dev/null +++ b/src/Titano.Ui/Visuals/BarChart.cs @@ -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; + +/// +/// 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 (). Hovering reads out the bar; clicking raises +/// . +/// +public sealed class BarChart : DrawingElement +{ + public static readonly DependencyProperty ItemsProperty = DependencyProperty.Register( + nameof(Items), typeof(IReadOnlyList), 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), 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; + + /// Bars in display order. + public IReadOnlyList? Items { get => (IReadOnlyList?)GetValue(ItemsProperty); set => SetValue(ItemsProperty, value); } + + public Orientation Orientation { get => (Orientation)GetValue(OrientationProperty); set => SetValue(OrientationProperty, value); } + + /// Theme brush key of the bars (items may override). + public string BrushKey { get => (string)GetValue(BrushKeyProperty); set => SetValue(BrushKeyProperty, value); } + + /// Opacity of a zero bar; bars ramp linearly to 1 at the maximum (1 = flat colour). + public double MinimumOpacity { get => (double)GetValue(MinimumOpacityProperty); set => SetValue(MinimumOpacityProperty, value); } + + public bool ShowValues { get => (bool)GetValue(ShowValuesProperty); set => SetValue(ShowValuesProperty, value); } + + /// Value-axis gridlines and tick labels. + public bool ShowGrid { get => (bool)GetValue(ShowGridProperty); set => SetValue(ShowGridProperty, value); } + + /// Value at full length; NaN = the largest value (or the nice tick above it with the grid on). + public double Maximum { get => (double)GetValue(MaximumProperty); set => SetValue(MaximumProperty, value); } + + /// Maximum bar thickness in DIPs. + public double BarThickness { get => (double)GetValue(BarThicknessProperty); set => SetValue(BarThicknessProperty, value); } + + /// Culture-aware value formatting for value labels, ticks and readouts. + public Func? ValueFormatter { get => (Func?)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 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 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 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; + } + } + + /// Gridlines at nice ticks along the value axis, with labels below (horizontal bars) or left (vertical bars). + 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; + } +} diff --git a/src/Titano.Ui/Visuals/HeatmapStrip.cs b/src/Titano.Ui/Visuals/HeatmapStrip.cs new file mode 100644 index 00000000..35fe46dc --- /dev/null +++ b/src/Titano.Ui/Visuals/HeatmapStrip.cs @@ -0,0 +1,241 @@ +using System.Windows; +using System.Windows.Input; +using System.Windows.Media; +using Titano.Core.Localization; + +namespace Titano.Ui.Visuals; + +/// +/// 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 . +/// +public sealed class HeatmapStrip : DrawingElement +{ + public static readonly DependencyProperty RowsProperty = DependencyProperty.Register( + nameof(Rows), typeof(IReadOnlyList), typeof(HeatmapStrip), new PropertyMetadata(null, OnDataPropertyChanged)); + + public static readonly DependencyProperty ColumnLabelsProperty = DependencyProperty.Register( + nameof(ColumnLabels), typeof(IReadOnlyList), 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), 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; + + /// One row per year (label + 12 monthly values). + public IReadOnlyList? Rows { get => (IReadOnlyList?)GetValue(RowsProperty); set => SetValue(RowsProperty, value); } + + /// Column headers (culture-aware month initials); also fixes the column count. + public IReadOnlyList? ColumnLabels { get => (IReadOnlyList?)GetValue(ColumnLabelsProperty); set => SetValue(ColumnLabelsProperty, value); } + + public string BrushKey { get => (string)GetValue(BrushKeyProperty); set => SetValue(BrushKeyProperty, value); } + + /// Value drawn at full opacity; NaN = the largest value. + public double Maximum { get => (double)GetValue(MaximumProperty); set => SetValue(MaximumProperty, value); } + + /// Opacity of a zero cell. + 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); } + + /// Min–max colour scale under the grid. + public bool ShowScale { get => (bool)GetValue(ShowScaleProperty); set => SetValue(ShowScaleProperty, value); } + + /// Culture-aware value formatting (scale ends and readouts). + public Func? ValueFormatter { get => (Func?)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 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; + } + + /// "min ▭ max" right-aligned under the grid, with a gradient from the zero opacity to full colour. + 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); + } +} diff --git a/src/Titano.Ui/Visuals/SeriesChart.cs b/src/Titano.Ui/Visuals/SeriesChart.cs new file mode 100644 index 00000000..a2e1dbd8 --- /dev/null +++ b/src/Titano.Ui/Visuals/SeriesChart.cs @@ -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; + +/// +/// 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 , plus a right-aligned +/// ), 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 +/// ; 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 +/// / are set. +/// +public sealed class SeriesChart : DrawingElement +{ + public static readonly DependencyProperty SeriesProperty = DependencyProperty.Register( + nameof(Series), typeof(IReadOnlyList), typeof(SeriesChart), new PropertyMetadata(null, OnDataPropertyChanged)); + + public static readonly DependencyProperty MarkersProperty = DependencyProperty.Register( + nameof(Markers), typeof(IReadOnlyList), typeof(SeriesChart), new PropertyMetadata(null, OnDataPropertyChanged)); + + public static readonly DependencyProperty LegendProperty = DependencyProperty.Register( + nameof(Legend), typeof(IReadOnlyList), 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), typeof(SeriesChart), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender)); + + public static readonly DependencyProperty XLabelFormatterProperty = DependencyProperty.Register( + nameof(XLabelFormatter), typeof(Func), 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) + { + } + + /// Lines to draw; replace the list (or use an observable collection) to update. + public IReadOnlyList? Series { get => (IReadOnlyList?)GetValue(SeriesProperty); set => SetValue(SeriesProperty, value); } + + /// Frame markers drawn as dashed vertical lines in the marker colour. + public IReadOnlyList? Markers { get => (IReadOnlyList?)GetValue(MarkersProperty); set => SetValue(MarkersProperty, value); } + + /// Explicit legend entries; null lists the titled series. + public IReadOnlyList? Legend { get => (IReadOnlyList?)GetValue(LegendProperty); set => SetValue(LegendProperty, value); } + + /// Right-aligned text of the legend row (e.g. "flicker −67 % · max step 0.21 EV"). + 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); } + + /// Playhead frame (two-way); −1 hides it. + public int CurrentIndex { get => (int)GetValue(CurrentIndexProperty); set => SetValue(CurrentIndexProperty, value); } + + /// Whether clicking or dragging sets . + public bool IsSeekEnabled { get => (bool)GetValue(IsSeekEnabledProperty); set => SetValue(IsSeekEnabledProperty, value); } + + /// Fixed bottom of the Y axis; NaN = automatic. + public double YMinimum { get => (double)GetValue(YMinimumProperty); set => SetValue(YMinimumProperty, value); } + + /// Fixed top of the Y axis; NaN = automatic. + public double YMaximum { get => (double)GetValue(YMaximumProperty); set => SetValue(YMaximumProperty, value); } + + /// Fraction of the data span added above and below an automatic range. + public double YPadding { get => (double)GetValue(YPaddingProperty); set => SetValue(YPaddingProperty, value); } + + /// Culture-aware formatting of values (axis labels and readout). + public Func? YLabelFormatter { get => (Func?)GetValue(YLabelFormatterProperty); set => SetValue(YLabelFormatterProperty, value); } + + /// Formatting of frame indices (readout header and, when set, X axis labels). + public Func? XLabelFormatter { get => (Func?)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); + } + + /// Draws the legend row and returns the plot top. + 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 AutoLegend() + { + var items = new List(); + 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 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(); + } +} diff --git a/src/Titano.Ui/Visuals/StackedBar.cs b/src/Titano.Ui/Visuals/StackedBar.cs new file mode 100644 index 00000000..42a497dc --- /dev/null +++ b/src/Titano.Ui/Visuals/StackedBar.cs @@ -0,0 +1,203 @@ +using System.Windows; +using System.Windows.Input; +using System.Windows.Media; +using Titano.Core.Localization; + +namespace Titano.Ui.Visuals; + +/// +/// 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 . +/// +public sealed class StackedBar : DrawingElement +{ + public static readonly DependencyProperty ItemsProperty = DependencyProperty.Register( + nameof(Items), typeof(IReadOnlyList), 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), 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 _segments = []; + private readonly List _entries = []; + private int _hover = -1; + + /// Parts in display order (largest first reads best). + public IReadOnlyList? Items { get => (IReadOnlyList?)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); } + + /// Formats a share 0…1 for the legend (default: culture percent without decimals). + public Func? ShareFormatter { get => (Func?)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 items) + { + var total = 0.0; + for (var i = 0; i < items.Count; i++) total += Math.Max(0, items[i].Value); + return total; + } + + /// Rank fade 1 → 0.35 for items in the shared colour; items with their own brush stay opaque. + private static double OpacityOf(int index, IReadOnlyList 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); + + /// Flows legend entries into lines of the given width; draws them when is set. Returns the line count. + private int LayoutLegend(IReadOnlyList 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); + } +} diff --git a/src/Titano.Ui/Visuals/TimelineBands.cs b/src/Titano.Ui/Visuals/TimelineBands.cs new file mode 100644 index 00000000..a2e743b9 --- /dev/null +++ b/src/Titano.Ui/Visuals/TimelineBands.cs @@ -0,0 +1,202 @@ +using System.Windows; +using System.Windows.Input; +using System.Windows.Media; +using Titano.Core.Localization; + +namespace Titano.Ui.Visuals; + +/// +/// 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 +/// (, ) is outlined in Accent; clicking a slot makes it current +/// and raises . Desired height = bands × , so the control +/// scrolls inside a ScrollViewer. +/// +public sealed class TimelineBands : DrawingElement +{ + public static readonly DependencyProperty BandsProperty = DependencyProperty.Register( + nameof(Bands), typeof(IReadOnlyList), typeof(TimelineBands), new PropertyMetadata(null, OnDataPropertyChanged)); + + public static readonly DependencyProperty SlotLabelsProperty = DependencyProperty.Register( + nameof(SlotLabels), typeof(IReadOnlyList), 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), 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); + + /// One band per year: label + one value per slot. + public IReadOnlyList? Bands { get => (IReadOnlyList?)GetValue(BandsProperty); set => SetValue(BandsProperty, value); } + + /// Slot captions (culture-aware month initials); also fixes the slot count. + public IReadOnlyList? SlotLabels { get => (IReadOnlyList?)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); } + + /// Band of the current slot (two-way); −1 = none. + public int CurrentBand { get => (int)GetValue(CurrentBandProperty); set => SetValue(CurrentBandProperty, value); } + + /// Current slot inside (two-way); −1 = none. + public int CurrentSlot { get => (int)GetValue(CurrentSlotProperty); set => SetValue(CurrentSlotProperty, value); } + + /// Culture-aware value formatting for readouts. + public Func? ValueFormatter { get => (Func?)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); + } +} From 44ac5d84c034e4ec59230b5b55c69fb3bc506e00 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 10:27:09 +0000 Subject: [PATCH 07/13] feat(ui-visuals): add PreviewViewport with wipe compare, zoom, pan and overlays Images and overlays are retained visuals under one shared transform, so panning only updates a matrix. Fit, 1:1 (raw device pixels) and wheel zoom around the cursor; motion vectors, region boundary and crop mask overlays. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- src/Titano.Ui/Visuals/PreviewSurface.cs | 195 ++++++++++++ src/Titano.Ui/Visuals/PreviewViewport.cs | 385 +++++++++++++++++++++++ 2 files changed, 580 insertions(+) create mode 100644 src/Titano.Ui/Visuals/PreviewSurface.cs create mode 100644 src/Titano.Ui/Visuals/PreviewViewport.cs diff --git a/src/Titano.Ui/Visuals/PreviewSurface.cs b/src/Titano.Ui/Visuals/PreviewSurface.cs new file mode 100644 index 00000000..245a2b99 --- /dev/null +++ b/src/Titano.Ui/Visuals/PreviewSurface.cs @@ -0,0 +1,195 @@ +using System.Windows; +using System.Windows.Media; + +namespace Titano.Ui.Visuals; + +/// +/// Drawing surface of (its PART_Surface). The corrected image, the original +/// (clipped left of the wipe) and the overlays are retained visuals in image coordinates sharing one +/// , so panning and zooming only update a matrix; overlays are rebuilt when the zoom +/// changes (to keep strokes and arrowheads a constant on-screen size) or their data changes. The wipe divider +/// and its label live in a screen-space layer on top. +/// +public sealed class PreviewSurface : DrawingElement +{ + public static readonly DependencyProperty CornerRadiusProperty = DependencyProperty.Register( + nameof(CornerRadius), typeof(double), typeof(PreviewSurface), new PropertyMetadata(8.0, (d, _) => ((PreviewSurface)d).UpdateClip())); + + private const double LabelSize = 11; + + private readonly VisualCollection _layers; + private readonly DrawingVisual _corrected = new(); + private readonly DrawingVisual _original = new(); + private readonly ContainerVisual _originalHost = new(); + private readonly DrawingVisual _overlay = new(); + private readonly DrawingVisual _chrome = new(); + private readonly MatrixTransform _view = new(); + private readonly RectangleGeometry _wipeClip = new(); + private Size _imageSize = Size.Empty; + private double _overlayScale; + private double _zoom; + + public PreviewSurface() + { + _corrected.Transform = _view; + _original.Transform = _view; + _overlay.Transform = _view; + _originalHost.Clip = _wipeClip; + _originalHost.Children.Add(_original); + _layers = new VisualCollection(this) { _corrected, _originalHost, _overlay, _chrome }; + } + + /// Radius of the rounded clip of the whole surface. + public double CornerRadius { get => (double)GetValue(CornerRadiusProperty); set => SetValue(CornerRadiusProperty, value); } + + /// Viewport whose properties drive the layers. + internal PreviewViewport? Owner { get; set; } + + protected override int VisualChildrenCount => _layers.Count; + + protected override Visual GetVisualChild(int index) => _layers[index]; + + /// Redraws both images over the image rectangle [0, size]. + internal void SetImages(ImageSource? corrected, ImageSource? original, Size imageSize) + { + _imageSize = imageSize; + var rect = imageSize.IsEmpty ? Rect.Empty : new Rect(imageSize); + using (var dc = _corrected.RenderOpen()) + if (corrected is not null && !rect.IsEmpty) dc.DrawImage(corrected, rect); + using (var dc = _original.RenderOpen()) + if (original is not null && !rect.IsEmpty) dc.DrawImage(original, rect); + RefreshOverlay(); + RefreshChrome(); + } + + /// Applies the image-to-view transform; is device pixels per image pixel. + internal void SetView(ViewTransform view, double zoom) + { + _view.Matrix = new Matrix(view.Scale, 0, 0, view.Scale, view.OffsetX, view.OffsetY); + if (zoom != _zoom) + { + _zoom = zoom; + // Raw pixels from 1:1 up; filtered when shrinking. + var mode = zoom >= 1 ? BitmapScalingMode.NearestNeighbor : BitmapScalingMode.HighQuality; + RenderOptions.SetBitmapScalingMode(_corrected, mode); + RenderOptions.SetBitmapScalingMode(_original, mode); + } + if (view.Scale != _overlayScale) RefreshOverlay(); + UpdateWipeClip(); + } + + /// Rebuilds the overlays (crop mask, region boundary, motion vectors) in image coordinates. + internal void RefreshOverlay() + { + _overlayScale = _view.Matrix.M11; + using var dc = _overlay.RenderOpen(); + if (Owner is not { } owner || _imageSize.IsEmpty || !(_overlayScale > 0)) return; + var unit = 1 / _overlayScale; + if (owner.ShowCropMask) DrawCropMask(dc, owner, unit); + if (owner.ShowRegions && owner.RegionBoundary is { Count: > 1 } boundary) DrawRegion(dc, boundary, unit); + if (owner.ShowVectors && owner.MotionVectors is { Count: > 0 } vectors) DrawVectors(dc, vectors, owner.VectorScale, unit); + } + + /// Redraws the wipe divider and label. + internal void RefreshChrome() + { + UpdateWipeClip(); + using var dc = _chrome.RenderOpen(); + if (Owner is not { } owner || !IsWipeVisible(owner)) return; + var scale = PixelScale; + var x = PixelGrid.Snap(owner.WipePosition * ActualWidth, scale); + dc.DrawRectangle(GetBrush("Brush.Text"), null, new Rect(x - 1, 0, 2, ActualHeight)); + if (string.IsNullOrEmpty(owner.WipeLabel)) return; + var label = CreateText(owner.WipeLabel, LabelSize, GetBrush("Brush.Text")); + var pill = new Rect(x - label.Width / 2 - 8, 12, label.Width + 16, label.Height + 6); + pill.X = Math.Clamp(pill.X, 4, Math.Max(4, ActualWidth - pill.Width - 4)); + dc.PushOpacity(0.85); + dc.DrawRoundedRectangle(GetBrush("Brush.Chrome"), null, pill, 4, 4); + dc.Pop(); + dc.DrawText(label, new Point(pill.X + 8, pill.Y + 3)); + } + + protected override void OnRender(DrawingContext dc) => DrawHitArea(dc); + + protected override void OnRenderSizeChanged(SizeChangedInfo sizeInfo) + { + base.OnRenderSizeChanged(sizeInfo); + UpdateClip(); + RefreshChrome(); + } + + protected override void OnThemeChanged() + { + base.OnThemeChanged(); + RefreshOverlay(); + RefreshChrome(); + } + + private static bool IsWipeVisible(PreviewViewport owner) => owner.IsCompareEnabled && owner.OriginalSource is not null; + + private void UpdateClip() => Clip = new RectangleGeometry(new Rect(RenderSize), CornerRadius, CornerRadius); + + private void UpdateWipeClip() + { + var visible = Owner is { } owner && IsWipeVisible(owner); + _wipeClip.Rect = visible ? new Rect(0, 0, Math.Max(0, Owner!.WipePosition * ActualWidth), Math.Max(0, ActualHeight)) : Rect.Empty; + } + + /// Everything outside the crop: dimmed with the scrim ("what I lose") or hidden ("how it will look"). + private void DrawCropMask(DrawingContext dc, PreviewViewport owner, double unit) + { + var image = new Rect(_imageSize); + var n = owner.CropRect; + var crop = Rect.Intersect(image, new Rect(n.X * image.Width, n.Y * image.Height, n.Width * image.Width, n.Height * image.Height)); + if (crop.IsEmpty) crop = new Rect(image.TopLeft, new Size(0, 0)); + var outside = new CombinedGeometry(GeometryCombineMode.Exclude, new RectangleGeometry(image), new RectangleGeometry(crop)); + outside.Freeze(); + var loss = owner.CropMaskMode == CropMaskMode.ShowLoss; + dc.DrawGeometry(loss ? GetBrush("Brush.Scrim") : owner.Background ?? GetBrush("Brush.Preview"), null, outside); + if (loss && !crop.IsEmpty) dc.DrawRectangle(null, CreatePen("Brush.TextMuted", unit), crop); + } + + private void DrawRegion(DrawingContext dc, IReadOnlyList boundary, double unit) + { + var geometry = new StreamGeometry(); + using (var ctx = geometry.Open()) + { + ctx.BeginFigure(boundary[0], false, false); + for (var i = 1; i < boundary.Count; i++) ctx.LineTo(boundary[i], true, true); + } + geometry.Freeze(); + dc.DrawGeometry(null, CreatePen("Brush.Region", 1.5 * unit), geometry); + } + + /// Arrows from each sample along its (scaled) displacement; heads stay 5 px on screen. + private void DrawVectors(DrawingContext dc, IReadOnlyList vectors, double gain, double unit) + { + var head = 5 * unit; + var geometry = new StreamGeometry(); + using (var ctx = geometry.Open()) + { + for (var i = 0; i < vectors.Count; i++) + { + var v = vectors[i]; + var dx = v.Dx * gain; + var dy = v.Dy * gain; + var length = Math.Sqrt(dx * dx + dy * dy); + if (!(length >= unit)) continue; + var start = new Point(v.X, v.Y); + var end = new Point(v.X + dx, v.Y + dy); + ctx.BeginFigure(start, false, false); + ctx.LineTo(end, true, false); + // Arrowhead: two strokes at ±25° from the reversed direction. + var ux = dx / length; + var uy = dy / length; + const double cos = 0.906, sin = 0.423; + var h = Math.Min(head, length * 0.6); + ctx.BeginFigure(new Point(end.X - h * (ux * cos - uy * sin), end.Y - h * (uy * cos + ux * sin)), false, false); + ctx.LineTo(end, true, true); + ctx.LineTo(new Point(end.X - h * (ux * cos + uy * sin), end.Y - h * (uy * cos - ux * sin)), true, true); + } + } + geometry.Freeze(); + dc.DrawGeometry(null, CreatePen("Brush.Accent", 1.25 * unit), geometry); + } +} diff --git a/src/Titano.Ui/Visuals/PreviewViewport.cs b/src/Titano.Ui/Visuals/PreviewViewport.cs new file mode 100644 index 00000000..bcfc5bb3 --- /dev/null +++ b/src/Titano.Ui/Visuals/PreviewViewport.cs @@ -0,0 +1,385 @@ +using System.Windows; +using System.Windows.Controls; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Media.Imaging; + +namespace Titano.Ui.Visuals; + +/// How the preview scales the image. +public enum PreviewZoomMode +{ + /// The whole image fits the view, centred; follows resizes. + Fit, + + /// One image pixel per device pixel (raw pixels, no interpolation). + Actual, + + /// Set by the wheel or by . + Custom, +} + +/// What the crop mask shows outside the crop rectangle. +public enum CropMaskMode +{ + /// "What I lose": the outside is dimmed with the scrim. + ShowLoss, + + /// "How it will look": the outside is hidden. + ShowResult, +} + +/// A motion-field sample in image pixels: origin (X, Y) and displacement (Dx, Dy). +public readonly record struct MotionVector(float X, float Y, float Dx, float Dy); + +/// +/// Editor preview (BRIEF §12.3): the corrected image with an optional original shown left of a draggable wipe +/// divider (label from ), zoom to fit / 1:1 (raw pixels) / wheel zoom around the cursor, +/// pan by dragging, and overlays in image coordinates: motion vectors (Accent arrows), region boundary (Region +/// polyline) and a crop mask (normalised ; dims or hides what the output loses). Tools go +/// bottom-left (), the shot data pill bottom-right (). Images and +/// overlays are retained visuals under one shared transform, so panning re-renders nothing. Double-click toggles +/// Fit and 1:1; Ctrl+0 fits, Ctrl+1 shows 1:1. +/// +[TemplatePart(Name = PartSurface, Type = typeof(FrameworkElement))] +public class PreviewViewport : Control +{ + public const string PartSurface = "PART_Surface"; + + public static readonly RoutedCommand FitCommand = new(nameof(FitCommand), typeof(PreviewViewport), [new KeyGesture(Key.D0, ModifierKeys.Control)]); + public static readonly RoutedCommand ActualSizeCommand = new(nameof(ActualSizeCommand), typeof(PreviewViewport), [new KeyGesture(Key.D1, ModifierKeys.Control)]); + + public static readonly DependencyProperty SourceProperty = DependencyProperty.Register( + nameof(Source), typeof(ImageSource), typeof(PreviewViewport), new PropertyMetadata(null, OnImagesChanged)); + + public static readonly DependencyProperty OriginalSourceProperty = DependencyProperty.Register( + nameof(OriginalSource), typeof(ImageSource), typeof(PreviewViewport), new PropertyMetadata(null, OnImagesChanged)); + + public static readonly DependencyProperty IsCompareEnabledProperty = DependencyProperty.Register( + nameof(IsCompareEnabled), typeof(bool), typeof(PreviewViewport), new PropertyMetadata(false, OnChromeChanged)); + + public static readonly DependencyProperty WipePositionProperty = DependencyProperty.Register( + nameof(WipePosition), typeof(double), typeof(PreviewViewport), + new FrameworkPropertyMetadata(0.5, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnChromeChanged, CoerceUnit)); + + public static readonly DependencyProperty WipeLabelProperty = DependencyProperty.Register( + nameof(WipeLabel), typeof(string), typeof(PreviewViewport), new PropertyMetadata(null, OnChromeChanged)); + + public static readonly DependencyProperty ZoomModeProperty = DependencyProperty.Register( + nameof(ZoomMode), typeof(PreviewZoomMode), typeof(PreviewViewport), + new FrameworkPropertyMetadata(PreviewZoomMode.Fit, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnZoomModeChanged)); + + public static readonly DependencyProperty ZoomProperty = DependencyProperty.Register( + nameof(Zoom), typeof(double), typeof(PreviewViewport), + new FrameworkPropertyMetadata(1.0, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnZoomChanged, CoerceZoom)); + + public static readonly DependencyProperty ShowVectorsProperty = DependencyProperty.Register( + nameof(ShowVectors), typeof(bool), typeof(PreviewViewport), new PropertyMetadata(false, OnOverlayChanged)); + + public static readonly DependencyProperty MotionVectorsProperty = DependencyProperty.Register( + nameof(MotionVectors), typeof(IReadOnlyList), typeof(PreviewViewport), new PropertyMetadata(null, OnOverlayChanged)); + + public static readonly DependencyProperty VectorScaleProperty = DependencyProperty.Register( + nameof(VectorScale), typeof(double), typeof(PreviewViewport), new PropertyMetadata(1.0, OnOverlayChanged)); + + public static readonly DependencyProperty ShowRegionsProperty = DependencyProperty.Register( + nameof(ShowRegions), typeof(bool), typeof(PreviewViewport), new PropertyMetadata(false, OnOverlayChanged)); + + public static readonly DependencyProperty RegionBoundaryProperty = DependencyProperty.Register( + nameof(RegionBoundary), typeof(IReadOnlyList), typeof(PreviewViewport), new PropertyMetadata(null, OnOverlayChanged)); + + public static readonly DependencyProperty ShowCropMaskProperty = DependencyProperty.Register( + nameof(ShowCropMask), typeof(bool), typeof(PreviewViewport), new PropertyMetadata(false, OnOverlayChanged)); + + public static readonly DependencyProperty CropRectProperty = DependencyProperty.Register( + nameof(CropRect), typeof(Rect), typeof(PreviewViewport), new PropertyMetadata(new Rect(0, 0, 1, 1), OnOverlayChanged)); + + public static readonly DependencyProperty CropMaskModeProperty = DependencyProperty.Register( + nameof(CropMaskMode), typeof(CropMaskMode), typeof(PreviewViewport), new PropertyMetadata(CropMaskMode.ShowLoss, OnOverlayChanged)); + + public static readonly DependencyProperty InfoTextProperty = DependencyProperty.Register(nameof(InfoText), typeof(string), typeof(PreviewViewport)); + + public static readonly DependencyProperty ToolsContentProperty = DependencyProperty.Register(nameof(ToolsContent), typeof(object), typeof(PreviewViewport)); + + private const double MinZoom = 0.01; + private const double MaxZoom = 32; + private const double DividerGrip = 6; + + private PreviewSurface? _surface; + private ViewTransform _view = new(1, 0, 0); + private Size _imageSize = Size.Empty; + private bool _syncingZoom; + private DragMode _drag; + private Point _dragStart; + private ViewTransform _dragOrigin; + + static PreviewViewport() + { + DefaultStyleKeyProperty.OverrideMetadata(typeof(PreviewViewport), new FrameworkPropertyMetadata(typeof(PreviewViewport))); + FocusableProperty.OverrideMetadata(typeof(PreviewViewport), new FrameworkPropertyMetadata(true)); + } + + public PreviewViewport() + { + CommandBindings.Add(new CommandBinding(FitCommand, (_, _) => SetCurrentValue(ZoomModeProperty, PreviewZoomMode.Fit))); + CommandBindings.Add(new CommandBinding(ActualSizeCommand, (_, _) => SetCurrentValue(ZoomModeProperty, PreviewZoomMode.Actual))); + } + + private enum DragMode + { + None, + Pan, + Wipe, + } + + /// Corrected image (the output look). + public ImageSource? Source { get => (ImageSource?)GetValue(SourceProperty); set => SetValue(SourceProperty, value); } + + /// Original image for the wipe compare; drawn over the same area as . + public ImageSource? OriginalSource { get => (ImageSource?)GetValue(OriginalSourceProperty); set => SetValue(OriginalSourceProperty, value); } + + /// Shows the original left of the wipe divider. + public bool IsCompareEnabled { get => (bool)GetValue(IsCompareEnabledProperty); set => SetValue(IsCompareEnabledProperty, value); } + + /// Divider position as a fraction of the view width (two-way). + public double WipePosition { get => (double)GetValue(WipePositionProperty); set => SetValue(WipePositionProperty, value); } + + /// Label centred on the divider ("original | corrected"). + public string? WipeLabel { get => (string?)GetValue(WipeLabelProperty); set => SetValue(WipeLabelProperty, value); } + + public PreviewZoomMode ZoomMode { get => (PreviewZoomMode)GetValue(ZoomModeProperty); set => SetValue(ZoomModeProperty, value); } + + /// Device pixels per image pixel (1 = 1:1). Setting it switches to . + public double Zoom { get => (double)GetValue(ZoomProperty); set => SetValue(ZoomProperty, value); } + + public bool ShowVectors { get => (bool)GetValue(ShowVectorsProperty); set => SetValue(ShowVectorsProperty, value); } + + /// Motion field in image pixels. + public IReadOnlyList? MotionVectors { get => (IReadOnlyList?)GetValue(MotionVectorsProperty); set => SetValue(MotionVectorsProperty, value); } + + /// Gain applied to vector lengths so sub-pixel motion stays visible. + public double VectorScale { get => (double)GetValue(VectorScaleProperty); set => SetValue(VectorScaleProperty, value); } + + public bool ShowRegions { get => (bool)GetValue(ShowRegionsProperty); set => SetValue(ShowRegionsProperty, value); } + + /// Sky/landscape boundary as a polyline in image pixels. + public IReadOnlyList? RegionBoundary { get => (IReadOnlyList?)GetValue(RegionBoundaryProperty); set => SetValue(RegionBoundaryProperty, value); } + + public bool ShowCropMask { get => (bool)GetValue(ShowCropMaskProperty); set => SetValue(ShowCropMaskProperty, value); } + + /// Output crop in normalised image coordinates (0…1). + public Rect CropRect { get => (Rect)GetValue(CropRectProperty); set => SetValue(CropRectProperty, value); } + + public CropMaskMode CropMaskMode { get => (CropMaskMode)GetValue(CropMaskModeProperty); set => SetValue(CropMaskModeProperty, value); } + + /// Shot data shown in the bottom-right pill. + public string? InfoText { get => (string?)GetValue(InfoTextProperty); set => SetValue(InfoTextProperty, value); } + + /// Tool buttons shown bottom-left over the image. + public object? ToolsContent { get => GetValue(ToolsContentProperty); set => SetValue(ToolsContentProperty, value); } + + /// Current image-to-view transform in DIPs (for hit testing overlays from outside). + public ViewTransform View => _view; + + /// Size of in image pixels. + public Size ImageSize => _imageSize; + + private Size ViewSize => _surface?.RenderSize ?? Size.Empty; + + private double PixelScale => VisualTreeHelper.GetDpi(this).DpiScaleX; + + public override void OnApplyTemplate() + { + if (_surface is not null) _surface.SizeChanged -= OnSurfaceSizeChanged; + base.OnApplyTemplate(); + _surface = GetTemplateChild(PartSurface) as PreviewSurface; + if (_surface is null) return; + _surface.Owner = this; + _surface.SizeChanged += OnSurfaceSizeChanged; + _surface.SetImages(Source, OriginalSource, _imageSize); + ApplyZoomMode(); + } + + protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e) + { + base.OnMouseLeftButtonDown(e); + if (e.Handled || _surface is null) return; + Focus(); + var p = e.GetPosition(_surface); + if (e.ClickCount == 2) + { + ToggleZoom(p); + e.Handled = true; + return; + } + _drag = IsNearDivider(p) ? DragMode.Wipe : DragMode.Pan; + _dragStart = p; + _dragOrigin = _view; + if (!CaptureMouse()) _drag = DragMode.None; + e.Handled = true; + } + + protected override void OnMouseMove(MouseEventArgs e) + { + base.OnMouseMove(e); + if (_drag == DragMode.None || _surface is null) return; + var p = e.GetPosition(_surface); + if (_drag == DragMode.Wipe) + { + var width = ViewSize.Width; + if (width > 0) SetCurrentValue(WipePositionProperty, p.X / width); + return; + } + UpdateView(ViewportMath.Clamp(ViewportMath.Pan(_dragOrigin, p.X - _dragStart.X, p.Y - _dragStart.Y), + _imageSize.Width, _imageSize.Height, ViewSize.Width, ViewSize.Height)); + } + + protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e) + { + base.OnMouseLeftButtonUp(e); + if (_drag != DragMode.None) ReleaseMouseCapture(); + } + + protected override void OnLostMouseCapture(MouseEventArgs e) + { + base.OnLostMouseCapture(e); + _drag = DragMode.None; + } + + protected override void OnMouseWheel(MouseWheelEventArgs e) + { + base.OnMouseWheel(e); + if (e.Handled || _surface is null || _imageSize.IsEmpty) return; + var p = e.GetPosition(_surface); + var dpi = PixelScale; + var scale = ViewportMath.WheelZoom(_view.Scale, e.Delta / (double)Mouse.MouseWheelDeltaForOneLine, MinZoom / dpi, MaxZoom / dpi); + SetCurrentValue(ZoomModeProperty, PreviewZoomMode.Custom); + UpdateView(ViewportMath.Clamp(ViewportMath.ZoomAt(_view, scale, p.X, p.Y), _imageSize.Width, _imageSize.Height, ViewSize.Width, ViewSize.Height)); + e.Handled = true; + } + + protected override void OnQueryCursor(QueryCursorEventArgs e) + { + base.OnQueryCursor(e); + if (e.Handled || _surface is null || !ReferenceEquals(e.OriginalSource, _surface)) return; + var p = e.GetPosition(_surface); + if (_drag == DragMode.Wipe || IsNearDivider(p)) e.Cursor = Cursors.SizeWE; + else if (IsPannable()) e.Cursor = Cursors.SizeAll; + else return; + e.Handled = true; + } + + protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi) + { + base.OnDpiChanged(oldDpi, newDpi); + ApplyZoomMode(); + } + + private static object CoerceUnit(DependencyObject d, object value) => double.IsNaN((double)value) ? 0.5 : Math.Clamp((double)value, 0, 1); + + private static object CoerceZoom(DependencyObject d, object value) => + double.IsFinite((double)value) ? Math.Clamp((double)value, MinZoom, MaxZoom) : 1.0; + + private static void OnImagesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) + { + var viewport = (PreviewViewport)d; + var size = PixelSize(viewport.Source); + var resized = size != viewport._imageSize; + viewport._imageSize = size; + viewport._surface?.SetImages(viewport.Source, viewport.OriginalSource, size); + // Same-size frames (scrubbing) keep zoom and pan; a new size refits or re-clamps. + if (resized) viewport.ApplyZoomMode(); + } + + private static void OnChromeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) => ((PreviewViewport)d)._surface?.RefreshChrome(); + + private static void OnOverlayChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) => ((PreviewViewport)d)._surface?.RefreshOverlay(); + + private static void OnZoomModeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) => ((PreviewViewport)d).ApplyZoomMode(); + + private static void OnZoomChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) + { + var viewport = (PreviewViewport)d; + if (viewport._syncingZoom || viewport._imageSize.IsEmpty) return; + viewport.SetCurrentValue(ZoomModeProperty, PreviewZoomMode.Custom); + var size = viewport.ViewSize; + var scale = (double)e.NewValue / viewport.PixelScale; + viewport.UpdateView(ViewportMath.Clamp(ViewportMath.ZoomAt(viewport._view, scale, size.Width / 2, size.Height / 2), + viewport._imageSize.Width, viewport._imageSize.Height, size.Width, size.Height)); + } + + private static Size PixelSize(ImageSource? source) => source switch + { + null => Size.Empty, + BitmapSource bitmap => new Size(bitmap.PixelWidth, bitmap.PixelHeight), + _ => new Size(source.Width, source.Height), + }; + + private void OnSurfaceSizeChanged(object sender, SizeChangedEventArgs e) + { + ApplyZoomMode(); + _surface?.RefreshChrome(); + } + + private void ApplyZoomMode() + { + var view = ViewSize; + if (_surface is null || _imageSize.IsEmpty || view.Width <= 0 || view.Height <= 0) return; + var (w, h) = (_imageSize.Width, _imageSize.Height); + switch (ZoomMode) + { + case PreviewZoomMode.Fit: + UpdateView(ViewportMath.Centered(ViewportMath.FitScale(w, h, view.Width, view.Height), w, h, view.Width, view.Height)); + break; + case PreviewZoomMode.Actual: + var actual = 1 / PixelScale; + var start = _view.Scale > 0 ? _view : ViewportMath.Centered(actual, w, h, view.Width, view.Height); + UpdateView(ViewportMath.Clamp(ViewportMath.ZoomAt(start, actual, view.Width / 2, view.Height / 2), w, h, view.Width, view.Height)); + break; + default: + UpdateView(ViewportMath.Clamp(_view, w, h, view.Width, view.Height)); + break; + } + } + + private void ToggleZoom(Point at) + { + if (_imageSize.IsEmpty) return; + if (ZoomMode == PreviewZoomMode.Actual) + { + SetCurrentValue(ZoomModeProperty, PreviewZoomMode.Fit); + return; + } + // 1:1 centred on the double-clicked point. + var view = ViewSize; + var zoomed = ViewportMath.ZoomAt(_view, 1 / PixelScale, at.X, at.Y); + _view = ViewportMath.Pan(zoomed, view.Width / 2 - at.X, view.Height / 2 - at.Y); + SetCurrentValue(ZoomModeProperty, PreviewZoomMode.Actual); + } + + private void UpdateView(ViewTransform view) + { + var dpi = PixelScale; + if (ZoomMode == PreviewZoomMode.Actual) view = ViewportMath.SnapOffset(view, dpi); + _view = view; + _surface?.SetView(view, view.Scale * dpi); + _syncingZoom = true; + try + { + SetCurrentValue(ZoomProperty, view.Scale * dpi); + } + finally + { + _syncingZoom = false; + } + } + + private bool IsNearDivider(Point p) => + IsCompareEnabled && OriginalSource is not null && Math.Abs(p.X - WipePosition * ViewSize.Width) <= DividerGrip; + + private bool IsPannable() + { + var view = ViewSize; + return !_imageSize.IsEmpty && (_imageSize.Width * _view.Scale > view.Width + 0.5 || _imageSize.Height * _view.Scale > view.Height + 0.5); + } +} From cf0c0a6c6a4d4293c668873be93cf365ee39404d Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 10:27:09 +0000 Subject: [PATCH 08/13] feat(ui-visuals): add CurveEditor for time remap and keyframes Edits control points in place (add, drag with monotone X, delete, nudge) and draws the curve from a supplied evaluator, with grid, diagonal and playhead. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- src/Titano.Ui/Visuals/CurveEditor.cs | 379 +++++++++++++++++++++++++++ 1 file changed, 379 insertions(+) create mode 100644 src/Titano.Ui/Visuals/CurveEditor.cs diff --git a/src/Titano.Ui/Visuals/CurveEditor.cs b/src/Titano.Ui/Visuals/CurveEditor.cs new file mode 100644 index 00000000..c90ebff3 --- /dev/null +++ b/src/Titano.Ui/Visuals/CurveEditor.cs @@ -0,0 +1,379 @@ +using System.Collections.Specialized; +using System.Windows; +using System.Windows.Input; +using System.Windows.Media; +using Titano.Core.Localization; + +namespace Titano.Ui.Visuals; + +/// Editing rules of a . +public enum CurveEditMode +{ + /// Keyframes ordered by time (virtual camera): X stays increasing, the ends may move. + Keyframes, + + /// Time remap: X stays increasing and the end points are pinned to X = 0 and X = 1. + TimeRemap, +} + +/// +/// Spline/keyframe editor in normalised [0, 1]² space (BRIEF §12.3: Time remap curve, Camera keyframes). +/// Control points come from and are edited in place (double-click adds, drag moves with the +/// X order constrained by , Delete removes, arrows nudge); the curve itself is drawn by +/// sampling once per device-pixel column, so the engine's Fritsch–Carlson spline is what +/// the user sees. Grid, optional identity diagonal and a playhead are drawn; hovering or dragging a point reads +/// out its coordinates. fires after each add, delete, nudge or finished drag. +/// +public sealed class CurveEditor : DrawingElement +{ + public static readonly DependencyProperty PointsProperty = DependencyProperty.Register( + nameof(Points), typeof(IList), typeof(CurveEditor), new PropertyMetadata(null, OnDataPropertyChanged)); + + public static readonly DependencyProperty EvaluatorProperty = DependencyProperty.Register( + nameof(Evaluator), typeof(Func), typeof(CurveEditor), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender)); + + public static readonly DependencyProperty ModeProperty = DependencyProperty.Register( + nameof(Mode), typeof(CurveEditMode), typeof(CurveEditor), new PropertyMetadata(CurveEditMode.Keyframes)); + + public static readonly DependencyProperty SelectedIndexProperty = DependencyProperty.Register( + nameof(SelectedIndex), typeof(int), typeof(CurveEditor), + new FrameworkPropertyMetadata(-1, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault | FrameworkPropertyMetadataOptions.AffectsRender, null, CoerceSelectedIndex)); + + public static readonly DependencyProperty PlayheadPositionProperty = DependencyProperty.Register( + nameof(PlayheadPosition), typeof(double), typeof(CurveEditor), new PropertyMetadata(double.NaN, (d, _) => ((CurveEditor)d).RenderOverlay())); + + public static readonly DependencyProperty ShowDiagonalProperty = DependencyProperty.Register( + nameof(ShowDiagonal), typeof(bool), typeof(CurveEditor), new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.AffectsRender)); + + public static readonly DependencyProperty MinimumGapProperty = DependencyProperty.Register( + nameof(MinimumGap), typeof(double), typeof(CurveEditor), new PropertyMetadata(CurveMath.DefaultMinGap)); + + public static readonly DependencyProperty XLabelFormatterProperty = DependencyProperty.Register( + nameof(XLabelFormatter), typeof(Func), typeof(CurveEditor), new PropertyMetadata(null)); + + public static readonly DependencyProperty YLabelFormatterProperty = DependencyProperty.Register( + nameof(YLabelFormatter), typeof(Func), typeof(CurveEditor), new PropertyMetadata(null)); + + public static readonly RoutedEvent EditCompletedEvent = EventManager.RegisterRoutedEvent( + nameof(EditCompleted), RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(CurveEditor)); + + private const double Inset = 7; + private const double PointRadius = 4.5; + private const double HitRadius = 8; + + private double[] _xs = []; + private double[] _ys = []; + private double[] _viewX = []; + private double[] _viewY = []; + private int _count; + private Rect _plot; + private int _hover = -1; + private bool _dragging; + private bool _moved; + + static CurveEditor() + { + FocusableProperty.OverrideMetadata(typeof(CurveEditor), new FrameworkPropertyMetadata(true)); + } + + public CurveEditor() + : base(hasOverlay: true) + { + } + + /// Control points in [0, 1]², ordered by X; edited in place unless the list is read-only. + public IList? Points { get => (IList?)GetValue(PointsProperty); set => SetValue(PointsProperty, value); } + + /// The curve through the points (x → y in [0, 1]); null draws straight segments. + public Func? Evaluator { get => (Func?)GetValue(EvaluatorProperty); set => SetValue(EvaluatorProperty, value); } + + public CurveEditMode Mode { get => (CurveEditMode)GetValue(ModeProperty); set => SetValue(ModeProperty, value); } + + /// Selected point (two-way); −1 = none. + public int SelectedIndex { get => (int)GetValue(SelectedIndexProperty); set => SetValue(SelectedIndexProperty, value); } + + /// Playhead X in [0, 1]; NaN hides it. + public double PlayheadPosition { get => (double)GetValue(PlayheadPositionProperty); set => SetValue(PlayheadPositionProperty, value); } + + /// Dashed identity line (y = x), the "no remap" reference. + public bool ShowDiagonal { get => (bool)GetValue(ShowDiagonalProperty); set => SetValue(ShowDiagonalProperty, value); } + + /// Minimum X distance between neighbouring points. + public double MinimumGap { get => (double)GetValue(MinimumGapProperty); set => SetValue(MinimumGapProperty, value); } + + /// Culture-aware formatting of X in readouts (e.g. output time). + public Func? XLabelFormatter { get => (Func?)GetValue(XLabelFormatterProperty); set => SetValue(XLabelFormatterProperty, value); } + + /// Culture-aware formatting of Y in readouts (e.g. source time). + public Func? YLabelFormatter { get => (Func?)GetValue(YLabelFormatterProperty); set => SetValue(YLabelFormatterProperty, value); } + + public event RoutedEventHandler EditCompleted + { + add => AddHandler(EditCompletedEvent, value); + remove => RemoveHandler(EditCompletedEvent, value); + } + + private bool PinEnds => Mode == CurveEditMode.TimeRemap; + + private bool IsEditable => Points is { IsReadOnly: false }; + + protected override Size MeasureOverride(Size availableSize) => new(0, 160); + + protected override void OnDataChanged() + { + var points = Points; + _count = points?.Count ?? 0; + if (_xs.Length < _count) + { + _xs = new double[_count]; + _ys = new double[_count]; + _viewX = new double[_count]; + _viewY = new double[_count]; + } + for (var i = 0; i < _count; i++) + { + _xs[i] = points![i].X; + _ys[i] = points[i].Y; + } + _hover = -1; + CoerceValue(SelectedIndexProperty); + base.OnDataChanged(); + } + + protected override void OnRender(DrawingContext dc) + { + DrawHitArea(dc); + _plot = new Rect(Inset, Inset, Math.Max(0, ActualWidth - 2 * Inset), Math.Max(0, ActualHeight - 2 * Inset)); + if (_plot.Width < 1 || _plot.Height < 1) return; + var scale = PixelScale; + var grid = GetHairline("Brush.Stroke"); + for (var i = 0; i <= 4; i++) + { + var x = PixelGrid.SnapLine(X(i / 4.0), grid.Thickness, scale); + var y = PixelGrid.SnapLine(Y(i / 4.0), grid.Thickness, scale); + dc.DrawLine(grid, new Point(x, _plot.Top), new Point(x, _plot.Bottom)); + dc.DrawLine(grid, new Point(_plot.Left, y), new Point(_plot.Right, y)); + } + if (ShowDiagonal) dc.DrawLine(GetPen("Brush.TextFaint", 1, LineDash.Dashed), new Point(X(0), Y(0)), new Point(X(1), Y(1))); + + dc.PushClip(new RectangleGeometry(new Rect(0, 0, ActualWidth, ActualHeight))); + DrawCurve(dc, scale); + dc.Pop(); + + var fill = GetBrush("Brush.Surface"); + var accent = GetBrush("Brush.Accent"); + var stroke = GetPen("Brush.Accent", 1.5); + for (var i = 0; i < _count; i++) + { + var selected = i == SelectedIndex; + var radius = i == _hover || selected ? PointRadius + 1 : PointRadius; + dc.DrawEllipse(selected ? accent : fill, stroke, new Point(X(_xs[i]), Y(_ys[i])), radius, radius); + } + RenderOverlay(); + } + + protected override void OnRenderOverlay(DrawingContext dc) + { + var position = PlayheadPosition; + if (!double.IsFinite(position) || _plot.Width < 1) return; + var pen = GetHairline("Brush.Accent"); + var x = PixelGrid.SnapLine(X(Math.Clamp(position, 0, 1)), pen.Thickness, PixelScale); + dc.DrawLine(pen, new Point(x, _plot.Top), new Point(x, _plot.Bottom)); + } + + protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e) + { + base.OnMouseLeftButtonDown(e); + Focus(); + var p = e.GetPosition(this); + var hit = HitTest(p); + if (hit >= 0) + { + SetCurrentValue(SelectedIndexProperty, hit); + _moved = false; + _dragging = IsEditable && CaptureMouse(); + } + else if (e.ClickCount == 2) + { + Add(p); + } + else + { + SetCurrentValue(SelectedIndexProperty, -1); + } + e.Handled = true; + } + + protected override void OnMouseMove(MouseEventArgs e) + { + base.OnMouseMove(e); + var p = e.GetPosition(this); + if (_dragging && SelectedIndex >= 0) + { + _moved |= Move(SelectedIndex, ToX(p.X), ToY(p.Y)); + Readout.Show(ReadoutText(SelectedIndex), p); + return; + } + var hover = HitTest(p); + if (hover != _hover) + { + _hover = hover; + InvalidateVisual(); + } + Readout.Show(hover >= 0 ? ReadoutText(hover) : null, p); + } + + protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e) + { + base.OnMouseLeftButtonUp(e); + if (_dragging) ReleaseMouseCapture(); + } + + protected override void OnLostMouseCapture(MouseEventArgs e) + { + base.OnLostMouseCapture(e); + if (!_dragging) return; + _dragging = false; + if (_moved) RaiseEvent(new RoutedEventArgs(EditCompletedEvent)); + _moved = false; + } + + protected override void OnMouseLeave(MouseEventArgs e) + { + base.OnMouseLeave(e); + if (_dragging) return; + Readout.Hide(); + if (_hover < 0) return; + _hover = -1; + InvalidateVisual(); + } + + protected override void OnQueryCursor(QueryCursorEventArgs e) + { + base.OnQueryCursor(e); + if (e.Handled || (!_dragging && _hover < 0)) return; + e.Cursor = _dragging ? Cursors.SizeAll : Cursors.Hand; + e.Handled = true; + } + + protected override void OnKeyDown(KeyEventArgs e) + { + base.OnKeyDown(e); + var index = SelectedIndex; + if (e.Handled || index < 0 || index >= _count || !IsEditable) return; + var step = (Keyboard.Modifiers & ModifierKeys.Shift) != 0 ? 0.1 : 0.01; + var changed = e.Key switch + { + Key.Delete or Key.Back => Remove(index), + Key.Left => Move(index, _xs[index] - step, _ys[index]), + Key.Right => Move(index, _xs[index] + step, _ys[index]), + Key.Up => Move(index, _xs[index], _ys[index] + step), + Key.Down => Move(index, _xs[index], _ys[index] - step), + _ => (bool?)null, + }; + if (changed is null) return; + e.Handled = true; + if (changed.Value) RaiseEvent(new RoutedEventArgs(EditCompletedEvent)); + } + + private static object CoerceSelectedIndex(DependencyObject d, object value) + { + var index = (int)value; + return index >= 0 && index < ((CurveEditor)d)._count ? index : -1; + } + + private double X(double x) => _plot.Left + x * _plot.Width; + + private double Y(double y) => _plot.Bottom - y * _plot.Height; + + private double ToX(double x) => _plot.Width > 0 ? (x - _plot.Left) / _plot.Width : 0; + + private double ToY(double y) => _plot.Height > 0 ? (_plot.Bottom - y) / _plot.Height : 0; + + private void DrawCurve(DrawingContext dc, double scale) + { + var evaluator = Evaluator; + if (evaluator is null && _count < 2) return; + var geometry = new StreamGeometry(); + using (var ctx = geometry.Open()) + { + if (evaluator is not null) + { + var columns = Math.Max(2, (int)Math.Ceiling(_plot.Width * scale) + 1); + for (var c = 0; c < columns; c++) + { + var x = c / (double)(columns - 1); + var p = new Point(X(x), Y(evaluator(x))); + if (c == 0) ctx.BeginFigure(p, false, false); + else ctx.LineTo(p, true, true); + } + } + else + { + ctx.BeginFigure(new Point(X(_xs[0]), Y(_ys[0])), false, false); + for (var i = 1; i < _count; i++) ctx.LineTo(new Point(X(_xs[i]), Y(_ys[i])), true, true); + } + } + geometry.Freeze(); + dc.DrawGeometry(null, GetPen("Brush.Accent", 2), geometry); + } + + private int HitTest(Point p) + { + if (_count == 0 || _plot.Width < 1) return -1; + for (var i = 0; i < _count; i++) + { + _viewX[i] = X(_xs[i]); + _viewY[i] = Y(_ys[i]); + } + return CurveMath.HitTest(_viewX.AsSpan(0, _count), _viewY.AsSpan(0, _count), p.X, p.Y, HitRadius); + } + + /// Moves point towards (x, y) within the constraints; true when it changed. + private bool Move(int index, double x, double y) + { + if (Points is not { IsReadOnly: false } points) return false; + var cx = CurveMath.ConstrainX(_xs.AsSpan(0, _count), index, x, MinimumGap, PinEnds); + var cy = CurveMath.ConstrainY(y); + if (cx == _xs[index] && cy == _ys[index]) return false; + points[index] = new Point(cx, cy); + AfterEdit(points); + return true; + } + + private void Add(Point at) + { + if (Points is not { IsReadOnly: false } points) return; + var x = ToX(at.X); + var index = CurveMath.InsertionIndex(_xs.AsSpan(0, _count), x, MinimumGap, PinEnds); + if (index < 0) return; + points.Insert(index, new Point(x, CurveMath.ConstrainY(ToY(at.Y)))); + AfterEdit(points); + SetCurrentValue(SelectedIndexProperty, index); + RaiseEvent(new RoutedEventArgs(EditCompletedEvent)); + } + + private bool Remove(int index) + { + if (Points is not { IsReadOnly: false } points || !CurveMath.CanRemove(_count, index, PinEnds)) return false; + points.RemoveAt(index); + AfterEdit(points); + SetCurrentValue(SelectedIndexProperty, Math.Min(index, _count - 1)); + return true; + } + + /// Observable lists notify through the collection watcher; plain lists are re-read here. + private void AfterEdit(IList points) + { + if (points is not INotifyCollectionChanged) OnDataChanged(); + } + + private string ReadoutText(int index) + { + var x = XLabelFormatter ?? DefaultFormat; + var y = YLabelFormatter ?? DefaultFormat; + return x(_xs[index]) + " → " + y(_ys[index]); + } + + private static string DefaultFormat(double value) => value.ToString("0.###", Loc.Culture); +} From f18c26ca090f0bd565e339bdf7fa2d4d2c0c76a5 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 10:27:10 +0000 Subject: [PATCH 09/13] feat(ui-visuals): add SegmentedControl and SplitButton Segmented single-selection list with a shared border for the view switcher, and a split button whose drop-down menu chooses the item its command uses. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- src/Titano.Ui/Visuals/SegmentedControl.cs | 73 +++++++++++++ src/Titano.Ui/Visuals/SplitButton.cs | 126 ++++++++++++++++++++++ 2 files changed, 199 insertions(+) create mode 100644 src/Titano.Ui/Visuals/SegmentedControl.cs create mode 100644 src/Titano.Ui/Visuals/SplitButton.cs diff --git a/src/Titano.Ui/Visuals/SegmentedControl.cs b/src/Titano.Ui/Visuals/SegmentedControl.cs new file mode 100644 index 00000000..663ebe9e --- /dev/null +++ b/src/Titano.Ui/Visuals/SegmentedControl.cs @@ -0,0 +1,73 @@ +using System.Collections.Specialized; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Input; +using Titano.Ui.Controls; + +namespace Titano.Ui.Visuals; + +/// Where a segment sits in its group; decides which corners are rounded. +public enum SegmentPosition +{ + Only, + First, + Middle, + Last, +} + +/// +/// Grouped buttons with one shared border and a single selected segment in Accent (Library toolbar view +/// switcher: grid / list / timeline). A single-selection list: bind or +/// (with = Tag). Left/Right move the +/// selection; the group is one tab stop. +/// +public class SegmentedControl : ListBox +{ + static SegmentedControl() + { + DefaultStyleKeyProperty.OverrideMetadata(typeof(SegmentedControl), new FrameworkPropertyMetadata(typeof(SegmentedControl))); + SelectionModeProperty.OverrideMetadata(typeof(SegmentedControl), new FrameworkPropertyMetadata(SelectionMode.Single)); + KeyboardNavigation.TabNavigationProperty.OverrideMetadata(typeof(SegmentedControl), new FrameworkPropertyMetadata(KeyboardNavigationMode.Once)); + } + + protected override DependencyObject GetContainerForItemOverride() => new SegmentedItem(); + + protected override bool IsItemItsOwnContainerOverride(object item) => item is SegmentedItem; + + protected override void PrepareContainerForItemOverride(DependencyObject element, object item) + { + base.PrepareContainerForItemOverride(element, item); + if (element is SegmentedItem segment) segment.Position = PositionOf(ItemContainerGenerator.IndexFromContainer(element), Items.Count); + } + + protected override void OnItemsChanged(NotifyCollectionChangedEventArgs e) + { + base.OnItemsChanged(e); + for (var i = 0; i < Items.Count; i++) + if (ItemContainerGenerator.ContainerFromIndex(i) is SegmentedItem segment) segment.Position = PositionOf(i, Items.Count); + } + + private static SegmentPosition PositionOf(int index, int count) => + count <= 1 ? SegmentPosition.Only : index <= 0 ? SegmentPosition.First : index >= count - 1 ? SegmentPosition.Last : SegmentPosition.Middle; +} + +/// One segment: an icon () and/or content; give it a ToolTip and an automation name. +public class SegmentedItem : ListBoxItem +{ + public static readonly DependencyProperty GlyphProperty = DependencyProperty.Register(nameof(Glyph), typeof(IconData), typeof(SegmentedItem)); + + private static readonly DependencyPropertyKey PositionKey = DependencyProperty.RegisterReadOnly( + nameof(Position), typeof(SegmentPosition), typeof(SegmentedItem), new PropertyMetadata(SegmentPosition.Only)); + + public static readonly DependencyProperty PositionProperty = PositionKey.DependencyProperty; + + static SegmentedItem() + { + DefaultStyleKeyProperty.OverrideMetadata(typeof(SegmentedItem), new FrameworkPropertyMetadata(typeof(SegmentedItem))); + } + + public IconData? Glyph { get => (IconData?)GetValue(GlyphProperty); set => SetValue(GlyphProperty, value); } + + /// Place in the group, maintained by . + public SegmentPosition Position { get => (SegmentPosition)GetValue(PositionProperty); internal set => SetValue(PositionKey, value); } +} diff --git a/src/Titano.Ui/Visuals/SplitButton.cs b/src/Titano.Ui/Visuals/SplitButton.cs new file mode 100644 index 00000000..cf86a03b --- /dev/null +++ b/src/Titano.Ui/Visuals/SplitButton.cs @@ -0,0 +1,126 @@ +using System.Collections; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Controls.Primitives; +using System.Windows.Data; +using System.Windows.Input; + +namespace Titano.Ui.Visuals; + +/// +/// Main action on the left, a ▾ part on the right that drops down a menu of choices (Editor: "Render · preset ▾"). +/// The main part executes ; choosing a menu entry sets (checked in +/// the menu) — bind to it to act on the chosen preset. The control's ToolTip +/// describes the main action, the ▾ part. F4 or Alt+Down opens the menu. +/// gives the accent look of the screen's primary button. +/// +public class SplitButton : Control +{ + public static readonly DependencyProperty ContentProperty = DependencyProperty.Register(nameof(Content), typeof(object), typeof(SplitButton)); + public static readonly DependencyProperty CommandProperty = DependencyProperty.Register(nameof(Command), typeof(ICommand), typeof(SplitButton)); + public static readonly DependencyProperty CommandParameterProperty = DependencyProperty.Register(nameof(CommandParameter), typeof(object), typeof(SplitButton)); + public static readonly DependencyProperty CommandTargetProperty = DependencyProperty.Register(nameof(CommandTarget), typeof(IInputElement), typeof(SplitButton)); + public static readonly DependencyProperty ItemsSourceProperty = DependencyProperty.Register(nameof(ItemsSource), typeof(IEnumerable), typeof(SplitButton)); + public static readonly DependencyProperty ItemTemplateProperty = DependencyProperty.Register(nameof(ItemTemplate), typeof(DataTemplate), typeof(SplitButton)); + public static readonly DependencyProperty ItemContainerStyleProperty = DependencyProperty.Register(nameof(ItemContainerStyle), typeof(Style), typeof(SplitButton)); + public static readonly DependencyProperty DisplayMemberPathProperty = DependencyProperty.Register(nameof(DisplayMemberPath), typeof(string), typeof(SplitButton)); + public static readonly DependencyProperty DropDownToolTipProperty = DependencyProperty.Register(nameof(DropDownToolTip), typeof(object), typeof(SplitButton)); + public static readonly DependencyProperty IsPrimaryProperty = DependencyProperty.Register(nameof(IsPrimary), typeof(bool), typeof(SplitButton)); + + public static readonly DependencyProperty SelectedItemProperty = DependencyProperty.Register( + nameof(SelectedItem), typeof(object), typeof(SplitButton), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault)); + + public static readonly DependencyProperty IsDropDownOpenProperty = DependencyProperty.Register( + nameof(IsDropDownOpen), typeof(bool), typeof(SplitButton), + new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnIsDropDownOpenChanged)); + + private ContextMenu? _menu; + + static SplitButton() + { + DefaultStyleKeyProperty.OverrideMetadata(typeof(SplitButton), new FrameworkPropertyMetadata(typeof(SplitButton))); + FocusableProperty.OverrideMetadata(typeof(SplitButton), new FrameworkPropertyMetadata(false)); + } + + /// Content of the main part (e.g. "Render · 4K 10-bit HEVC"). + public object? Content { get => GetValue(ContentProperty); set => SetValue(ContentProperty, value); } + + public ICommand? Command { get => (ICommand?)GetValue(CommandProperty); set => SetValue(CommandProperty, value); } + + public object? CommandParameter { get => GetValue(CommandParameterProperty); set => SetValue(CommandParameterProperty, value); } + + public IInputElement? CommandTarget { get => (IInputElement?)GetValue(CommandTargetProperty); set => SetValue(CommandTargetProperty, value); } + + /// Choices listed in the drop-down menu. + public IEnumerable? ItemsSource { get => (IEnumerable?)GetValue(ItemsSourceProperty); set => SetValue(ItemsSourceProperty, value); } + + public DataTemplate? ItemTemplate { get => (DataTemplate?)GetValue(ItemTemplateProperty); set => SetValue(ItemTemplateProperty, value); } + + /// Style of the menu items (e.g. to bind a ToolTip per choice). + public Style? ItemContainerStyle { get => (Style?)GetValue(ItemContainerStyleProperty); set => SetValue(ItemContainerStyleProperty, value); } + + public string? DisplayMemberPath { get => (string?)GetValue(DisplayMemberPathProperty); set => SetValue(DisplayMemberPathProperty, value); } + + /// The chosen entry (two-way). + public object? SelectedItem { get => GetValue(SelectedItemProperty); set => SetValue(SelectedItemProperty, value); } + + public bool IsDropDownOpen { get => (bool)GetValue(IsDropDownOpenProperty); set => SetValue(IsDropDownOpenProperty, value); } + + /// Tooltip of the ▾ part. + public object? DropDownToolTip { get => GetValue(DropDownToolTipProperty); set => SetValue(DropDownToolTipProperty, value); } + + /// Accent fill (the one primary action of a screen). + public bool IsPrimary { get => (bool)GetValue(IsPrimaryProperty); set => SetValue(IsPrimaryProperty, value); } + + protected override void OnKeyDown(KeyEventArgs e) + { + base.OnKeyDown(e); + if (e.Handled) return; + var key = e.Key == Key.System ? e.SystemKey : e.Key; + if (key == Key.F4 || (key == Key.Down && (Keyboard.Modifiers & ModifierKeys.Alt) != 0)) + { + SetCurrentValue(IsDropDownOpenProperty, true); + e.Handled = true; + } + } + + private static void OnIsDropDownOpenChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) + { + var button = (SplitButton)d; + if ((bool)e.NewValue) button.EnsureMenu().IsOpen = true; + else if (button._menu is { IsOpen: true } menu) menu.IsOpen = false; + } + + private ContextMenu EnsureMenu() + { + if (_menu is not null) return _menu; + var menu = new ContextMenu { PlacementTarget = this, Placement = PlacementMode.Bottom, VerticalOffset = 4 }; + menu.SetBinding(ItemsControl.ItemsSourceProperty, new Binding(nameof(ItemsSource)) { Source = this }); + menu.SetBinding(ItemsControl.ItemTemplateProperty, new Binding(nameof(ItemTemplate)) { Source = this }); + menu.SetBinding(ItemsControl.ItemContainerStyleProperty, new Binding(nameof(ItemContainerStyle)) { Source = this }); + menu.SetBinding(ItemsControl.DisplayMemberPathProperty, new Binding(nameof(DisplayMemberPath)) { Source = this }); + menu.SetBinding(DataContextProperty, new Binding(nameof(DataContext)) { Source = this }); + menu.AddHandler(MenuItem.ClickEvent, new RoutedEventHandler(OnMenuItemClick)); + menu.Opened += (_, _) => MarkSelected(); + menu.Closed += (_, _) => SetCurrentValue(IsDropDownOpenProperty, false); + _menu = menu; + return menu; + } + + private void OnMenuItemClick(object sender, RoutedEventArgs e) + { + if (_menu is null || e.OriginalSource is not MenuItem container) return; + var item = _menu.ItemContainerGenerator.ItemFromContainer(container); + if (item != DependencyProperty.UnsetValue) SetCurrentValue(SelectedItemProperty, item); + } + + /// Checks the menu entry of the current choice. + private void MarkSelected() + { + if (_menu is null) return; + _menu.UpdateLayout(); + for (var i = 0; i < _menu.Items.Count; i++) + if (_menu.ItemContainerGenerator.ContainerFromIndex(i) is MenuItem container) + container.IsChecked = Equals(_menu.Items[i], SelectedItem); + } +} From 04e3e3bddaec37fe68714fa6c34212fa9cf48c5a Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 10:27:10 +0000 Subject: [PATCH 10/13] feat(ui-visuals): add Visuals.xaml styles and merge them into the theme Card list and container styles, SequenceCard, PreviewViewport, SegmentedControl and SplitButton templates, focus visuals for the drawn controls; Controls.xaml merges the dictionary. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- src/Titano.Ui/Themes/Controls.xaml | 1 + src/Titano.Ui/Themes/Visuals.xaml | 298 +++++++++++++++++++++++++++++ 2 files changed, 299 insertions(+) create mode 100644 src/Titano.Ui/Themes/Visuals.xaml diff --git a/src/Titano.Ui/Themes/Controls.xaml b/src/Titano.Ui/Themes/Controls.xaml index aabdc7bc..bd057671 100644 --- a/src/Titano.Ui/Themes/Controls.xaml +++ b/src/Titano.Ui/Themes/Controls.xaml @@ -9,6 +9,7 @@ + diff --git a/src/Titano.Ui/Themes/Visuals.xaml b/src/Titano.Ui/Themes/Visuals.xaml new file mode 100644 index 00000000..253abb6e --- /dev/null +++ b/src/Titano.Ui/Themes/Visuals.xaml @@ -0,0 +1,298 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From b0c5790adbf6b200ba9718ab081575588b112b72 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 10:27:10 +0000 Subject: [PATCH 11/13] test(ui-visuals): render every visual off screen and virtualize 500k items Windows-only tests load the real theme on an STA dispatcher, render each control in both themes, check the card fits the default grid slot, the wrap panel keeps containers bounded over half a million items, preview zoom modes and segment positions, and asynchronous filmstrip loading. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- .../Visuals/VisualsSmokeTests.cs | 322 ++++++++++++++++++ 1 file changed, 322 insertions(+) create mode 100644 tests/Titano.App.Tests/Visuals/VisualsSmokeTests.cs diff --git a/tests/Titano.App.Tests/Visuals/VisualsSmokeTests.cs b/tests/Titano.App.Tests/Visuals/VisualsSmokeTests.cs new file mode 100644 index 00000000..65e1a41f --- /dev/null +++ b/tests/Titano.App.Tests/Visuals/VisualsSmokeTests.cs @@ -0,0 +1,322 @@ +using System.Collections.ObjectModel; +using System.Diagnostics; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Media; +using System.Windows.Media.Imaging; +using System.Windows.Threading; +using Titano.Testing; +using Titano.Ui.Controls; +using Titano.Ui.Theming; +using Titano.Ui.Visuals; + +namespace Titano.App.Tests.Visuals; + +/// +/// Loads the real theme (Controls.xaml + Visuals.xaml) on an STA dispatcher and measures, arranges and renders +/// every visual off screen in both themes: catches template, resource and layout errors that compile cleanly. +/// +[WindowsOnly] +[Serial] +public sealed class VisualsSmokeTests +{ + [Test] + public void ThemeProvidesVisualStyles() => WpfHost.Run(() => + { + Assert.True(Application.Current.TryFindResource(typeof(SequenceCard)) is Style); + Assert.True(Application.Current.TryFindResource(typeof(PreviewViewport)) is Style); + Assert.True(Application.Current.TryFindResource("ListBox.Cards") is Style); + Assert.True(Application.Current.TryFindResource("ListBoxItem.Card") is Style); + }); + + [Test] + public void EveryVisualRendersInBothThemes() => WpfHost.Run(() => + { + foreach (var theme in new[] { AppTheme.Dark, AppTheme.Light }) + { + ThemeManager.Apply(theme); + foreach (var (name, element, width, height) in Samples()) + { + var pixels = Painted(Render(element, width, height)); + Assert.Greater(pixels, 0, $"{name} drew nothing in {theme}"); + } + } + ThemeManager.Apply(AppTheme.Dark); + }); + + [Test] + public void CardFitsTheDefaultGridSlot() => WpfHost.Run(() => + { + var card = SampleCard(); + card.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity)); + Assert.Approximately(236, card.DesiredSize.Width, 0.5); + Assert.LessOrEqual(card.DesiredSize.Height, (double)VirtualizingWrapPanel.ItemHeightProperty.DefaultMetadata.DefaultValue + 0.5); + }); + + [Test] + public void WrapPanelVirtualizesHalfAMillionItems() => WpfHost.Run(() => + { + var list = new ListBox + { + Style = (Style)Application.Current.FindResource("ListBox.Cards"), + ItemsSource = Enumerable.Range(0, 500_000).ToArray(), + }; + Render(list, 1300, 900); + var panel = Assert.NotNull(FindChild(list)); + var columns = WrapLayout.ColumnsFor(1300 - 40, panel.ItemWidth, panel.Spacing); + var rows = (int)Math.Ceiling(900 / (panel.ItemHeight + panel.Spacing)) + 3; + Assert.LessOrEqual(panel.Children.Count, rows * columns); + Assert.Approximately(100_000 * (panel.ItemHeight + panel.Spacing) - panel.Spacing + 16, panel.ExtentHeight, 1); + + var stopwatch = Stopwatch.StartNew(); + for (var i = 0; i < 300; i++) + { + panel.SetVerticalOffset(panel.VerticalOffset + 37); + list.UpdateLayout(); + } + stopwatch.Stop(); + Assert.Less(stopwatch.Elapsed.TotalSeconds, 5, "300 scroll steps"); + Assert.LessOrEqual(panel.Children.Count, rows * columns); + + panel.SetVerticalOffset(panel.ExtentHeight / 2); + list.UpdateLayout(); + var first = (int)((ListBoxItem)panel.Children[0]).Content; + Assert.InRange(first, 249_000, 251_000); + + list.ScrollIntoView(400_000); + list.UpdateLayout(); + Assert.NotNull(list.ItemContainerGenerator.ContainerFromIndex(400_000)); + Assert.LessOrEqual(panel.Children.Count, rows * columns); + }); + + [Test] + public void PreviewZoomModesMapToDevicePixels() => WpfHost.Run(() => + { + var preview = new PreviewViewport { Source = Bitmap(2000, 1500) }; + Render(preview, 800, 450); + var dpi = VisualTreeHelper.GetDpi(preview).DpiScaleX; + Assert.Approximately(Math.Min(800 / 2000.0, 450 / 1500.0) * dpi, preview.Zoom, 1e-6); + preview.ZoomMode = PreviewZoomMode.Actual; + Assert.Approximately(1, preview.Zoom, 1e-9); + preview.Zoom = 2; + Assert.Equal(PreviewZoomMode.Custom, preview.ZoomMode); + Assert.Approximately(2 / dpi, preview.View.Scale, 1e-9); + }); + + [Test] + public void SegmentsKnowTheirPosition() => WpfHost.Run(() => + { + var control = SampleSegments(); + Render(control, 120, 32); + Assert.Equal(SegmentPosition.First, ((SegmentedItem)control.Items[0]).Position); + Assert.Equal(SegmentPosition.Middle, ((SegmentedItem)control.Items[1]).Position); + Assert.Equal(SegmentPosition.Last, ((SegmentedItem)control.Items[2]).Position); + }); + + [Test] + public void FilmstripRequestsThumbnailsAsynchronously() => WpfHost.Run(() => + { + var source = new FakeFrames(3600); + var strip = new Filmstrip { Source = source, CurrentIndex = 412 }; + Render(strip, 900, 58); + WpfHost.DoEvents(); + Assert.Greater(source.Requests, 0); + Assert.Greater(source.LastPixelWidth, 0); + Render(strip, 900, 58); + Assert.Equal(412, strip.CurrentIndex); + }); + + private static IEnumerable<(string Name, FrameworkElement Element, double Width, double Height)> Samples() + { + var n = 120_000; + var measured = new double[n]; + var target = new double[n]; + var sky = new double[n]; + var random = new Random(3); + for (var i = 0; i < n; i++) + { + target[i] = 0.8 - i / (double)n * 0.6; + measured[i] = target[i] + (random.NextDouble() - 0.5) * 0.05; + sky[i] = i is > 500 and < 900 ? double.NaN : target[i] + 0.1; + } + var markers = new[] { new TimelineMarker(30_000, MarkerKind.ExposureStep, "-1 EV"), new TimelineMarker(70_000, MarkerKind.Keyframe) }; + yield return ("SeriesChart", new SeriesChart + { + Series = + [ + new ChartSeries("measured", measured, "Brush.Sun") { Thickness = 1.4 }, + new ChartSeries("target", target, "Brush.Accent") { Thickness = 2.2 }, + new ChartSeries("sky", sky, "Brush.Region") { Dash = LineDash.Dashed }, + ], + Markers = markers, + Summary = "summary", + CurrentIndex = 1000, + XLabelFormatter = v => v.ToString("N0"), + }, 900, 200); + + var items = new[] { new ChartItem("2019", 0.3), new ChartItem("2020", 0.5), new ChartItem("2021", 1.8, "1.8 TB") }; + yield return ("BarChart.Horizontal", new BarChart { Items = items, MinimumOpacity = 0.5 }, 300, 120); + yield return ("BarChart.Vertical", new BarChart { Items = items, Orientation = Orientation.Vertical, ShowGrid = true }, 300, 160); + yield return ("StackedBar", new StackedBar { Items = items }, 300, 60); + + var months = new[] { "J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D" }; + var rows = Enumerable.Range(2019, 8).Select(y => new ChartRow(y.ToString(), Enumerable.Range(0, 12).Select(m => y == 2026 && m > 8 ? double.NaN : (double)(m * y % 97)).ToArray())).ToArray(); + yield return ("HeatmapStrip", new HeatmapStrip { Rows = rows, ColumnLabels = months }, 300, 220); + yield return ("TimelineBands", new TimelineBands { Bands = rows, SlotLabels = months, CurrentBand = 1, CurrentSlot = 3 }, 600, 520); + + yield return ("Filmstrip", new Filmstrip { Source = new FakeFrames(3600), Markers = markers, CurrentIndex = 500 }, 900, 58); + yield return ("CurveEditor", new CurveEditor + { + Points = new ObservableCollection { new(0, 0), new(0.5, 0.3), new(1, 1) }, + Evaluator = x => x * x, + Mode = CurveEditMode.TimeRemap, + ShowDiagonal = true, + PlayheadPosition = 0.4, + SelectedIndex = 1, + }, 400, 200); + + yield return ("PreviewViewport", new PreviewViewport + { + Source = Bitmap(2000, 1500), + OriginalSource = Bitmap(1000, 750), + IsCompareEnabled = true, + WipeLabel = "original | corrected", + InfoText = "0413 / 3,600", + ShowVectors = true, + MotionVectors = [new MotionVector(100, 100, 3, -2), new MotionVector(900, 700, -1, 4)], + VectorScale = 20, + ShowRegions = true, + RegionBoundary = [new Point(0, 800), new Point(1000, 760), new Point(2000, 820)], + ShowCropMask = true, + CropRect = new Rect(0.1, 0.1, 0.8, 0.8), + }, 800, 450); + + yield return ("SequenceCard", SampleCard(), 236, 208); + yield return ("SegmentedControl", SampleSegments(), 120, 32); + yield return ("SplitButton", new SplitButton { Content = "Render", ItemsSource = new[] { "4K", "1080p" }, IsPrimary = true }, 200, 32); + } + + private static SequenceCard SampleCard() => new() + { + Title = "Harbour sunset", + Subtitle = "3,600 · Canon EOS R5 · 2 h 00 m", + Badge = "3,600", + Thumbnail = Bitmap(320, 180), + IsSelected = true, + Statuses = new[] { new CardStatus(StatusKind.Analysed, "a"), new CardStatus(StatusKind.Rendered, "2"), new CardStatus(StatusKind.Synced) }, + }; + + private static SegmentedControl SampleSegments() + { + var control = new SegmentedControl(); + foreach (var key in new[] { "Icon.ViewGrid", "Icon.ViewList", "Icon.ViewTimeline" }) + control.Items.Add(new SegmentedItem { Glyph = (IconData)Application.Current.FindResource(key), ToolTip = key }); + control.SelectedIndex = 0; + return control; + } + + private static BitmapSource Bitmap(int width, int height) + { + var pixels = new byte[width * height * 4]; + for (var y = 0; y < height; y++) + { + for (var x = 0; x < width; x++) + { + var i = (y * width + x) * 4; + pixels[i] = (byte)(x * 255 / width); + pixels[i + 1] = (byte)(y * 255 / height); + pixels[i + 2] = 128; + pixels[i + 3] = 255; + } + } + var bitmap = BitmapSource.Create(width, height, 96, 96, PixelFormats.Bgra32, null, pixels, width * 4); + bitmap.Freeze(); + return bitmap; + } + + private static RenderTargetBitmap Render(FrameworkElement element, double width, double height) + { + element.Measure(new Size(width, height)); + element.Arrange(new Rect(0, 0, width, height)); + element.UpdateLayout(); + var bitmap = new RenderTargetBitmap((int)width, (int)height, 96, 96, PixelFormats.Pbgra32); + bitmap.Render(element); + return bitmap; + } + + private static int Painted(BitmapSource bitmap) + { + var stride = bitmap.PixelWidth * 4; + var pixels = new byte[stride * bitmap.PixelHeight]; + bitmap.CopyPixels(pixels, stride, 0); + var count = 0; + for (var i = 3; i < pixels.Length; i += 4) + if (pixels[i] != 0) count++; + return count; + } + + private static T? FindChild(DependencyObject root) + where T : DependencyObject + { + for (var i = 0; i < VisualTreeHelper.GetChildrenCount(root); i++) + { + var child = VisualTreeHelper.GetChild(root, i); + if (child is T match) return match; + if (FindChild(child) is { } nested) return nested; + } + return null; + } + + private sealed class FakeFrames(int count) : IThumbnailSource + { + private readonly BitmapSource _frame = Bitmap(64, 36); + + public int Count => count; + + public int Requests { get; private set; } + + public int LastPixelWidth { get; private set; } + + public ValueTask GetAsync(int index, int pixelWidth, CancellationToken cancellationToken) + { + Requests++; + LastPixelWidth = pixelWidth; + return ValueTask.FromResult(_frame); + } + } + + /// One STA dispatcher with an Application and the Titano theme, shared by the WPF tests. + private static class WpfHost + { + private static readonly Lazy Dispatcher = new(Start); + + public static void Run(Action action) => Dispatcher.Value.Invoke(action); + + /// Processes queued dispatcher work (async continuations) on the current dispatcher. + public static void DoEvents() + { + var frame = new DispatcherFrame(); + System.Windows.Threading.Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Background, () => frame.Continue = false); + System.Windows.Threading.Dispatcher.PushFrame(frame); + } + + private static Dispatcher Start() + { + Dispatcher? dispatcher = null; + using var ready = new ManualResetEventSlim(); + var thread = new Thread(() => + { + var app = new Application { ShutdownMode = ShutdownMode.OnExplicitShutdown }; + ThemeManager.Initialize(app, AppTheme.Dark); + dispatcher = System.Windows.Threading.Dispatcher.CurrentDispatcher; + ready.Set(); + System.Windows.Threading.Dispatcher.Run(); + }); + thread.SetApartmentState(ApartmentState.STA); + thread.IsBackground = true; + thread.Start(); + ready.Wait(); + return dispatcher!; + } + } +} From 75508395c3fe25dfe73f81e668e8ddbfb7779ac9 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 10:28:13 +0000 Subject: [PATCH 12/13] fix(ui-visuals): guard preview layers during base construction The base constructor sets an inherited property, which can enumerate visual children before the surface's layer collection is assigned. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- src/Titano.Ui/Visuals/PreviewSurface.cs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/Titano.Ui/Visuals/PreviewSurface.cs b/src/Titano.Ui/Visuals/PreviewSurface.cs index 245a2b99..f8921f4f 100644 --- a/src/Titano.Ui/Visuals/PreviewSurface.cs +++ b/src/Titano.Ui/Visuals/PreviewSurface.cs @@ -45,7 +45,8 @@ public sealed class PreviewSurface : DrawingElement /// Viewport whose properties drive the layers. internal PreviewViewport? Owner { get; set; } - protected override int VisualChildrenCount => _layers.Count; + // The base constructor sets an inherited property, which may enumerate children before _layers exists. + protected override int VisualChildrenCount => _layers is null ? 0 : _layers.Count; protected override Visual GetVisualChild(int index) => _layers[index]; From a12ec6b49331e34196453c16141c474ae788b44e Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 10:29:45 +0000 Subject: [PATCH 13/13] perf(ui-visuals): keep seeking and panning free of redundant work The filmstrip moves one cached current-frame marker instead of building a geometry per seek; panning the preview no longer re-applies the wipe clip or re-sets an unchanged zoom. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- src/Titano.Ui/Visuals/Filmstrip.cs | 20 ++++++++++++++++---- src/Titano.Ui/Visuals/PreviewSurface.cs | 1 - src/Titano.Ui/Visuals/PreviewViewport.cs | 4 +++- 3 files changed, 19 insertions(+), 6 deletions(-) diff --git a/src/Titano.Ui/Visuals/Filmstrip.cs b/src/Titano.Ui/Visuals/Filmstrip.cs index efa9001a..fb639cb3 100644 --- a/src/Titano.Ui/Visuals/Filmstrip.cs +++ b/src/Titano.Ui/Visuals/Filmstrip.cs @@ -39,6 +39,9 @@ public sealed class Filmstrip : DrawingElement private static readonly MarkerKind[] Kinds = Enum.GetValues(); + /// The current-frame ▼ at x = 0; moved by so seeking allocates no geometry. + private static readonly Geometry CurrentMarker = CreateCurrentMarker(); + private LruCache _cache = new(256); private readonly HashSet _pending = []; private CancellationTokenSource _loads = new(); @@ -46,6 +49,7 @@ public sealed class Filmstrip : DrawingElement private Rect _cells; private bool _dragging; private int _wheelDelta; + private readonly TranslateTransform _markerShift = new(); static Filmstrip() { @@ -120,10 +124,10 @@ public sealed class Filmstrip : DrawingElement var outline = new Rect(left + 1, _cells.Top + 1, Math.Max(0, right - left - 2), Math.Max(0, _cells.Height - 2)); dc.DrawRectangle(null, GetPen("Brush.Accent", 2), outline); - var marker = new StreamGeometry(); - using (var ctx = marker.Open()) AddTriangleDown(ctx, _strip.XForFrame(frame), 1, 9); - marker.Freeze(); - dc.DrawGeometry(GetBrush("Brush.Accent"), null, marker); + _markerShift.X = _strip.XForFrame(frame); + dc.PushTransform(_markerShift); + dc.DrawGeometry(GetBrush("Brush.Accent"), null, CurrentMarker); + dc.Pop(); } protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e) @@ -219,6 +223,14 @@ public sealed class Filmstrip : DrawingElement private static void OnCacheCapacityChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) => ((Filmstrip)d)._cache.Capacity = (int)e.NewValue; + private static StreamGeometry CreateCurrentMarker() + { + var geometry = new StreamGeometry(); + using (var ctx = geometry.Open()) AddTriangleDown(ctx, 0, 1, 9); + geometry.Freeze(); + return geometry; + } + /// Draws scaled to cover , centred and cropped. private static void DrawCover(DrawingContext dc, ImageSource image, Rect cell) { diff --git a/src/Titano.Ui/Visuals/PreviewSurface.cs b/src/Titano.Ui/Visuals/PreviewSurface.cs index f8921f4f..d9756bfa 100644 --- a/src/Titano.Ui/Visuals/PreviewSurface.cs +++ b/src/Titano.Ui/Visuals/PreviewSurface.cs @@ -76,7 +76,6 @@ public sealed class PreviewSurface : DrawingElement RenderOptions.SetBitmapScalingMode(_original, mode); } if (view.Scale != _overlayScale) RefreshOverlay(); - UpdateWipeClip(); } /// Rebuilds the overlays (crop mask, region boundary, motion vectors) in image coordinates. diff --git a/src/Titano.Ui/Visuals/PreviewViewport.cs b/src/Titano.Ui/Visuals/PreviewViewport.cs index bcfc5bb3..77679d2c 100644 --- a/src/Titano.Ui/Visuals/PreviewViewport.cs +++ b/src/Titano.Ui/Visuals/PreviewViewport.cs @@ -363,10 +363,12 @@ public class PreviewViewport : Control if (ZoomMode == PreviewZoomMode.Actual) view = ViewportMath.SnapOffset(view, dpi); _view = view; _surface?.SetView(view, view.Scale * dpi); + var zoom = view.Scale * dpi; + if (zoom == Zoom) return; _syncingZoom = true; try { - SetCurrentValue(ZoomProperty, view.Scale * dpi); + SetCurrentValue(ZoomProperty, zoom); } finally {