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;
+ }
+}