Steven Kirk
3 years ago
14 changed files with 617 additions and 785 deletions
@ -1,23 +0,0 @@ |
|||
namespace Avalonia.Controls |
|||
{ |
|||
/// <summary>
|
|||
/// Describes the item virtualization method to use for a list.
|
|||
/// </summary>
|
|||
public enum ItemVirtualizationMode |
|||
{ |
|||
/// <summary>
|
|||
/// Do not virtualize items.
|
|||
/// </summary>
|
|||
None, |
|||
|
|||
/// <summary>
|
|||
/// Virtualize items without smooth scrolling.
|
|||
/// </summary>
|
|||
Simple, |
|||
|
|||
/// <summary>
|
|||
/// Virtualize items with smooth scrolling.
|
|||
/// </summary>
|
|||
Smooth, |
|||
} |
|||
} |
|||
@ -1,662 +0,0 @@ |
|||
using System; |
|||
using System.Collections; |
|||
using System.Collections.Generic; |
|||
using System.Collections.Specialized; |
|||
using System.Diagnostics; |
|||
using Avalonia.Controls.Utils; |
|||
using Avalonia.Layout; |
|||
using Avalonia.Utilities; |
|||
using Avalonia.VisualTree; |
|||
|
|||
namespace Avalonia.Controls |
|||
{ |
|||
public partial class VirtualizingStackPanel : VirtualizingPanel |
|||
{ |
|||
private static readonly Rect s_invalidViewport = new(double.PositiveInfinity, double.PositiveInfinity, 0, 0); |
|||
private readonly Action<Control> _recycleElement; |
|||
private readonly Action<Control, int> _updateElementIndex; |
|||
private int _anchorIndex = -1; |
|||
private Control? _anchorElement; |
|||
private bool _isWaitingForViewportUpdate; |
|||
private double _lastEstimatedElementSizeU = 25; |
|||
private RealizedElementList? _measureElements; |
|||
private RealizedElementList? _realizedElements; |
|||
private Rect _viewport = s_invalidViewport; |
|||
|
|||
private Size MeasureOverrideSmooth(Size availableSize) |
|||
{ |
|||
if (!IsEffectivelyVisible) |
|||
return default; |
|||
|
|||
var items = ItemsControl?.Items as IList; |
|||
|
|||
if (items is null || items.Count == 0) |
|||
{ |
|||
Children.Clear(); |
|||
return default; |
|||
} |
|||
|
|||
var orientation = Orientation; |
|||
|
|||
_realizedElements ??= new(); |
|||
_measureElements ??= new(); |
|||
|
|||
// If we're bringing an item into view, ignore any layout passes until we receive a new
|
|||
// effective viewport.
|
|||
if (_isWaitingForViewportUpdate) |
|||
{ |
|||
var sizeV = orientation == Orientation.Horizontal ? DesiredSize.Height : DesiredSize.Width; |
|||
return CalculateDesiredSize(orientation, items, sizeV); |
|||
} |
|||
|
|||
// We handle horizontal and vertical layouts here so X and Y are abstracted to:
|
|||
// - Horizontal layouts: U = horizontal, V = vertical
|
|||
// - Vertical layouts: U = vertical, V = horizontal
|
|||
var viewport = CalculateMeasureViewport(items); |
|||
|
|||
// Recycle elements outside of the expected range.
|
|||
_realizedElements.RecycleElementsBefore(viewport.firstIndex, _recycleElement); |
|||
_realizedElements.RecycleElementsAfter(viewport.estimatedLastIndex, _recycleElement); |
|||
|
|||
// Do the measure, creating/recycling elements as necessary to fill the viewport. Don't
|
|||
// write to _realizedElements yet, only _measureElements.
|
|||
GenerateElements(availableSize, ref viewport); |
|||
|
|||
// Now we know what definitely fits, recycle anything left over.
|
|||
_realizedElements.RecycleElementsAfter(_measureElements.LastModelIndex, _recycleElement); |
|||
|
|||
// And swap the measureElements and realizedElements collection.
|
|||
(_measureElements, _realizedElements) = (_realizedElements, _measureElements); |
|||
_measureElements.ResetForReuse(); |
|||
|
|||
return CalculateDesiredSize(orientation, items, viewport.measuredV); |
|||
} |
|||
|
|||
private Size ArrangeOverrideSmooth(Size finalSize) |
|||
{ |
|||
Debug.Assert(_realizedElements is not null); |
|||
|
|||
var orientation = Orientation; |
|||
var u = _realizedElements!.StartU; |
|||
|
|||
for (var i = 0; i < _realizedElements.Count; ++i) |
|||
{ |
|||
var e = _realizedElements.Elements[i]; |
|||
|
|||
if (e is object) |
|||
{ |
|||
var sizeU = _realizedElements.SizeU[i]; |
|||
var rect = orientation == Orientation.Horizontal ? |
|||
new Rect(u, 0, sizeU, finalSize.Height) : |
|||
new Rect(0, u, finalSize.Width, sizeU); |
|||
e.Arrange(rect); |
|||
u += orientation == Orientation.Horizontal ? rect.Width : rect.Height; |
|||
} |
|||
} |
|||
|
|||
return finalSize; |
|||
} |
|||
|
|||
private MeasureViewport CalculateMeasureViewport(IList items) |
|||
{ |
|||
Debug.Assert(_realizedElements is not null); |
|||
|
|||
// If the control has not yet been laid out then the effective viewport won't have been set.
|
|||
// Try to work it out from an ancestor control.
|
|||
var viewport = _viewport != s_invalidViewport ? _viewport : EstimateViewport(); |
|||
|
|||
// Get the viewport in the orientation direction.
|
|||
var viewportStart = Orientation == Orientation.Horizontal ? viewport.X : viewport.Y; |
|||
var viewportEnd = Orientation == Orientation.Horizontal ? viewport.Right : viewport.Bottom; |
|||
|
|||
var (firstIndex, firstIndexU) = _realizedElements!.GetElementAt(viewportStart); |
|||
var (lastIndex, _) = _realizedElements.GetElementAt(viewportEnd); |
|||
var estimatedElementSize = -1.0; |
|||
var itemCount = items?.Count ?? 0; |
|||
|
|||
if (firstIndex == -1) |
|||
{ |
|||
estimatedElementSize = EstimateElementSizeU(); |
|||
firstIndex = (int)(viewportStart / estimatedElementSize); |
|||
firstIndexU = firstIndex * estimatedElementSize; |
|||
} |
|||
|
|||
if (lastIndex == -1) |
|||
{ |
|||
if (estimatedElementSize == -1) |
|||
estimatedElementSize = EstimateElementSizeU(); |
|||
lastIndex = (int)(viewportEnd / estimatedElementSize); |
|||
} |
|||
|
|||
return new MeasureViewport |
|||
{ |
|||
firstIndex = MathUtilities.Clamp(firstIndex, 0, itemCount - 1), |
|||
estimatedLastIndex = MathUtilities.Clamp(lastIndex, 0, itemCount - 1), |
|||
viewportUStart = viewportStart, |
|||
viewportUEnd = viewportEnd, |
|||
startU = firstIndexU, |
|||
}; |
|||
} |
|||
|
|||
private Size CalculateDesiredSize(Orientation orientation, IList items, double sizeV) |
|||
{ |
|||
var sizeU = EstimateElementSizeU() * items.Count; |
|||
|
|||
if (double.IsInfinity(sizeU) || double.IsNaN(sizeU)) |
|||
throw new InvalidOperationException("Invalid calculated size."); |
|||
|
|||
return orientation == Orientation.Horizontal ? |
|||
new Size(sizeU, sizeV) : |
|||
new Size(sizeV, sizeU); |
|||
} |
|||
|
|||
private double EstimateElementSizeU() |
|||
{ |
|||
var count = _realizedElements!.Count; |
|||
var divisor = 0.0; |
|||
var total = 0.0; |
|||
|
|||
for (var i = 0; i < count; ++i) |
|||
{ |
|||
if (_realizedElements.Elements[i] is object) |
|||
{ |
|||
total += _realizedElements.SizeU[i]; |
|||
++divisor; |
|||
} |
|||
} |
|||
|
|||
if (divisor == 0 || total == 0) |
|||
return _lastEstimatedElementSizeU; |
|||
|
|||
_lastEstimatedElementSizeU = total / divisor; |
|||
return _lastEstimatedElementSizeU; |
|||
} |
|||
|
|||
private Rect EstimateViewport() |
|||
{ |
|||
var c = this.GetVisualParent(); |
|||
var viewport = new Rect(); |
|||
|
|||
if (c is null) |
|||
{ |
|||
return viewport; |
|||
} |
|||
|
|||
while (c is not null) |
|||
{ |
|||
if (!c.Bounds.IsEmpty && c.TransformToVisual(this) is Matrix transform) |
|||
{ |
|||
viewport = new Rect(0, 0, c.Bounds.Width, c.Bounds.Height) |
|||
.TransformToAABB(transform); |
|||
break; |
|||
} |
|||
|
|||
c = c?.GetVisualParent(); |
|||
} |
|||
|
|||
|
|||
return viewport; |
|||
} |
|||
|
|||
private void GenerateElements(Size availableSize, ref MeasureViewport viewport) |
|||
{ |
|||
Debug.Assert(ItemsControl?.Items is IList); |
|||
Debug.Assert(_measureElements is not null); |
|||
|
|||
var items = (IList)ItemsControl!.Items; |
|||
var horizontal = Orientation == Orientation.Horizontal; |
|||
var index = viewport.firstIndex; |
|||
var u = viewport.startU; |
|||
|
|||
do |
|||
{ |
|||
var e = GetOrCreateElement(items, index); |
|||
e.Measure(availableSize); |
|||
|
|||
var sizeU = horizontal ? e.DesiredSize.Width : e.DesiredSize.Height; |
|||
var sizeV = horizontal ? e.DesiredSize.Height : e.DesiredSize.Width; |
|||
|
|||
_measureElements!.Add(index, e, u, sizeU); |
|||
viewport.measuredV = Math.Max(viewport.measuredV, sizeV); |
|||
|
|||
u += sizeU; |
|||
++index; |
|||
} while (u < viewport.viewportUEnd && index < items.Count); |
|||
} |
|||
|
|||
private Control GetOrCreateElement(IList items, int index) |
|||
{ |
|||
var e = GetRealizedElement(index) ?? GetRecycledOrCreateElement(items, index); |
|||
InvalidateHack(e); |
|||
return e; |
|||
} |
|||
|
|||
private Control? GetRealizedElement(int index) |
|||
{ |
|||
Debug.Assert(_realizedElements is not null); |
|||
|
|||
if (_anchorIndex == index) |
|||
return _anchorElement; |
|||
return _realizedElements!.GetElement(index); |
|||
} |
|||
|
|||
private Control GetRecycledOrCreateElement(IList items, int index) |
|||
{ |
|||
Debug.Assert(ItemsControl is not null); |
|||
|
|||
var c = ItemsControl!.ItemContainerGenerator.Materialize(index, items[index]!).ContainerControl; |
|||
Children.Add(c); |
|||
return c; |
|||
} |
|||
|
|||
private void RecycleElement(Control element) |
|||
{ |
|||
Debug.Assert(ItemsControl is not null); |
|||
|
|||
var index = ItemsControl.ItemContainerGenerator!.IndexFromContainer(element); |
|||
ItemsControl!.ItemContainerGenerator.Dematerialize(index, 1); |
|||
Children.Remove(element); |
|||
} |
|||
|
|||
private void UpdateElementIndex(Control element, int index) |
|||
{ |
|||
// TODO: Implement this after we refactor ItemContainerGenerator.
|
|||
} |
|||
|
|||
private void OnEffectiveViewportChanged(object? sender, EffectiveViewportChangedEventArgs e) |
|||
{ |
|||
_viewport = e.EffectiveViewport; |
|||
_isWaitingForViewportUpdate = false; |
|||
InvalidateMeasure(); |
|||
} |
|||
|
|||
private void OnItemsChangedSmooth(NotifyCollectionChangedEventArgs e) |
|||
{ |
|||
if (_realizedElements is null) |
|||
return; |
|||
|
|||
switch (e.Action) |
|||
{ |
|||
case NotifyCollectionChangedAction.Add: |
|||
_realizedElements.ItemsInserted(e.NewStartingIndex, e.NewItems!.Count, _updateElementIndex); |
|||
ItemsControl!.ItemContainerGenerator.InsertSpace(e.NewStartingIndex, e.NewItems!.Count); |
|||
break; |
|||
case NotifyCollectionChangedAction.Remove: |
|||
_realizedElements.ItemsRemoved(e.OldStartingIndex, e.OldItems!.Count, _updateElementIndex, _recycleElement); |
|||
ItemsControl!.ItemContainerGenerator.RemoveRange(e.OldStartingIndex, e.OldItems!.Count); |
|||
break; |
|||
case NotifyCollectionChangedAction.Reset: |
|||
////RecycleAllElements();
|
|||
break; |
|||
} |
|||
|
|||
InvalidateMeasure(); |
|||
} |
|||
|
|||
private static void InvalidateHack(Control c) |
|||
{ |
|||
bool HasInvalidations(Control c) |
|||
{ |
|||
if (!c.IsMeasureValid) |
|||
return true; |
|||
|
|||
for (var i = 0; i < c.VisualChildren.Count; ++i) |
|||
{ |
|||
if (c.VisualChildren[i] is Control child) |
|||
{ |
|||
if (!child.IsMeasureValid || HasInvalidations(child)) |
|||
return true; |
|||
} |
|||
} |
|||
|
|||
return false; |
|||
} |
|||
|
|||
void Invalidate(Control c) |
|||
{ |
|||
c.InvalidateMeasure(); |
|||
for (var i = 0; i < c.VisualChildren.Count; ++i) |
|||
{ |
|||
if (c.VisualChildren[i] is Control child) |
|||
Invalidate(child); |
|||
} |
|||
} |
|||
|
|||
if (HasInvalidations(c)) |
|||
Invalidate(c); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Stores the realized element state for a <see cref="VirtualizingStackPanel"/> in smooth mode.
|
|||
/// </summary>
|
|||
internal class RealizedElementList |
|||
{ |
|||
private int _firstIndex; |
|||
private List<Control?>? _elements; |
|||
private List<double>? _sizes; |
|||
private double _startU; |
|||
|
|||
/// <summary>
|
|||
/// Gets the number of realized elements.
|
|||
/// </summary>
|
|||
public int Count => _elements?.Count ?? 0; |
|||
|
|||
/// <summary>
|
|||
/// Gets the model index of the first realized element, or -1 if no elements are realized.
|
|||
/// </summary>
|
|||
public int FirstModelIndex => _elements?.Count > 0 ? _firstIndex : -1; |
|||
|
|||
/// <summary>
|
|||
/// Gets the model index of the last realized element, or -1 if no elements are realized.
|
|||
/// </summary>
|
|||
public int LastModelIndex => _elements?.Count > 0 ? _firstIndex + _elements.Count - 1 : -1; |
|||
|
|||
/// <summary>
|
|||
/// Gets the elements.
|
|||
/// </summary>
|
|||
public IReadOnlyList<Control?> Elements => _elements ??= new List<Control?>(); |
|||
|
|||
/// <summary>
|
|||
/// Gets the sizes of the elements on the primary axis.
|
|||
/// </summary>
|
|||
public IReadOnlyList<double> SizeU => _sizes ??= new List<double>(); |
|||
|
|||
/// <summary>
|
|||
/// Gets the position of the first element on the primary axis.
|
|||
/// </summary>
|
|||
public double StartU => _startU; |
|||
|
|||
/// <summary>
|
|||
/// Adds a newly realized element to the collection.
|
|||
/// </summary>
|
|||
/// <param name="modelIndex">The model index of the element.</param>
|
|||
/// <param name="element">The element.</param>
|
|||
/// <param name="u">The position of the elemnt on the primary axis.</param>
|
|||
/// <param name="sizeU">The size of the element on the primary axis.</param>
|
|||
public void Add(int modelIndex, Control element, double u, double sizeU) |
|||
{ |
|||
if (modelIndex < 0) |
|||
throw new ArgumentOutOfRangeException(nameof(modelIndex)); |
|||
|
|||
_elements ??= new List<Control?>(); |
|||
_sizes ??= new List<double>(); |
|||
|
|||
if (Count == 0) |
|||
{ |
|||
_elements.Add(element); |
|||
_sizes.Add(sizeU); |
|||
_startU = u; |
|||
_firstIndex = modelIndex; |
|||
} |
|||
else if (modelIndex == LastModelIndex + 1) |
|||
{ |
|||
_elements.Add(element); |
|||
_sizes.Add(sizeU); |
|||
} |
|||
else if (modelIndex == FirstModelIndex - 1) |
|||
{ |
|||
--_firstIndex; |
|||
_elements.Insert(0, element); |
|||
_sizes.Insert(0, sizeU); |
|||
_startU = u; |
|||
} |
|||
else |
|||
{ |
|||
throw new NotSupportedException("Can only add items to the beginning or end of realized elements."); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the element at the specified model index, if realized.
|
|||
/// </summary>
|
|||
/// <param name="modelIndex">The index in the source collection of the element to get.</param>
|
|||
/// <returns>The element if realized; otherwise null.</returns>
|
|||
public Control? GetElement(int modelIndex) |
|||
{ |
|||
var index = modelIndex - FirstModelIndex; |
|||
if (index >= 0 && index < _elements?.Count) |
|||
return _elements[index]; |
|||
return null; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the element at the specified position on the primary axis, if realized.
|
|||
/// </summary>
|
|||
/// <param name="position">The position.</param>
|
|||
/// <returns>
|
|||
/// A tuple containing the index of the element (or -1 if not found) and the position of the element on the
|
|||
/// primary axis.
|
|||
/// </returns>
|
|||
public (int index, double position) GetElementAt(double position) |
|||
{ |
|||
if (_sizes is null || position < StartU) |
|||
return (-1, 0); |
|||
|
|||
var u = StartU; |
|||
var i = FirstModelIndex; |
|||
|
|||
foreach (var size in _sizes) |
|||
{ |
|||
var endU = u + size; |
|||
if (position < endU) |
|||
return (i, u); |
|||
u += size; |
|||
++i; |
|||
} |
|||
|
|||
return (-1, 0); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Updates the elements in response to items being inserted into the source collection.
|
|||
/// </summary>
|
|||
/// <param name="modelIndex">The index in the source collection of the insert.</param>
|
|||
/// <param name="count">The number of items inserted.</param>
|
|||
/// <param name="updateElementIndex">A method used to update the element indexes.</param>
|
|||
public void ItemsInserted(int modelIndex, int count, Action<Control, int> updateElementIndex) |
|||
{ |
|||
if (modelIndex < 0) |
|||
throw new ArgumentOutOfRangeException(nameof(modelIndex)); |
|||
if (_elements is null || _elements.Count == 0) |
|||
return; |
|||
|
|||
// Get the index within the realized _elements collection.
|
|||
var first = FirstModelIndex; |
|||
var index = modelIndex - first; |
|||
|
|||
if (index < Count) |
|||
{ |
|||
// The insertion point affects the realized elements. Update the index of the
|
|||
// elements after the insertion point.
|
|||
var elementCount = _elements.Count; |
|||
var start = Math.Max(index, 0); |
|||
|
|||
for (var i = start; i < elementCount; ++i) |
|||
{ |
|||
if (_elements[i] is Control element) |
|||
updateElementIndex(element, first + i + count); |
|||
} |
|||
|
|||
if (index <= 0) |
|||
{ |
|||
// The insertion point was before the first element, update the first index.
|
|||
_firstIndex += count; |
|||
} |
|||
else |
|||
{ |
|||
// The insertion point was within the realized elements, insert an empty space
|
|||
// in _elements and _sizes.
|
|||
_elements!.InsertMany(index, null, count); |
|||
_sizes!.InsertMany(index, 0.0, count); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Updates the elements in response to items being removed from the source collection.
|
|||
/// </summary>
|
|||
/// <param name="modelIndex">The index in the source collection of the remove.</param>
|
|||
/// <param name="count">The number of items removed.</param>
|
|||
/// <param name="updateElementIndex">A method used to update the element indexes.</param>
|
|||
/// <param name="recycleElement">A method used to recycle elements.</param>
|
|||
public void ItemsRemoved( |
|||
int modelIndex, |
|||
int count, |
|||
Action<Control, int> updateElementIndex, |
|||
Action<Control> recycleElement) |
|||
{ |
|||
if (modelIndex < 0) |
|||
throw new ArgumentOutOfRangeException(nameof(modelIndex)); |
|||
if (_elements is null || _elements.Count == 0) |
|||
return; |
|||
|
|||
// Get the removal start and end index within the realized _elements collection.
|
|||
var first = FirstModelIndex; |
|||
var last = LastModelIndex; |
|||
var startIndex = modelIndex - first; |
|||
var endIndex = (modelIndex + count) - first; |
|||
|
|||
if (endIndex < 0) |
|||
{ |
|||
// The removed range was before the realized elements. Update the first index and
|
|||
// the indexes of the realized elements.
|
|||
_firstIndex -= count; |
|||
|
|||
for (var i = 0; i < _elements.Count; ++i) |
|||
{ |
|||
if (_elements[i] is Control element) |
|||
updateElementIndex(element, _firstIndex + i); |
|||
} |
|||
} |
|||
else if (startIndex < _elements.Count) |
|||
{ |
|||
// Recycle and remove the affected elements.
|
|||
var start = Math.Max(startIndex, 0); |
|||
var end = Math.Min(endIndex, _elements.Count); |
|||
|
|||
for (var i = start; i < end; ++i) |
|||
{ |
|||
if (_elements[i] is Control element) |
|||
recycleElement(element); |
|||
} |
|||
|
|||
_elements.RemoveRange(start, end - start); |
|||
_sizes!.RemoveRange(start, end - start); |
|||
|
|||
// If the remove started before and ended within our realized elements, then our new
|
|||
// first index will be the index where the remove started.
|
|||
if (startIndex <= 0 && end < last) |
|||
_firstIndex = first = modelIndex; |
|||
|
|||
// Update the indexes of the elements after the removed range.
|
|||
end = _elements.Count; |
|||
for (var i = start; i < end; ++i) |
|||
{ |
|||
if (_elements[i] is Control element) |
|||
updateElementIndex(element, first + i); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Recycles elements before a specific index.
|
|||
/// </summary>
|
|||
/// <param name="modelIndex">The index in the source collection of new first element.</param>
|
|||
/// <param name="recycleElement">A method used to recycle elements.</param>
|
|||
public void RecycleElementsBefore(int modelIndex, Action<Control> recycleElement) |
|||
{ |
|||
if (modelIndex <= FirstModelIndex || _elements is null || _elements.Count == 0) |
|||
return; |
|||
|
|||
if (modelIndex > LastModelIndex) |
|||
{ |
|||
RecycleAllElements(recycleElement); |
|||
} |
|||
else |
|||
{ |
|||
var endIndex = modelIndex - FirstModelIndex; |
|||
|
|||
for (var i = 0; i < endIndex; ++i) |
|||
{ |
|||
if (_elements[i] is Control e) |
|||
recycleElement(e); |
|||
} |
|||
|
|||
_elements.RemoveRange(0, endIndex); |
|||
_sizes!.RemoveRange(0, endIndex); |
|||
_firstIndex = modelIndex; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Recycles elements after a specific index.
|
|||
/// </summary>
|
|||
/// <param name="modelIndex">The index in the source collection of new last element.</param>
|
|||
/// <param name="recycleElement">A method used to recycle elements.</param>
|
|||
public void RecycleElementsAfter(int modelIndex, Action<Control> recycleElement) |
|||
{ |
|||
if (modelIndex >= LastModelIndex || _elements is null || _elements.Count == 0) |
|||
return; |
|||
|
|||
if (modelIndex < FirstModelIndex) |
|||
{ |
|||
RecycleAllElements(recycleElement); |
|||
} |
|||
else |
|||
{ |
|||
var startIndex = (modelIndex + 1) - FirstModelIndex; |
|||
var count = _elements.Count; |
|||
|
|||
for (var i = startIndex; i < count; ++i) |
|||
{ |
|||
if (_elements[i] is Control e) |
|||
recycleElement(e); |
|||
} |
|||
|
|||
_elements.RemoveRange(startIndex, _elements.Count - startIndex); |
|||
_sizes!.RemoveRange(startIndex, _sizes.Count - startIndex); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Recycles all realized elements.
|
|||
/// </summary>
|
|||
/// <param name="recycleElement">A method used to recycle elements.</param>
|
|||
public void RecycleAllElements(Action<Control> recycleElement) |
|||
{ |
|||
if (_elements is null || _elements.Count == 0) |
|||
return; |
|||
|
|||
foreach (var e in _elements) |
|||
{ |
|||
if (e is object) |
|||
recycleElement(e); |
|||
} |
|||
|
|||
_startU = _firstIndex = 0; |
|||
_elements?.Clear(); |
|||
_sizes?.Clear(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Resets the element list and prepares it for reuse.
|
|||
/// </summary>
|
|||
public void ResetForReuse() |
|||
{ |
|||
_startU = _firstIndex = 0; |
|||
_elements?.Clear(); |
|||
_sizes?.Clear(); |
|||
} |
|||
} |
|||
|
|||
private struct MeasureViewport |
|||
{ |
|||
public int firstIndex; |
|||
public int estimatedLastIndex; |
|||
public double viewportUStart; |
|||
public double viewportUEnd; |
|||
public double measuredV; |
|||
public double startU; |
|||
} |
|||
} |
|||
} |
|||
Loading…
Reference in new issue