JaggerJo
7 years ago
284 changed files with 11386 additions and 2170 deletions
@ -1,6 +1,6 @@ |
|||
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
|||
<ItemGroup> |
|||
<PackageReference Include="SkiaSharp" Version="1.68.0" /> |
|||
<PackageReference Condition="'$(IncludeLinuxSkia)' == 'true'" Include="Avalonia.Skia.Linux.Natives" Version="1.68.0.1" /> |
|||
<PackageReference Condition="'$(IncludeLinuxSkia)' == 'true'" Include="Avalonia.Skia.Linux.Natives" Version="1.68.0.2" /> |
|||
</ItemGroup> |
|||
</Project> |
|||
|
|||
@ -0,0 +1,26 @@ |
|||
<UserControl xmlns="https://github.com/avaloniaui" |
|||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" |
|||
x:Class="ControlCatalog.Pages.ItemsRepeaterPage"> |
|||
<DockPanel> |
|||
<StackPanel DockPanel.Dock="Top" Spacing="4" Margin="0 0 0 16"> |
|||
<TextBlock Classes="h1">ItemsRepeater</TextBlock> |
|||
<TextBlock Classes="h2">A data-driven collection control that incorporates a flexible layout system, custom views, and virtualization.</TextBlock> |
|||
</StackPanel> |
|||
<StackPanel DockPanel.Dock="Right" Margin="8 0" Spacing="4"> |
|||
<ComboBox SelectedIndex="0" SelectionChanged="LayoutChanged"> |
|||
<ComboBoxItem>Stack - Vertical</ComboBoxItem> |
|||
<ComboBoxItem>Stack - Horizontal</ComboBoxItem> |
|||
<ComboBoxItem>UniformGrid - Vertical</ComboBoxItem> |
|||
<ComboBoxItem>UniformGrid - Horizontal</ComboBoxItem> |
|||
</ComboBox> |
|||
<Button Command="{Binding AddItem}">Add Item</Button> |
|||
</StackPanel> |
|||
<Border BorderThickness="1" BorderBrush="{DynamicResource ThemeBorderMidBrush}" Margin="0 0 0 16"> |
|||
<ScrollViewer Name="scroller" |
|||
HorizontalScrollBarVisibility="Auto" |
|||
VerticalScrollBarVisibility="Auto"> |
|||
<ItemsRepeater Name="repeater" Background="Transparent" Items="{Binding Items}"/> |
|||
</ScrollViewer> |
|||
</Border> |
|||
</DockPanel> |
|||
</UserControl> |
|||
@ -0,0 +1,81 @@ |
|||
using System; |
|||
using System.Linq; |
|||
using Avalonia.Controls; |
|||
using Avalonia.Controls.Primitives; |
|||
using Avalonia.Input; |
|||
using Avalonia.Layout; |
|||
using Avalonia.Markup.Xaml; |
|||
using ControlCatalog.ViewModels; |
|||
|
|||
namespace ControlCatalog.Pages |
|||
{ |
|||
public class ItemsRepeaterPage : UserControl |
|||
{ |
|||
private ItemsRepeater _repeater; |
|||
private ScrollViewer _scroller; |
|||
|
|||
public ItemsRepeaterPage() |
|||
{ |
|||
this.InitializeComponent(); |
|||
_repeater = this.FindControl<ItemsRepeater>("repeater"); |
|||
_scroller = this.FindControl<ScrollViewer>("scroller"); |
|||
_repeater.PointerPressed += RepeaterClick; |
|||
DataContext = new ItemsRepeaterPageViewModel(); |
|||
} |
|||
|
|||
private void InitializeComponent() |
|||
{ |
|||
AvaloniaXamlLoader.Load(this); |
|||
} |
|||
|
|||
private void LayoutChanged(object sender, SelectionChangedEventArgs e) |
|||
{ |
|||
if (_repeater == null) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
var comboBox = (ComboBox)sender; |
|||
|
|||
switch (comboBox.SelectedIndex) |
|||
{ |
|||
case 0: |
|||
_scroller.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto; |
|||
_scroller.VerticalScrollBarVisibility = ScrollBarVisibility.Auto; |
|||
_repeater.Layout = new StackLayout { Orientation = Orientation.Vertical }; |
|||
break; |
|||
case 1: |
|||
_scroller.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto; |
|||
_scroller.VerticalScrollBarVisibility = ScrollBarVisibility.Auto; |
|||
_repeater.Layout = new StackLayout { Orientation = Orientation.Horizontal }; |
|||
break; |
|||
case 2: |
|||
_scroller.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto; |
|||
_scroller.VerticalScrollBarVisibility = ScrollBarVisibility.Disabled; |
|||
_repeater.Layout = new UniformGridLayout |
|||
{ |
|||
Orientation = Orientation.Vertical, |
|||
MinItemWidth = 200, |
|||
MinItemHeight = 200, |
|||
}; |
|||
break; |
|||
case 3: |
|||
_scroller.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled; |
|||
_scroller.VerticalScrollBarVisibility = ScrollBarVisibility.Auto; |
|||
_repeater.Layout = new UniformGridLayout |
|||
{ |
|||
Orientation = Orientation.Horizontal, |
|||
MinItemWidth = 200, |
|||
MinItemHeight = 200, |
|||
}; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
private void RepeaterClick(object sender, PointerPressedEventArgs e) |
|||
{ |
|||
var item = (e.Source as TextBlock)?.DataContext as string; |
|||
((ItemsRepeaterPageViewModel)DataContext).SelectedItem = item; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,27 @@ |
|||
using System.Collections.ObjectModel; |
|||
using System.Linq; |
|||
using ReactiveUI; |
|||
|
|||
namespace ControlCatalog.ViewModels |
|||
{ |
|||
public class ItemsRepeaterPageViewModel : ReactiveObject |
|||
{ |
|||
private int newItemIndex = 1; |
|||
|
|||
public ItemsRepeaterPageViewModel() |
|||
{ |
|||
Items = new ObservableCollection<string>( |
|||
Enumerable.Range(1, 100000).Select(i => $"Item {i}")); |
|||
} |
|||
|
|||
public ObservableCollection<string> Items { get; } |
|||
|
|||
public string SelectedItem { get; set; } |
|||
|
|||
public void AddItem() |
|||
{ |
|||
var index = SelectedItem != null ? Items.IndexOf(SelectedItem) : -1; |
|||
Items.Insert(index + 1, $"New Item {newItemIndex++}"); |
|||
} |
|||
} |
|||
} |
|||
@ -1,112 +0,0 @@ |
|||
using System; |
|||
using Android.Content; |
|||
using Android.Graphics; |
|||
using Android.Runtime; |
|||
using Android.Views; |
|||
using Avalonia.Controls; |
|||
using Avalonia.Platform; |
|||
|
|||
namespace Avalonia.Android.Platform.SkiaPlatform |
|||
{ |
|||
class PopupImpl : TopLevelImpl, IPopupImpl |
|||
{ |
|||
private PixelPoint _position; |
|||
private bool _isAdded; |
|||
Action IWindowBaseImpl.Activated { get; set; } |
|||
public Action<PixelPoint> PositionChanged { get; set; } |
|||
public Action Deactivated { get; set; } |
|||
|
|||
public PopupImpl() : base(ActivityTracker.Current, true) |
|||
{ |
|||
} |
|||
|
|||
private Size _clientSize = new Size(1, 1); |
|||
|
|||
public void Resize(Size value) |
|||
{ |
|||
if (View == null) |
|||
return; |
|||
_clientSize = value; |
|||
UpdateParams(); |
|||
} |
|||
|
|||
public void SetMinMaxSize(Size minSize, Size maxSize) |
|||
{ |
|||
} |
|||
|
|||
public IScreenImpl Screen { get; } |
|||
|
|||
public PixelPoint Position |
|||
{ |
|||
get { return _position; } |
|||
set |
|||
{ |
|||
_position = value; |
|||
PositionChanged?.Invoke(_position); |
|||
UpdateParams(); |
|||
} |
|||
} |
|||
|
|||
WindowManagerLayoutParams CreateParams() => new WindowManagerLayoutParams(0, |
|||
WindowManagerFlags.NotTouchModal, Format.Translucent) |
|||
{ |
|||
Gravity = GravityFlags.Left | GravityFlags.Top, |
|||
WindowAnimations = 0, |
|||
X = (int) _position.X, |
|||
Y = (int) _position.Y, |
|||
Width = Math.Max(1, (int) _clientSize.Width), |
|||
Height = Math.Max(1, (int) _clientSize.Height) |
|||
}; |
|||
|
|||
void UpdateParams() |
|||
{ |
|||
if (_isAdded) |
|||
ActivityTracker.Current?.WindowManager?.UpdateViewLayout(View, CreateParams()); |
|||
} |
|||
|
|||
public override void Show() |
|||
{ |
|||
if (_isAdded) |
|||
return; |
|||
ActivityTracker.Current.WindowManager.AddView(View, CreateParams()); |
|||
_isAdded = true; |
|||
} |
|||
|
|||
public override void Hide() |
|||
{ |
|||
if (_isAdded) |
|||
{ |
|||
var wm = View.Context.ApplicationContext.GetSystemService(Context.WindowService) |
|||
.JavaCast<IWindowManager>(); |
|||
wm.RemoveView(View); |
|||
_isAdded = false; |
|||
} |
|||
} |
|||
|
|||
public override void Dispose() |
|||
{ |
|||
Hide(); |
|||
base.Dispose(); |
|||
} |
|||
|
|||
|
|||
public void Activate() |
|||
{ |
|||
} |
|||
|
|||
public void BeginMoveDrag() |
|||
{ |
|||
//Not supported
|
|||
} |
|||
|
|||
public void BeginResizeDrag(WindowEdge edge) |
|||
{ |
|||
//Not supported
|
|||
} |
|||
|
|||
public void SetTopmost(bool value) |
|||
{ |
|||
//Not supported
|
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,150 @@ |
|||
// Copyright (c) The Avalonia Project. All rights reserved.
|
|||
// Licensed under the MIT license. See licence.md file in the project root for full license information.
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
|
|||
namespace Avalonia.Utilities |
|||
{ |
|||
/// <summary>
|
|||
/// Stores values with <see cref="AvaloniaProperty"/> as key.
|
|||
/// </summary>
|
|||
/// <typeparam name="TValue">Stored value type.</typeparam>
|
|||
internal sealed class AvaloniaPropertyValueStore<TValue> |
|||
{ |
|||
private Entry[] _entries; |
|||
|
|||
public AvaloniaPropertyValueStore() |
|||
{ |
|||
// The last item in the list is always int.MaxValue
|
|||
_entries = new[] { new Entry { PropertyId = int.MaxValue, Value = default } }; |
|||
} |
|||
|
|||
private (int, bool) TryFindEntry(int propertyId) |
|||
{ |
|||
if (_entries.Length <= 12) |
|||
{ |
|||
// For small lists, we use an optimized linear search. Since the last item in the list
|
|||
// is always int.MaxValue, we can skip a conditional branch in each iteration.
|
|||
// By unrolling the loop, we can skip another unconditional branch in each iteration.
|
|||
|
|||
if (_entries[0].PropertyId >= propertyId) |
|||
return (0, _entries[0].PropertyId == propertyId); |
|||
if (_entries[1].PropertyId >= propertyId) |
|||
return (1, _entries[1].PropertyId == propertyId); |
|||
if (_entries[2].PropertyId >= propertyId) |
|||
return (2, _entries[2].PropertyId == propertyId); |
|||
if (_entries[3].PropertyId >= propertyId) |
|||
return (3, _entries[3].PropertyId == propertyId); |
|||
if (_entries[4].PropertyId >= propertyId) |
|||
return (4, _entries[4].PropertyId == propertyId); |
|||
if (_entries[5].PropertyId >= propertyId) |
|||
return (5, _entries[5].PropertyId == propertyId); |
|||
if (_entries[6].PropertyId >= propertyId) |
|||
return (6, _entries[6].PropertyId == propertyId); |
|||
if (_entries[7].PropertyId >= propertyId) |
|||
return (7, _entries[7].PropertyId == propertyId); |
|||
if (_entries[8].PropertyId >= propertyId) |
|||
return (8, _entries[8].PropertyId == propertyId); |
|||
if (_entries[9].PropertyId >= propertyId) |
|||
return (9, _entries[9].PropertyId == propertyId); |
|||
if (_entries[10].PropertyId >= propertyId) |
|||
return (10, _entries[10].PropertyId == propertyId); |
|||
} |
|||
else |
|||
{ |
|||
int low = 0; |
|||
int high = _entries.Length; |
|||
int id; |
|||
|
|||
while (high - low > 3) |
|||
{ |
|||
int pivot = (high + low) / 2; |
|||
id = _entries[pivot].PropertyId; |
|||
|
|||
if (propertyId == id) |
|||
return (pivot, true); |
|||
|
|||
if (propertyId <= id) |
|||
high = pivot; |
|||
else |
|||
low = pivot + 1; |
|||
} |
|||
|
|||
do |
|||
{ |
|||
id = _entries[low].PropertyId; |
|||
|
|||
if (id == propertyId) |
|||
return (low, true); |
|||
|
|||
if (id > propertyId) |
|||
break; |
|||
|
|||
++low; |
|||
} |
|||
while (low < high); |
|||
} |
|||
|
|||
return (0, false); |
|||
} |
|||
|
|||
public bool TryGetValue(AvaloniaProperty property, out TValue value) |
|||
{ |
|||
(int index, bool found) = TryFindEntry(property.Id); |
|||
if (!found) |
|||
{ |
|||
value = default; |
|||
return false; |
|||
} |
|||
|
|||
value = _entries[index].Value; |
|||
return true; |
|||
} |
|||
|
|||
public void AddValue(AvaloniaProperty property, TValue value) |
|||
{ |
|||
Entry[] entries = new Entry[_entries.Length + 1]; |
|||
|
|||
for (int i = 0; i < _entries.Length; ++i) |
|||
{ |
|||
if (_entries[i].PropertyId > property.Id) |
|||
{ |
|||
if (i > 0) |
|||
{ |
|||
Array.Copy(_entries, 0, entries, 0, i); |
|||
} |
|||
|
|||
entries[i] = new Entry { PropertyId = property.Id, Value = value }; |
|||
Array.Copy(_entries, i, entries, i + 1, _entries.Length - i); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
_entries = entries; |
|||
} |
|||
|
|||
public void SetValue(AvaloniaProperty property, TValue value) |
|||
{ |
|||
_entries[TryFindEntry(property.Id).Item1].Value = value; |
|||
} |
|||
|
|||
public Dictionary<AvaloniaProperty, TValue> ToDictionary() |
|||
{ |
|||
var dict = new Dictionary<AvaloniaProperty, TValue>(_entries.Length - 1); |
|||
|
|||
for (int i = 0; i < _entries.Length - 1; ++i) |
|||
{ |
|||
dict.Add(AvaloniaPropertyRegistry.Instance.FindRegistered(_entries[i].PropertyId), _entries[i].Value); |
|||
} |
|||
|
|||
return dict; |
|||
} |
|||
|
|||
private struct Entry |
|||
{ |
|||
internal int PropertyId; |
|||
internal TValue Value; |
|||
} |
|||
} |
|||
} |
|||
@ -1,168 +1,122 @@ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
// Copyright (c) The Avalonia Project. All rights reserved.
|
|||
// Licensed under the MIT license. See licence.md file in the project root for full license information.
|
|||
|
|||
using System; |
|||
|
|||
namespace Avalonia.Utilities |
|||
{ |
|||
/// <summary>
|
|||
/// Callback invoked when deferred setter wants to set a value.
|
|||
/// </summary>
|
|||
/// <typeparam name="TValue">Value type.</typeparam>
|
|||
/// <param name="property">Property being set.</param>
|
|||
/// <param name="backing">Backing field reference.</param>
|
|||
/// <param name="value">New value.</param>
|
|||
internal delegate void SetAndNotifyCallback<TValue>(AvaloniaProperty property, ref TValue backing, TValue value); |
|||
|
|||
/// <summary>
|
|||
/// A utility class to enable deferring assignment until after property-changed notifications are sent.
|
|||
/// Used to fix #855.
|
|||
/// </summary>
|
|||
/// <typeparam name="TSetRecord">The type of value with which to track the delayed assignment.</typeparam>
|
|||
class DeferredSetter<TSetRecord> |
|||
internal sealed class DeferredSetter<TSetRecord> |
|||
{ |
|||
private struct NotifyDisposable : IDisposable |
|||
private readonly SingleOrQueue<TSetRecord> _pendingValues; |
|||
private bool _isNotifying; |
|||
|
|||
public DeferredSetter() |
|||
{ |
|||
private readonly SettingStatus status; |
|||
_pendingValues = new SingleOrQueue<TSetRecord>(); |
|||
} |
|||
|
|||
internal NotifyDisposable(SettingStatus status) |
|||
{ |
|||
this.status = status; |
|||
status.Notifying = true; |
|||
} |
|||
private static void SetAndRaisePropertyChanged(AvaloniaObject source, AvaloniaProperty<TSetRecord> property, ref TSetRecord backing, TSetRecord value) |
|||
{ |
|||
var old = backing; |
|||
|
|||
public void Dispose() |
|||
{ |
|||
status.Notifying = false; |
|||
} |
|||
backing = value; |
|||
|
|||
source.RaisePropertyChanged(property, old, value); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Information on current setting/notification status of a property.
|
|||
/// </summary>
|
|||
private class SettingStatus |
|||
public bool SetAndNotify( |
|||
AvaloniaObject source, |
|||
AvaloniaProperty<TSetRecord> property, |
|||
ref TSetRecord backing, |
|||
TSetRecord value) |
|||
{ |
|||
public bool Notifying { get; set; } |
|||
|
|||
private SingleOrQueue<TSetRecord> pendingValues; |
|||
|
|||
public SingleOrQueue<TSetRecord> PendingValues |
|||
if (!_isNotifying) |
|||
{ |
|||
get |
|||
using (new NotifyDisposable(this)) |
|||
{ |
|||
return pendingValues ?? (pendingValues = new SingleOrQueue<TSetRecord>()); |
|||
SetAndRaisePropertyChanged(source, property, ref backing, value); |
|||
} |
|||
} |
|||
} |
|||
|
|||
private Dictionary<AvaloniaProperty, SettingStatus> _setRecords; |
|||
private Dictionary<AvaloniaProperty, SettingStatus> SetRecords |
|||
=> _setRecords ?? (_setRecords = new Dictionary<AvaloniaProperty, SettingStatus>()); |
|||
if (!_pendingValues.Empty) |
|||
{ |
|||
using (new NotifyDisposable(this)) |
|||
{ |
|||
while (!_pendingValues.Empty) |
|||
{ |
|||
SetAndRaisePropertyChanged(source, property, ref backing, _pendingValues.Dequeue()); |
|||
} |
|||
} |
|||
} |
|||
|
|||
private SettingStatus GetOrCreateStatus(AvaloniaProperty property) |
|||
{ |
|||
if (!SetRecords.TryGetValue(property, out var status)) |
|||
{ |
|||
status = new SettingStatus(); |
|||
SetRecords.Add(property, status); |
|||
return true; |
|||
} |
|||
|
|||
return status; |
|||
_pendingValues.Enqueue(value); |
|||
|
|||
return false; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Mark the property as currently notifying.
|
|||
/// </summary>
|
|||
/// <param name="property">The property to mark as notifying.</param>
|
|||
/// <returns>Returns a disposable that when disposed, marks the property as done notifying.</returns>
|
|||
private NotifyDisposable MarkNotifying(AvaloniaProperty property) |
|||
public bool SetAndNotifyCallback<TValue>(AvaloniaProperty property, SetAndNotifyCallback<TValue> setAndNotifyCallback, ref TValue backing, TValue value) |
|||
where TValue : TSetRecord |
|||
{ |
|||
Contract.Requires<InvalidOperationException>(!IsNotifying(property)); |
|||
|
|||
SettingStatus status = GetOrCreateStatus(property); |
|||
|
|||
return new NotifyDisposable(status); |
|||
} |
|||
if (!_isNotifying) |
|||
{ |
|||
using (new NotifyDisposable(this)) |
|||
{ |
|||
setAndNotifyCallback(property, ref backing, value); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Check if the property is currently notifying listeners.
|
|||
/// </summary>
|
|||
/// <param name="property">The property.</param>
|
|||
/// <returns>If the property is currently notifying listeners.</returns>
|
|||
private bool IsNotifying(AvaloniaProperty property) |
|||
=> SetRecords.TryGetValue(property, out var value) && value.Notifying; |
|||
if (!_pendingValues.Empty) |
|||
{ |
|||
using (new NotifyDisposable(this)) |
|||
{ |
|||
while (!_pendingValues.Empty) |
|||
{ |
|||
setAndNotifyCallback(property, ref backing, (TValue) _pendingValues.Dequeue()); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Add a pending assignment for the property.
|
|||
/// </summary>
|
|||
/// <param name="property">The property.</param>
|
|||
/// <param name="value">The value to assign.</param>
|
|||
private void AddPendingSet(AvaloniaProperty property, TSetRecord value) |
|||
{ |
|||
Contract.Requires<InvalidOperationException>(IsNotifying(property)); |
|||
return true; |
|||
} |
|||
|
|||
GetOrCreateStatus(property).PendingValues.Enqueue(value); |
|||
} |
|||
_pendingValues.Enqueue(value); |
|||
|
|||
/// <summary>
|
|||
/// Checks if there are any pending assignments for the property.
|
|||
/// </summary>
|
|||
/// <param name="property">The property to check.</param>
|
|||
/// <returns>If the property has any pending assignments.</returns>
|
|||
private bool HasPendingSet(AvaloniaProperty property) |
|||
{ |
|||
return SetRecords.TryGetValue(property, out var status) && !status.PendingValues.Empty; |
|||
return false; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the first pending assignment for the property.
|
|||
/// Disposable that marks the property as currently notifying.
|
|||
/// When disposed, marks the property as done notifying.
|
|||
/// </summary>
|
|||
/// <param name="property">The property to check.</param>
|
|||
/// <returns>The first pending assignment for the property.</returns>
|
|||
private TSetRecord GetFirstPendingSet(AvaloniaProperty property) |
|||
private readonly struct NotifyDisposable : IDisposable |
|||
{ |
|||
return GetOrCreateStatus(property).PendingValues.Dequeue(); |
|||
} |
|||
|
|||
public delegate bool SetterDelegate<TValue>(TSetRecord record, ref TValue backing, Action<Action> notifyCallback); |
|||
private readonly DeferredSetter<TSetRecord> _setter; |
|||
|
|||
/// <summary>
|
|||
/// Set the property and notify listeners while ensuring we don't get into a stack overflow as happens with #855 and #824
|
|||
/// </summary>
|
|||
/// <param name="property">The property to set.</param>
|
|||
/// <param name="backing">The backing field for the property</param>
|
|||
/// <param name="setterCallback">
|
|||
/// A callback that actually sets the property.
|
|||
/// The first parameter is the value to set, and the second is a wrapper that takes a callback that sends the property-changed notification.
|
|||
/// </param>
|
|||
/// <param name="value">The value to try to set.</param>
|
|||
public bool SetAndNotify<TValue>( |
|||
AvaloniaProperty property, |
|||
ref TValue backing, |
|||
SetterDelegate<TValue> setterCallback, |
|||
TSetRecord value) |
|||
{ |
|||
Contract.Requires<ArgumentNullException>(setterCallback != null); |
|||
if (!IsNotifying(property)) |
|||
internal NotifyDisposable(DeferredSetter<TSetRecord> setter) |
|||
{ |
|||
bool updated = false; |
|||
if (!object.Equals(value, backing)) |
|||
{ |
|||
updated = setterCallback(value, ref backing, notification => |
|||
{ |
|||
using (MarkNotifying(property)) |
|||
{ |
|||
notification(); |
|||
} |
|||
}); |
|||
} |
|||
while (HasPendingSet(property)) |
|||
{ |
|||
updated |= setterCallback(GetFirstPendingSet(property), ref backing, notification => |
|||
{ |
|||
using (MarkNotifying(property)) |
|||
{ |
|||
notification(); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
return updated; |
|||
_setter = setter; |
|||
_setter._isNotifying = true; |
|||
} |
|||
else if(!object.Equals(value, backing)) |
|||
|
|||
public void Dispose() |
|||
{ |
|||
AddPendingSet(property, value); |
|||
_setter._isNotifying = false; |
|||
} |
|||
return false; |
|||
} |
|||
} |
|||
} |
|||
|
|||
@ -0,0 +1,9 @@ |
|||
namespace Avalonia.Controls |
|||
{ |
|||
public interface IScrollAnchorProvider |
|||
{ |
|||
IControl CurrentAnchor { get; } |
|||
void RegisterAnchorCandidate(IControl element); |
|||
void UnregisterAnchorCandidate(IControl element); |
|||
} |
|||
} |
|||
@ -1,42 +0,0 @@ |
|||
// Copyright (c) The Avalonia Project. All rights reserved.
|
|||
// Licensed under the MIT license. See licence.md file in the project root for full license information.
|
|||
|
|||
using Avalonia.LogicalTree; |
|||
|
|||
namespace Avalonia.Controls.Primitives |
|||
{ |
|||
public class AdornerDecorator : Decorator |
|||
{ |
|||
public AdornerDecorator() |
|||
{ |
|||
AdornerLayer = new AdornerLayer(); |
|||
((ISetLogicalParent)AdornerLayer).SetParent(this); |
|||
AdornerLayer.ZIndex = int.MaxValue; |
|||
VisualChildren.Add(AdornerLayer); |
|||
} |
|||
|
|||
protected override void OnAttachedToLogicalTree(LogicalTreeAttachmentEventArgs e) |
|||
{ |
|||
base.OnAttachedToLogicalTree(e); |
|||
|
|||
((ILogical)AdornerLayer).NotifyAttachedToLogicalTree(e); |
|||
} |
|||
|
|||
public AdornerLayer AdornerLayer |
|||
{ |
|||
get; |
|||
} |
|||
|
|||
protected override Size MeasureOverride(Size availableSize) |
|||
{ |
|||
AdornerLayer.Measure(availableSize); |
|||
return base.MeasureOverride(availableSize); |
|||
} |
|||
|
|||
protected override Size ArrangeOverride(Size finalSize) |
|||
{ |
|||
AdornerLayer.Arrange(new Rect(finalSize)); |
|||
return base.ArrangeOverride(finalSize); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,26 @@ |
|||
using System; |
|||
using Avalonia.Controls.Presenters; |
|||
using Avalonia.Controls.Primitives.PopupPositioning; |
|||
using Avalonia.VisualTree; |
|||
|
|||
namespace Avalonia.Controls.Primitives |
|||
{ |
|||
public interface IPopupHost : IDisposable |
|||
{ |
|||
void SetChild(IControl control); |
|||
IContentPresenter Presenter { get; } |
|||
IVisual HostedVisualTreeRoot { get; } |
|||
|
|||
event EventHandler<TemplateAppliedEventArgs> TemplateApplied; |
|||
|
|||
void ConfigurePosition(IVisual target, PlacementMode placement, Point offset, |
|||
PopupPositioningEdge anchor = PopupPositioningEdge.None, |
|||
PopupPositioningEdge gravity = PopupPositioningEdge.None); |
|||
void Show(); |
|||
void Hide(); |
|||
IDisposable BindConstraints(AvaloniaObject popup, StyledProperty<double> widthProperty, |
|||
StyledProperty<double> minWidthProperty, StyledProperty<double> maxWidthProperty, |
|||
StyledProperty<double> heightProperty, StyledProperty<double> minHeightProperty, |
|||
StyledProperty<double> maxHeightProperty, StyledProperty<bool> topmostProperty); |
|||
} |
|||
} |
|||
@ -0,0 +1,38 @@ |
|||
using System.Linq; |
|||
using Avalonia.Rendering; |
|||
using Avalonia.VisualTree; |
|||
|
|||
namespace Avalonia.Controls.Primitives |
|||
{ |
|||
public class OverlayLayer : Canvas, ICustomSimpleHitTest |
|||
{ |
|||
public Size AvailableSize { get; private set; } |
|||
public static OverlayLayer GetOverlayLayer(IVisual visual) |
|||
{ |
|||
foreach(var v in visual.GetVisualAncestors()) |
|||
if(v is VisualLayerManager vlm) |
|||
if (vlm.OverlayLayer != null) |
|||
return vlm.OverlayLayer; |
|||
if (visual is TopLevel tl) |
|||
{ |
|||
var layers = tl.GetVisualDescendants().OfType<VisualLayerManager>().FirstOrDefault(); |
|||
return layers?.OverlayLayer; |
|||
} |
|||
|
|||
return null; |
|||
} |
|||
|
|||
public bool HitTest(Point point) |
|||
{ |
|||
return Children.Any(ctrl => ctrl.TransformedBounds?.Contains(point) == true); |
|||
} |
|||
|
|||
protected override Size ArrangeOverride(Size finalSize) |
|||
{ |
|||
// We are saving it here since child controls might need to know the entire size of the overlay
|
|||
// and Bounds won't be updated in time
|
|||
AvailableSize = finalSize; |
|||
return base.ArrangeOverride(finalSize); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,149 @@ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Reactive.Disposables; |
|||
using Avalonia.Controls.Primitives.PopupPositioning; |
|||
using Avalonia.Interactivity; |
|||
using Avalonia.Media; |
|||
using Avalonia.Threading; |
|||
using Avalonia.VisualTree; |
|||
|
|||
namespace Avalonia.Controls.Primitives |
|||
{ |
|||
public class OverlayPopupHost : ContentControl, IPopupHost, IInteractive, IManagedPopupPositionerPopup |
|||
{ |
|||
private readonly OverlayLayer _overlayLayer; |
|||
private PopupPositionerParameters _positionerParameters = new PopupPositionerParameters(); |
|||
private ManagedPopupPositioner _positioner; |
|||
private Point _lastRequestedPosition; |
|||
private bool _shown; |
|||
|
|||
public OverlayPopupHost(OverlayLayer overlayLayer) |
|||
{ |
|||
_overlayLayer = overlayLayer; |
|||
_positioner = new ManagedPopupPositioner(this); |
|||
} |
|||
|
|||
public void SetChild(IControl control) |
|||
{ |
|||
Content = control; |
|||
} |
|||
|
|||
public IVisual HostedVisualTreeRoot => null; |
|||
|
|||
/// <inheritdoc/>
|
|||
IInteractive IInteractive.InteractiveParent => Parent; |
|||
|
|||
public void Dispose() => Hide(); |
|||
|
|||
|
|||
public void Show() |
|||
{ |
|||
_overlayLayer.Children.Add(this); |
|||
_shown = true; |
|||
} |
|||
|
|||
public void Hide() |
|||
{ |
|||
_overlayLayer.Children.Remove(this); |
|||
_shown = false; |
|||
} |
|||
|
|||
public IDisposable BindConstraints(AvaloniaObject popup, StyledProperty<double> widthProperty, StyledProperty<double> minWidthProperty, |
|||
StyledProperty<double> maxWidthProperty, StyledProperty<double> heightProperty, StyledProperty<double> minHeightProperty, |
|||
StyledProperty<double> maxHeightProperty, StyledProperty<bool> topmostProperty) |
|||
{ |
|||
// Topmost property is not supported
|
|||
var bindings = new List<IDisposable>(); |
|||
|
|||
void Bind(AvaloniaProperty what, AvaloniaProperty to) => bindings.Add(this.Bind(what, popup[~to])); |
|||
Bind(WidthProperty, widthProperty); |
|||
Bind(MinWidthProperty, minWidthProperty); |
|||
Bind(MaxWidthProperty, maxWidthProperty); |
|||
Bind(HeightProperty, heightProperty); |
|||
Bind(MinHeightProperty, minHeightProperty); |
|||
Bind(MaxHeightProperty, maxHeightProperty); |
|||
|
|||
return Disposable.Create(() => |
|||
{ |
|||
foreach (var x in bindings) |
|||
x.Dispose(); |
|||
}); |
|||
} |
|||
|
|||
public void ConfigurePosition(IVisual target, PlacementMode placement, Point offset, |
|||
PopupPositioningEdge anchor = PopupPositioningEdge.None, PopupPositioningEdge gravity = PopupPositioningEdge.None) |
|||
{ |
|||
_positionerParameters.ConfigurePosition((TopLevel)_overlayLayer.GetVisualRoot(), target, placement, offset, anchor, |
|||
gravity); |
|||
UpdatePosition(); |
|||
} |
|||
|
|||
protected override Size ArrangeOverride(Size finalSize) |
|||
{ |
|||
if (_positionerParameters.Size != finalSize) |
|||
{ |
|||
_positionerParameters.Size = finalSize; |
|||
UpdatePosition(); |
|||
} |
|||
return base.ArrangeOverride(finalSize); |
|||
} |
|||
|
|||
|
|||
private void UpdatePosition() |
|||
{ |
|||
// Don't bother the positioner with layout system artifacts
|
|||
if (_positionerParameters.Size.Width == 0 || _positionerParameters.Size.Height == 0) |
|||
return; |
|||
if (_shown) |
|||
{ |
|||
_positioner.Update(_positionerParameters); |
|||
} |
|||
} |
|||
|
|||
IReadOnlyList<ManagedPopupPositionerScreenInfo> IManagedPopupPositionerPopup.Screens |
|||
{ |
|||
get |
|||
{ |
|||
var rc = new Rect(default, _overlayLayer.AvailableSize); |
|||
return new[] {new ManagedPopupPositionerScreenInfo(rc, rc)}; |
|||
} |
|||
} |
|||
|
|||
Rect IManagedPopupPositionerPopup.ParentClientAreaScreenGeometry => |
|||
new Rect(default, _overlayLayer.Bounds.Size); |
|||
|
|||
void IManagedPopupPositionerPopup.MoveAndResize(Point devicePoint, Size virtualSize) |
|||
{ |
|||
_lastRequestedPosition = devicePoint; |
|||
Dispatcher.UIThread.Post(() => |
|||
{ |
|||
OverlayLayer.SetLeft(this, _lastRequestedPosition.X); |
|||
OverlayLayer.SetTop(this, _lastRequestedPosition.Y); |
|||
}, DispatcherPriority.Layout); |
|||
} |
|||
|
|||
Point IManagedPopupPositionerPopup.TranslatePoint(Point pt) => pt; |
|||
|
|||
Size IManagedPopupPositionerPopup.TranslateSize(Size size) => size; |
|||
|
|||
public static IPopupHost CreatePopupHost(IVisual target, IAvaloniaDependencyResolver dependencyResolver) |
|||
{ |
|||
var platform = (target.GetVisualRoot() as TopLevel)?.PlatformImpl?.CreatePopup(); |
|||
if (platform != null) |
|||
return new PopupRoot((TopLevel)target.GetVisualRoot(), platform, dependencyResolver); |
|||
|
|||
var overlayLayer = OverlayLayer.GetOverlayLayer(target); |
|||
if (overlayLayer == null) |
|||
throw new InvalidOperationException( |
|||
"Unable to create IPopupImpl and no overlay layer is found for the target control"); |
|||
|
|||
|
|||
return new OverlayPopupHost(overlayLayer); |
|||
} |
|||
|
|||
public override void Render(DrawingContext context) |
|||
{ |
|||
context.FillRectangle(Brushes.White, new Rect(default, Bounds.Size)); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,358 @@ |
|||
// The documentation and flag names in this file are initially taken from
|
|||
// xdg_shell wayland protocol this API is designed after
|
|||
// therefore, I'm including the license from wayland-protocols repo
|
|||
|
|||
/* |
|||
Copyright © 2008-2013 Kristian Høgsberg |
|||
Copyright © 2010-2013 Intel Corporation |
|||
Copyright © 2013 Rafael Antognolli |
|||
Copyright © 2013 Jasper St. Pierre |
|||
Copyright © 2014 Jonas Ådahl |
|||
Copyright © 2014 Jason Ekstrand |
|||
Copyright © 2014-2015 Collabora, Ltd. |
|||
Copyright © 2015 Red Hat Inc. |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice (including the next |
|||
paragraph) shall be included in all copies or substantial portions of the |
|||
Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
|||
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
|
|||
--- |
|||
|
|||
The above is the version of the MIT "Expat" License used by X.org: |
|||
|
|||
http://cgit.freedesktop.org/xorg/xserver/tree/COPYING
|
|||
|
|||
|
|||
Adjustments for Avalonia needs: |
|||
Copyright © 2019 Nikita Tsukanov |
|||
|
|||
|
|||
*/ |
|||
|
|||
using System; |
|||
using Avalonia.VisualTree; |
|||
|
|||
namespace Avalonia.Controls.Primitives.PopupPositioning |
|||
{ |
|||
/// <summary>
|
|||
///
|
|||
/// The IPopupPositioner provides a collection of rules for the placement of a
|
|||
/// a popup relative to its parent. Rules can be defined to ensure
|
|||
/// the popup remains within the visible area's borders, and to
|
|||
/// specify how the popup changes its position, such as sliding along
|
|||
/// an axis, or flipping around a rectangle. These positioner-created rules are
|
|||
/// constrained by the requirement that a popup must intersect with or
|
|||
/// be at least partially adjacent to its parent surface.
|
|||
/// </summary>
|
|||
public struct PopupPositionerParameters |
|||
{ |
|||
private PopupPositioningEdge _gravity; |
|||
private PopupPositioningEdge _anchor; |
|||
|
|||
/// <summary>
|
|||
/// Set the size of the popup that is to be positioned with the positioner
|
|||
/// object. The size is in scaled coordinates.
|
|||
/// </summary>
|
|||
public Size Size { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Specify the anchor rectangle within the parent that the popup
|
|||
/// will be placed relative to. The rectangle is relative to the
|
|||
/// parent geometry
|
|||
///
|
|||
/// The anchor rectangle may not extend outside the window geometry of the
|
|||
/// popup's parent. The anchor rectangle is in scaled coordinates
|
|||
/// </summary>
|
|||
public Rect AnchorRectangle { get; set; } |
|||
|
|||
|
|||
/// <summary>
|
|||
/// Defines the anchor point for the anchor rectangle. The specified anchor
|
|||
/// is used derive an anchor point that the popup will be
|
|||
/// positioned relative to. If a corner anchor is set (e.g. 'TopLeft' or
|
|||
/// 'BottomRight'), the anchor point will be at the specified corner;
|
|||
/// otherwise, the derived anchor point will be centered on the specified
|
|||
/// edge, or in the center of the anchor rectangle if no edge is specified.
|
|||
/// </summary>
|
|||
public PopupPositioningEdge Anchor |
|||
{ |
|||
get => _anchor; |
|||
set |
|||
{ |
|||
PopupPositioningEdgeHelper.ValidateEdge(value); |
|||
_anchor = value; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Defines in what direction a popup should be positioned, relative to
|
|||
/// the anchor point of the parent. If a corner gravity is
|
|||
/// specified (e.g. 'BottomRight' or 'TopLeft'), then the popup
|
|||
/// will be placed towards the specified gravity; otherwise, the popup
|
|||
/// will be centered over the anchor point on any axis that had no
|
|||
/// gravity specified.
|
|||
/// </summary>
|
|||
public PopupPositioningEdge Gravity |
|||
{ |
|||
get => _gravity; |
|||
set |
|||
{ |
|||
PopupPositioningEdgeHelper.ValidateEdge(value); |
|||
_gravity = value; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Specify how the popup should be positioned if the originally intended
|
|||
/// position caused the popup to be constrained, meaning at least
|
|||
/// partially outside positioning boundaries set by the positioner. The
|
|||
/// adjustment is set by constructing a bitmask describing the adjustment to
|
|||
/// be made when the popup is constrained on that axis.
|
|||
///
|
|||
/// If no bit for one axis is set, the positioner will assume that the child
|
|||
/// surface should not change its position on that axis when constrained.
|
|||
///
|
|||
/// If more than one bit for one axis is set, the order of how adjustments
|
|||
/// are applied is specified in the corresponding adjustment descriptions.
|
|||
///
|
|||
/// The default adjustment is none.
|
|||
/// </summary>
|
|||
public PopupPositionerConstraintAdjustment ConstraintAdjustment { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Specify the popup position offset relative to the position of the
|
|||
/// anchor on the anchor rectangle and the anchor on the popup. For
|
|||
/// example if the anchor of the anchor rectangle is at (x, y), the popup
|
|||
/// has the gravity bottom|right, and the offset is (ox, oy), the calculated
|
|||
/// surface position will be (x + ox, y + oy). The offset position of the
|
|||
/// surface is the one used for constraint testing. See
|
|||
/// set_constraint_adjustment.
|
|||
///
|
|||
/// An example use case is placing a popup menu on top of a user interface
|
|||
/// element, while aligning the user interface element of the parent surface
|
|||
/// with some user interface element placed somewhere in the popup.
|
|||
/// </summary>
|
|||
public Point Offset { get; set; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// The constraint adjustment value define ways how popup position will
|
|||
/// be adjusted if the unadjusted position would result in the popup
|
|||
/// being partly constrained.
|
|||
///
|
|||
/// Whether a popup is considered 'constrained' is left to the positioner
|
|||
/// to determine. For example, the popup may be partly outside the
|
|||
/// target platform defined 'work area', thus necessitating the popup's
|
|||
/// position be adjusted until it is entirely inside the work area.
|
|||
/// </summary>
|
|||
[Flags] |
|||
public enum PopupPositionerConstraintAdjustment |
|||
{ |
|||
/// <summary>
|
|||
/// Don't alter the surface position even if it is constrained on some
|
|||
/// axis, for example partially outside the edge of an output.
|
|||
/// </summary>
|
|||
None = 0, |
|||
|
|||
/// <summary>
|
|||
/// Slide the surface along the x axis until it is no longer constrained.
|
|||
/// First try to slide towards the direction of the gravity on the x axis
|
|||
/// until either the edge in the opposite direction of the gravity is
|
|||
/// unconstrained or the edge in the direction of the gravity is
|
|||
/// constrained.
|
|||
///
|
|||
/// Then try to slide towards the opposite direction of the gravity on the
|
|||
/// x axis until either the edge in the direction of the gravity is
|
|||
/// unconstrained or the edge in the opposite direction of the gravity is
|
|||
/// constrained.
|
|||
/// </summary>
|
|||
SlideX = 1, |
|||
|
|||
|
|||
/// <summary>
|
|||
/// Slide the surface along the y axis until it is no longer constrained.
|
|||
///
|
|||
/// First try to slide towards the direction of the gravity on the y axis
|
|||
/// until either the edge in the opposite direction of the gravity is
|
|||
/// unconstrained or the edge in the direction of the gravity is
|
|||
/// constrained.
|
|||
///
|
|||
/// Then try to slide towards the opposite direction of the gravity on the
|
|||
/// y axis until either the edge in the direction of the gravity is
|
|||
/// unconstrained or the edge in the opposite direction of the gravity is
|
|||
/// constrained.
|
|||
/// */
|
|||
/// </summary>
|
|||
SlideY = 2, |
|||
|
|||
/// <summary>
|
|||
/// Invert the anchor and gravity on the x axis if the surface is
|
|||
/// constrained on the x axis. For example, if the left edge of the
|
|||
/// surface is constrained, the gravity is 'left' and the anchor is
|
|||
/// 'left', change the gravity to 'right' and the anchor to 'right'.
|
|||
///
|
|||
/// If the adjusted position also ends up being constrained, the resulting
|
|||
/// position of the flip_x adjustment will be the one before the
|
|||
/// adjustment.
|
|||
/// </summary>
|
|||
FlipX = 4, |
|||
|
|||
/// <summary>
|
|||
/// Invert the anchor and gravity on the y axis if the surface is
|
|||
/// constrained on the y axis. For example, if the bottom edge of the
|
|||
/// surface is constrained, the gravity is 'bottom' and the anchor is
|
|||
/// 'bottom', change the gravity to 'top' and the anchor to 'top'.
|
|||
///
|
|||
/// The adjusted position is calculated given the original anchor
|
|||
/// rectangle and offset, but with the new flipped anchor and gravity
|
|||
/// values.
|
|||
///
|
|||
/// If the adjusted position also ends up being constrained, the resulting
|
|||
/// position of the flip_y adjustment will be the one before the
|
|||
/// adjustment.
|
|||
/// </summary>
|
|||
FlipY = 8, |
|||
All = SlideX|SlideY|FlipX|FlipY |
|||
} |
|||
|
|||
static class PopupPositioningEdgeHelper |
|||
{ |
|||
public static void ValidateEdge(this PopupPositioningEdge edge) |
|||
{ |
|||
if (((edge & PopupPositioningEdge.Left) != 0 && (edge & PopupPositioningEdge.Right) != 0) |
|||
|| |
|||
((edge & PopupPositioningEdge.Top) != 0 && (edge & PopupPositioningEdge.Bottom) != 0)) |
|||
throw new ArgumentException("Opposite edges specified"); |
|||
} |
|||
|
|||
public static PopupPositioningEdge Flip(this PopupPositioningEdge edge) |
|||
{ |
|||
var hmask = PopupPositioningEdge.Left | PopupPositioningEdge.Right; |
|||
var vmask = PopupPositioningEdge.Top | PopupPositioningEdge.Bottom; |
|||
if ((edge & hmask) != 0) |
|||
edge ^= hmask; |
|||
if ((edge & vmask) != 0) |
|||
edge ^= vmask; |
|||
return edge; |
|||
} |
|||
|
|||
public static PopupPositioningEdge FlipX(this PopupPositioningEdge edge) |
|||
{ |
|||
if ((edge & PopupPositioningEdge.HorizontalMask) != 0) |
|||
edge ^= PopupPositioningEdge.HorizontalMask; |
|||
return edge; |
|||
} |
|||
|
|||
public static PopupPositioningEdge FlipY(this PopupPositioningEdge edge) |
|||
{ |
|||
if ((edge & PopupPositioningEdge.VerticalMask) != 0) |
|||
edge ^= PopupPositioningEdge.VerticalMask; |
|||
return edge; |
|||
} |
|||
|
|||
} |
|||
|
|||
[Flags] |
|||
public enum PopupPositioningEdge |
|||
{ |
|||
None, |
|||
Top = 1, |
|||
Bottom = 2, |
|||
Left = 4, |
|||
Right = 8, |
|||
TopLeft = Top | Left, |
|||
TopRight = Top | Right, |
|||
BottomLeft = Bottom | Left, |
|||
BottomRight = Bottom | Right, |
|||
|
|||
|
|||
VerticalMask = Top | Bottom, |
|||
HorizontalMask = Left | Right, |
|||
AllMask = VerticalMask|HorizontalMask |
|||
} |
|||
|
|||
public interface IPopupPositioner |
|||
{ |
|||
void Update(PopupPositionerParameters parameters); |
|||
} |
|||
|
|||
static class PopupPositionerExtensions |
|||
{ |
|||
public static void ConfigurePosition(ref this PopupPositionerParameters positionerParameters, |
|||
TopLevel topLevel, |
|||
IVisual target, PlacementMode placement, Point offset, |
|||
PopupPositioningEdge anchor, PopupPositioningEdge gravity) |
|||
{ |
|||
// We need a better way for tracking the last pointer position
|
|||
var pointer = topLevel.PointToClient(topLevel.PlatformImpl.MouseDevice.Position); |
|||
|
|||
positionerParameters.Offset = offset; |
|||
positionerParameters.ConstraintAdjustment = PopupPositionerConstraintAdjustment.All; |
|||
if (placement == PlacementMode.Pointer) |
|||
{ |
|||
positionerParameters.AnchorRectangle = new Rect(pointer, new Size(1, 1)); |
|||
positionerParameters.Anchor = PopupPositioningEdge.BottomRight; |
|||
positionerParameters.Gravity = PopupPositioningEdge.BottomRight; |
|||
} |
|||
else |
|||
{ |
|||
if (target == null) |
|||
throw new InvalidOperationException("Placement mode is not Pointer and PlacementTarget is null"); |
|||
var matrix = target.TransformToVisual(topLevel); |
|||
if (matrix == null) |
|||
{ |
|||
if (target.GetVisualRoot() == null) |
|||
throw new InvalidCastException("Target control is not attached to the visual tree"); |
|||
throw new InvalidCastException("Target control is not in the same tree as the popup parent"); |
|||
} |
|||
|
|||
positionerParameters.AnchorRectangle = new Rect(default, target.Bounds.Size) |
|||
.TransformToAABB(matrix.Value); |
|||
|
|||
if (placement == PlacementMode.Right) |
|||
{ |
|||
positionerParameters.Anchor = PopupPositioningEdge.TopRight; |
|||
positionerParameters.Gravity = PopupPositioningEdge.BottomRight; |
|||
} |
|||
else if (placement == PlacementMode.Bottom) |
|||
{ |
|||
positionerParameters.Anchor = PopupPositioningEdge.BottomLeft; |
|||
positionerParameters.Gravity = PopupPositioningEdge.BottomRight; |
|||
} |
|||
else if (placement == PlacementMode.Left) |
|||
{ |
|||
positionerParameters.Anchor = PopupPositioningEdge.TopLeft; |
|||
positionerParameters.Gravity = PopupPositioningEdge.BottomLeft; |
|||
} |
|||
else if (placement == PlacementMode.Top) |
|||
{ |
|||
positionerParameters.Anchor = PopupPositioningEdge.TopLeft; |
|||
positionerParameters.Gravity = PopupPositioningEdge.TopRight; |
|||
} |
|||
else if (placement == PlacementMode.AnchorAndGravity) |
|||
{ |
|||
positionerParameters.Anchor = anchor; |
|||
positionerParameters.Gravity = gravity; |
|||
} |
|||
else |
|||
throw new InvalidOperationException("Invalid value for Popup.PlacementMode"); |
|||
} |
|||
} |
|||
} |
|||
|
|||
} |
|||
@ -0,0 +1,175 @@ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
|
|||
namespace Avalonia.Controls.Primitives.PopupPositioning |
|||
{ |
|||
public interface IManagedPopupPositionerPopup |
|||
{ |
|||
IReadOnlyList<ManagedPopupPositionerScreenInfo> Screens { get; } |
|||
Rect ParentClientAreaScreenGeometry { get; } |
|||
void MoveAndResize(Point devicePoint, Size virtualSize); |
|||
Point TranslatePoint(Point pt); |
|||
Size TranslateSize(Size size); |
|||
} |
|||
|
|||
public class ManagedPopupPositionerScreenInfo |
|||
{ |
|||
public Rect Bounds { get; } |
|||
public Rect WorkingArea { get; } |
|||
|
|||
public ManagedPopupPositionerScreenInfo(Rect bounds, Rect workingArea) |
|||
{ |
|||
Bounds = bounds; |
|||
WorkingArea = workingArea; |
|||
} |
|||
} |
|||
|
|||
public class ManagedPopupPositioner : IPopupPositioner |
|||
{ |
|||
private readonly IManagedPopupPositionerPopup _popup; |
|||
|
|||
public ManagedPopupPositioner(IManagedPopupPositionerPopup popup) |
|||
{ |
|||
_popup = popup; |
|||
} |
|||
|
|||
|
|||
private static Point GetAnchorPoint(Rect anchorRect, PopupPositioningEdge edge) |
|||
{ |
|||
double x, y; |
|||
if ((edge & PopupPositioningEdge.Left) != 0) |
|||
x = anchorRect.X; |
|||
else if ((edge & PopupPositioningEdge.Right) != 0) |
|||
x = anchorRect.Right; |
|||
else |
|||
x = anchorRect.X + anchorRect.Width / 2; |
|||
|
|||
if ((edge & PopupPositioningEdge.Top) != 0) |
|||
y = anchorRect.Y; |
|||
else if ((edge & PopupPositioningEdge.Bottom) != 0) |
|||
y = anchorRect.Bottom; |
|||
else |
|||
y = anchorRect.Y + anchorRect.Height / 2; |
|||
return new Point(x, y); |
|||
} |
|||
|
|||
private static Point Gravitate(Point anchorPoint, Size size, PopupPositioningEdge gravity) |
|||
{ |
|||
double x, y; |
|||
if ((gravity & PopupPositioningEdge.Left) != 0) |
|||
x = -size.Width; |
|||
else if ((gravity & PopupPositioningEdge.Right) != 0) |
|||
x = 0; |
|||
else |
|||
x = -size.Width / 2; |
|||
|
|||
if ((gravity & PopupPositioningEdge.Top) != 0) |
|||
y = -size.Height; |
|||
else if ((gravity & PopupPositioningEdge.Bottom) != 0) |
|||
y = 0; |
|||
else |
|||
y = -size.Height / 2; |
|||
return anchorPoint + new Point(x, y); |
|||
} |
|||
|
|||
public void Update(PopupPositionerParameters parameters) |
|||
{ |
|||
|
|||
Update(_popup.TranslateSize(parameters.Size), parameters.Size, |
|||
new Rect(_popup.TranslatePoint(parameters.AnchorRectangle.TopLeft), |
|||
_popup.TranslateSize(parameters.AnchorRectangle.Size)), |
|||
parameters.Anchor, parameters.Gravity, parameters.ConstraintAdjustment, |
|||
_popup.TranslatePoint(parameters.Offset)); |
|||
} |
|||
|
|||
|
|||
private void Update(Size translatedSize, Size originalSize, |
|||
Rect anchorRect, PopupPositioningEdge anchor, PopupPositioningEdge gravity, |
|||
PopupPositionerConstraintAdjustment constraintAdjustment, Point offset) |
|||
{ |
|||
var parentGeometry = _popup.ParentClientAreaScreenGeometry; |
|||
anchorRect = anchorRect.Translate(parentGeometry.TopLeft); |
|||
|
|||
Rect GetBounds() |
|||
{ |
|||
var screens = _popup.Screens; |
|||
|
|||
var targetScreen = screens.FirstOrDefault(s => s.Bounds.Contains(anchorRect.TopLeft)) |
|||
?? screens.FirstOrDefault(s => s.Bounds.Intersects(anchorRect)) |
|||
?? screens.FirstOrDefault(s => s.Bounds.Contains(parentGeometry.TopLeft)) |
|||
?? screens.FirstOrDefault(s => s.Bounds.Intersects(parentGeometry)) |
|||
?? screens.FirstOrDefault(); |
|||
return targetScreen?.WorkingArea |
|||
?? new Rect(0, 0, double.MaxValue, double.MaxValue); |
|||
} |
|||
|
|||
var bounds = GetBounds(); |
|||
|
|||
bool FitsInBounds(Rect rc, PopupPositioningEdge edge = PopupPositioningEdge.AllMask) |
|||
{ |
|||
if ((edge & PopupPositioningEdge.Left) != 0 |
|||
&& rc.X < bounds.X) |
|||
return false; |
|||
|
|||
if ((edge & PopupPositioningEdge.Top) != 0 |
|||
&& rc.Y < bounds.Y) |
|||
return false; |
|||
|
|||
if ((edge & PopupPositioningEdge.Right) != 0 |
|||
&& rc.Right > bounds.Right) |
|||
return false; |
|||
|
|||
if ((edge & PopupPositioningEdge.Bottom) != 0 |
|||
&& rc.Bottom > bounds.Bottom) |
|||
return false; |
|||
|
|||
return true; |
|||
} |
|||
|
|||
Rect GetUnconstrained(PopupPositioningEdge a, PopupPositioningEdge g) => |
|||
new Rect(Gravitate(GetAnchorPoint(anchorRect, a), translatedSize, g) + offset, translatedSize); |
|||
|
|||
|
|||
var geo = GetUnconstrained(anchor, gravity); |
|||
|
|||
// If flipping geometry and anchor is allowed and helps, use the flipped one,
|
|||
// otherwise leave it as is
|
|||
if (!FitsInBounds(geo, PopupPositioningEdge.HorizontalMask) |
|||
&& (constraintAdjustment & PopupPositionerConstraintAdjustment.FlipX) != 0) |
|||
{ |
|||
var flipped = GetUnconstrained(anchor.FlipX(), gravity.FlipX()); |
|||
if (FitsInBounds(flipped, PopupPositioningEdge.HorizontalMask)) |
|||
geo = geo.WithX(flipped.X); |
|||
} |
|||
|
|||
// If sliding is allowed, try moving the rect into the bounds
|
|||
if ((constraintAdjustment & PopupPositionerConstraintAdjustment.SlideX) != 0) |
|||
{ |
|||
geo = geo.WithX(Math.Max(geo.X, bounds.X)); |
|||
if (geo.Right > bounds.Right) |
|||
geo = geo.WithX(bounds.Right - geo.Width); |
|||
} |
|||
|
|||
// If flipping geometry and anchor is allowed and helps, use the flipped one,
|
|||
// otherwise leave it as is
|
|||
if (!FitsInBounds(geo, PopupPositioningEdge.VerticalMask) |
|||
&& (constraintAdjustment & PopupPositionerConstraintAdjustment.FlipY) != 0) |
|||
{ |
|||
var flipped = GetUnconstrained(anchor.FlipY(), gravity.FlipY()); |
|||
if (FitsInBounds(flipped, PopupPositioningEdge.VerticalMask)) |
|||
geo = geo.WithY(flipped.Y); |
|||
} |
|||
|
|||
// If sliding is allowed, try moving the rect into the bounds
|
|||
if ((constraintAdjustment & PopupPositionerConstraintAdjustment.SlideY) != 0) |
|||
{ |
|||
geo = geo.WithY(Math.Max(geo.Y, bounds.Y)); |
|||
if (geo.Bottom > bounds.Bottom) |
|||
geo = geo.WithY(bounds.Bottom - geo.Height); |
|||
} |
|||
|
|||
_popup.MoveAndResize(geo.TopLeft, originalSize); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,50 @@ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
using Avalonia.Platform; |
|||
|
|||
namespace Avalonia.Controls.Primitives.PopupPositioning |
|||
{ |
|||
/// <summary>
|
|||
/// This class is used to simplify integration of IPopupImpl implementations with popup positioner
|
|||
/// </summary>
|
|||
public class ManagedPopupPositionerPopupImplHelper : IManagedPopupPositionerPopup |
|||
{ |
|||
private readonly IWindowBaseImpl _parent; |
|||
|
|||
public delegate void MoveResizeDelegate(PixelPoint position, Size size, double scaling); |
|||
private readonly MoveResizeDelegate _moveResize; |
|||
|
|||
public ManagedPopupPositionerPopupImplHelper(IWindowBaseImpl parent, MoveResizeDelegate moveResize) |
|||
{ |
|||
_parent = parent; |
|||
_moveResize = moveResize; |
|||
} |
|||
|
|||
public IReadOnlyList<ManagedPopupPositionerScreenInfo> Screens => |
|||
|
|||
_parent.Screen.AllScreens.Select(s => new ManagedPopupPositionerScreenInfo( |
|||
s.Bounds.ToRect(1), s.WorkingArea.ToRect(1))).ToList(); |
|||
|
|||
public Rect ParentClientAreaScreenGeometry |
|||
{ |
|||
get |
|||
{ |
|||
// Popup positioner operates with abstract coordinates, but in our case they are pixel ones
|
|||
var point = _parent.PointToScreen(default); |
|||
var size = PixelSize.FromSize(_parent.ClientSize, _parent.Scaling); |
|||
return new Rect(point.X, point.Y, size.Width, size.Height); |
|||
|
|||
} |
|||
} |
|||
|
|||
public void MoveAndResize(Point devicePoint, Size virtualSize) |
|||
{ |
|||
_moveResize(new PixelPoint((int)devicePoint.X, (int)devicePoint.Y), virtualSize, _parent.Scaling); |
|||
} |
|||
|
|||
public Point TranslatePoint(Point pt) => pt * _parent.Scaling; |
|||
|
|||
public Size TranslateSize(Size size) => size * _parent.Scaling; |
|||
} |
|||
} |
|||
@ -0,0 +1,93 @@ |
|||
using System.Collections.Generic; |
|||
using Avalonia.LogicalTree; |
|||
using Avalonia.Styling; |
|||
|
|||
namespace Avalonia.Controls.Primitives |
|||
{ |
|||
public class VisualLayerManager : Decorator |
|||
{ |
|||
private const int AdornerZIndex = int.MaxValue - 100; |
|||
private const int OverlayZIndex = int.MaxValue - 99; |
|||
private IStyleHost _styleRoot; |
|||
private readonly List<Control> _layers = new List<Control>(); |
|||
|
|||
|
|||
public bool IsPopup { get; set; } |
|||
|
|||
public AdornerLayer AdornerLayer |
|||
{ |
|||
get |
|||
{ |
|||
var rv = FindLayer<AdornerLayer>(); |
|||
if (rv == null) |
|||
AddLayer(rv = new AdornerLayer(), AdornerZIndex); |
|||
return rv; |
|||
} |
|||
} |
|||
|
|||
public OverlayLayer OverlayLayer |
|||
{ |
|||
get |
|||
{ |
|||
if (IsPopup) |
|||
return null; |
|||
var rv = FindLayer<OverlayLayer>(); |
|||
if(rv == null) |
|||
AddLayer(rv = new OverlayLayer(), OverlayZIndex); |
|||
return rv; |
|||
} |
|||
} |
|||
|
|||
T FindLayer<T>() where T : class |
|||
{ |
|||
foreach (var layer in _layers) |
|||
if (layer is T match) |
|||
return match; |
|||
return null; |
|||
} |
|||
|
|||
void AddLayer(Control layer, int zindex) |
|||
{ |
|||
_layers.Add(layer); |
|||
((ISetLogicalParent)layer).SetParent(this); |
|||
layer.ZIndex = zindex; |
|||
VisualChildren.Add(layer); |
|||
if (((ILogical)this).IsAttachedToLogicalTree) |
|||
((ILogical)layer).NotifyAttachedToLogicalTree(new LogicalTreeAttachmentEventArgs(_styleRoot)); |
|||
InvalidateArrange(); |
|||
} |
|||
|
|||
|
|||
protected override void OnAttachedToLogicalTree(LogicalTreeAttachmentEventArgs e) |
|||
{ |
|||
base.OnAttachedToLogicalTree(e); |
|||
_styleRoot = e.Root; |
|||
|
|||
foreach (var l in _layers) |
|||
((ILogical)l).NotifyAttachedToLogicalTree(e); |
|||
} |
|||
|
|||
protected override void OnDetachedFromLogicalTree(LogicalTreeAttachmentEventArgs e) |
|||
{ |
|||
_styleRoot = null; |
|||
base.OnDetachedFromLogicalTree(e); |
|||
foreach (var l in _layers) |
|||
((ILogical)l).NotifyDetachedFromLogicalTree(e); |
|||
} |
|||
|
|||
|
|||
protected override Size MeasureOverride(Size availableSize) |
|||
{ |
|||
foreach (var l in _layers) |
|||
l.Measure(availableSize); |
|||
return base.MeasureOverride(availableSize); |
|||
} |
|||
|
|||
protected override Size ArrangeOverride(Size finalSize) |
|||
{ |
|||
foreach (var l in _layers) |
|||
l.Arrange(new Rect(finalSize)); |
|||
return base.ArrangeOverride(finalSize); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,54 @@ |
|||
// This source file is adapted from the WinUI project.
|
|||
// (https://github.com/microsoft/microsoft-ui-xaml)
|
|||
//
|
|||
// Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation.
|
|||
|
|||
using Avalonia.Controls.Templates; |
|||
|
|||
namespace Avalonia.Controls |
|||
{ |
|||
internal class ItemTemplateWrapper |
|||
{ |
|||
private readonly IDataTemplate _dataTemplate; |
|||
|
|||
public ItemTemplateWrapper(IDataTemplate dataTemplate) => _dataTemplate = dataTemplate; |
|||
|
|||
public IControl GetElement(IControl parent, object data) |
|||
{ |
|||
var selectedTemplate = _dataTemplate; |
|||
var recyclePool = RecyclePool.GetPoolInstance(selectedTemplate); |
|||
IControl element = null; |
|||
|
|||
if (recyclePool != null) |
|||
{ |
|||
// try to get an element from the recycle pool.
|
|||
element = recyclePool.TryGetElement(string.Empty, parent); |
|||
} |
|||
|
|||
if (element == null) |
|||
{ |
|||
// no element was found in recycle pool, create a new element
|
|||
element = selectedTemplate.Build(data); |
|||
|
|||
// Associate template with element
|
|||
element.SetValue(RecyclePool.OriginTemplateProperty, selectedTemplate); |
|||
} |
|||
|
|||
return element; |
|||
} |
|||
|
|||
public void RecycleElement(IControl parent, IControl element) |
|||
{ |
|||
var selectedTemplate = _dataTemplate; |
|||
var recyclePool = RecyclePool.GetPoolInstance(selectedTemplate); |
|||
if (recyclePool == null) |
|||
{ |
|||
// No Recycle pool in the template, create one.
|
|||
recyclePool = new RecyclePool(); |
|||
RecyclePool.SetPoolInstance(selectedTemplate, recyclePool); |
|||
} |
|||
|
|||
recyclePool.PutElement(element, "" /* key */, parent); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,724 @@ |
|||
// This source file is adapted from the WinUI project.
|
|||
// (https://github.com/microsoft/microsoft-ui-xaml)
|
|||
//
|
|||
// Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation.
|
|||
|
|||
using System; |
|||
using System.Collections; |
|||
using System.Collections.Specialized; |
|||
using Avalonia.Controls.Templates; |
|||
using Avalonia.Input; |
|||
using Avalonia.Layout; |
|||
|
|||
namespace Avalonia.Controls |
|||
{ |
|||
/// <summary>
|
|||
/// Represents a data-driven collection control that incorporates a flexible layout system,
|
|||
/// custom views, and virtualization.
|
|||
/// </summary>
|
|||
public class ItemsRepeater : Panel |
|||
{ |
|||
/// <summary>
|
|||
/// Defines the <see cref="HorizontalCacheLength"/> property.
|
|||
/// </summary>
|
|||
public static readonly AvaloniaProperty<double> HorizontalCacheLengthProperty = |
|||
AvaloniaProperty.Register<ItemsRepeater, double>(nameof(HorizontalCacheLength), 2.0); |
|||
|
|||
/// <summary>
|
|||
/// Defines the <see cref="ItemTemplate"/> property.
|
|||
/// </summary>
|
|||
public static readonly StyledProperty<IDataTemplate> ItemTemplateProperty = |
|||
ItemsControl.ItemTemplateProperty.AddOwner<ItemsRepeater>(); |
|||
|
|||
/// <summary>
|
|||
/// Defines the <see cref="Items"/> property.
|
|||
/// </summary>
|
|||
public static readonly DirectProperty<ItemsRepeater, IEnumerable> ItemsProperty = |
|||
ItemsControl.ItemsProperty.AddOwner<ItemsRepeater>(o => o.Items, (o, v) => o.Items = v); |
|||
|
|||
/// <summary>
|
|||
/// Defines the <see cref="Layout"/> property.
|
|||
/// </summary>
|
|||
public static readonly AvaloniaProperty<AttachedLayout> LayoutProperty = |
|||
AvaloniaProperty.Register<ItemsRepeater, AttachedLayout>(nameof(Layout), new StackLayout()); |
|||
|
|||
/// <summary>
|
|||
/// Defines the <see cref="VerticalCacheLength"/> property.
|
|||
/// </summary>
|
|||
public static readonly AvaloniaProperty<double> VerticalCacheLengthProperty = |
|||
AvaloniaProperty.Register<ItemsRepeater, double>(nameof(VerticalCacheLength), 2.0); |
|||
|
|||
private static readonly AttachedProperty<VirtualizationInfo> VirtualizationInfoProperty = |
|||
AvaloniaProperty.RegisterAttached<ItemsRepeater, IControl, VirtualizationInfo>("VirtualizationInfo"); |
|||
|
|||
internal static readonly Rect InvalidRect = new Rect(-1, -1, -1, -1); |
|||
internal static readonly Point ClearedElementsArrangePosition = new Point(-10000.0, -10000.0); |
|||
|
|||
private readonly ViewManager _viewManager; |
|||
private readonly ViewportManager _viewportManager; |
|||
private IEnumerable _items; |
|||
private VirtualizingLayoutContext _layoutContext; |
|||
private NotifyCollectionChangedEventArgs _processingItemsSourceChange; |
|||
private bool _isLayoutInProgress; |
|||
private ItemsRepeaterElementPreparedEventArgs _elementPreparedArgs; |
|||
private ItemsRepeaterElementClearingEventArgs _elementClearingArgs; |
|||
private ItemsRepeaterElementIndexChangedEventArgs _elementIndexChangedArgs; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="ItemsRepeater"/> class.
|
|||
/// </summary>
|
|||
public ItemsRepeater() |
|||
{ |
|||
_viewManager = new ViewManager(this); |
|||
_viewportManager = new ViewportManager(this); |
|||
KeyboardNavigation.SetTabNavigation(this, KeyboardNavigationMode.Once); |
|||
OnLayoutChanged(null, Layout); |
|||
} |
|||
|
|||
static ItemsRepeater() |
|||
{ |
|||
ClipToBoundsProperty.OverrideDefaultValue<ItemsRepeater>(true); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the layout used to size and position elements in the ItemsRepeater.
|
|||
/// </summary>
|
|||
/// <value>
|
|||
/// The layout used to size and position elements. The default is a StackLayout with
|
|||
/// vertical orientation.
|
|||
/// </value>
|
|||
public AttachedLayout Layout |
|||
{ |
|||
get => GetValue(LayoutProperty); |
|||
set => SetValue(LayoutProperty, value); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets an object source used to generate the content of the ItemsRepeater.
|
|||
/// </summary>
|
|||
public IEnumerable Items |
|||
{ |
|||
get => _items; |
|||
set => SetAndRaise(ItemsProperty, ref _items, value); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the template used to display each item.
|
|||
/// </summary>
|
|||
public IDataTemplate ItemTemplate |
|||
{ |
|||
get => GetValue(ItemTemplateProperty); |
|||
set => SetValue(ItemTemplateProperty, value); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets a value that indicates the size of the buffer used to realize items when
|
|||
/// panning or scrolling horizontally.
|
|||
/// </summary>
|
|||
public double HorizontalCacheLength |
|||
{ |
|||
get => GetValue(HorizontalCacheLengthProperty); |
|||
set => SetValue(HorizontalCacheLengthProperty, value); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets a value that indicates the size of the buffer used to realize items when
|
|||
/// panning or scrolling vertically.
|
|||
/// </summary>
|
|||
public double VerticalCacheLength |
|||
{ |
|||
get => GetValue(VerticalCacheLengthProperty); |
|||
set => SetValue(VerticalCacheLengthProperty, value); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a standardized view of the supported interactions between a given Items object and
|
|||
/// the ItemsRepeater control and its associated components.
|
|||
/// </summary>
|
|||
public ItemsSourceView ItemsSourceView { get; private set; } |
|||
|
|||
internal ItemTemplateWrapper ItemTemplateShim { get; set; } |
|||
internal Point LayoutOrigin { get; set; } |
|||
internal object LayoutState { get; set; } |
|||
internal IControl MadeAnchor => _viewportManager.MadeAnchor; |
|||
internal Rect RealizationWindow => _viewportManager.GetLayoutRealizationWindow(); |
|||
internal IControl SuggestedAnchor => _viewportManager.SuggestedAnchor; |
|||
|
|||
private bool IsProcessingCollectionChange => _processingItemsSourceChange != null; |
|||
|
|||
private LayoutContext LayoutContext |
|||
{ |
|||
get |
|||
{ |
|||
if (_layoutContext == null) |
|||
{ |
|||
_layoutContext = new RepeaterLayoutContext(this); |
|||
} |
|||
|
|||
return _layoutContext; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Occurs each time an element is cleared and made available to be re-used.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This event is raised immediately each time an element is cleared, such as when it falls
|
|||
/// outside the range of realized items. Elements are cleared when they become available
|
|||
/// for re-use.
|
|||
/// </remarks>
|
|||
public event EventHandler<ItemsRepeaterElementClearingEventArgs> ElementClearing; |
|||
|
|||
/// <summary>
|
|||
/// Occurs for each realized <see cref="IControl"/> when the index for the item it
|
|||
/// represents has changed.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// When you use ItemsRepeater to build a more complex control that supports specific
|
|||
/// interactions on the child elements (such as selection or click), it is useful to be
|
|||
/// able to keep an up-to-date identifier for the backing data item.
|
|||
///
|
|||
/// This event is raised for each realized IControl where the index for the item it
|
|||
/// represents has changed. For example, when another item is added or removed in the data
|
|||
/// source, the index for items that come after in the ordering will be impacted.
|
|||
/// </remarks>
|
|||
public event EventHandler<ItemsRepeaterElementIndexChangedEventArgs> ElementIndexChanged; |
|||
|
|||
/// <summary>
|
|||
/// Occurs each time an element is prepared for use.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// The prepared element might be newly created or an existing element that is being re-
|
|||
/// used.
|
|||
/// </remarks>
|
|||
public event EventHandler<ItemsRepeaterElementPreparedEventArgs> ElementPrepared; |
|||
|
|||
/// <summary>
|
|||
/// Retrieves the index of the item from the data source that corresponds to the specified
|
|||
/// <see cref="IControl"/>.
|
|||
/// </summary>
|
|||
/// <param name="element">
|
|||
/// The element that corresponds to the item to get the index of.
|
|||
/// </param>
|
|||
/// <returns>
|
|||
/// The index of the item from the data source that corresponds to the specified UIElement,
|
|||
/// or -1 if the element is not supported.
|
|||
/// </returns>
|
|||
public int GetElementIndex(IControl element) => GetElementIndexImpl(element); |
|||
|
|||
/// <summary>
|
|||
/// Retrieves the realized UIElement that corresponds to the item at the specified index in
|
|||
/// the data source.
|
|||
/// </summary>
|
|||
/// <param name="index">The index of the item.</param>
|
|||
/// <returns>
|
|||
/// he UIElement that corresponds to the item at the specified index if the item is
|
|||
/// realized, or null if the item is not realized.
|
|||
/// </returns>
|
|||
public IControl TryGetElement(int index) => GetElementFromIndexImpl(index); |
|||
|
|||
internal void PinElement(IControl element) => _viewManager.UpdatePin(element, true); |
|||
|
|||
internal void UnpinElement(IControl element) => _viewManager.UpdatePin(element, false); |
|||
|
|||
internal IControl GetOrCreateElement(int index) => GetOrCreateElementImpl(index); |
|||
|
|||
internal static VirtualizationInfo TryGetVirtualizationInfo(IControl element) |
|||
{ |
|||
var value = element.GetValue(VirtualizationInfoProperty); |
|||
return value; |
|||
} |
|||
|
|||
internal static VirtualizationInfo CreateAndInitializeVirtualizationInfo(IControl element) |
|||
{ |
|||
if (TryGetVirtualizationInfo(element) != null) |
|||
{ |
|||
throw new InvalidOperationException("VirtualizationInfo already created."); |
|||
} |
|||
|
|||
var result = new VirtualizationInfo(); |
|||
element.SetValue(VirtualizationInfoProperty, result); |
|||
return result; |
|||
} |
|||
|
|||
internal static VirtualizationInfo GetVirtualizationInfo(IControl element) |
|||
{ |
|||
var result = element.GetValue(VirtualizationInfoProperty); |
|||
|
|||
if (result == null) |
|||
{ |
|||
result = new VirtualizationInfo(); |
|||
element.SetValue(VirtualizationInfoProperty, result); |
|||
} |
|||
|
|||
return result; |
|||
} |
|||
|
|||
protected override Size MeasureOverride(Size availableSize) |
|||
{ |
|||
if (_isLayoutInProgress) |
|||
{ |
|||
throw new AvaloniaInternalException("Reentrancy detected during layout."); |
|||
} |
|||
|
|||
if (IsProcessingCollectionChange) |
|||
{ |
|||
throw new NotSupportedException("Cannot run layout in the middle of a collection change."); |
|||
} |
|||
|
|||
_viewportManager.OnOwnerMeasuring(); |
|||
|
|||
_isLayoutInProgress = true; |
|||
|
|||
try |
|||
{ |
|||
_viewManager.PrunePinnedElements(); |
|||
var extent = new Rect(); |
|||
var desiredSize = new Size(); |
|||
var layout = Layout; |
|||
|
|||
if (layout != null) |
|||
{ |
|||
var layoutContext = GetLayoutContext(); |
|||
|
|||
desiredSize = layout.Measure(layoutContext, availableSize); |
|||
extent = new Rect(LayoutOrigin.X, LayoutOrigin.Y, desiredSize.Width, desiredSize.Height); |
|||
|
|||
// Clear auto recycle candidate elements that have not been kept alive by layout - i.e layout did not
|
|||
// call GetElementAt(index).
|
|||
foreach (var element in Children) |
|||
{ |
|||
var virtInfo = GetVirtualizationInfo(element); |
|||
|
|||
if (virtInfo.Owner == ElementOwner.Layout && |
|||
virtInfo.AutoRecycleCandidate && |
|||
!virtInfo.KeepAlive) |
|||
{ |
|||
ClearElementImpl(element); |
|||
} |
|||
} |
|||
} |
|||
|
|||
_viewportManager.SetLayoutExtent(extent); |
|||
return desiredSize; |
|||
} |
|||
finally |
|||
{ |
|||
_isLayoutInProgress = false; |
|||
} |
|||
} |
|||
|
|||
protected override Size ArrangeOverride(Size finalSize) |
|||
{ |
|||
if (_isLayoutInProgress) |
|||
{ |
|||
throw new AvaloniaInternalException("Reentrancy detected during layout."); |
|||
} |
|||
|
|||
if (IsProcessingCollectionChange) |
|||
{ |
|||
throw new NotSupportedException("Cannot run layout in the middle of a collection change."); |
|||
} |
|||
|
|||
_isLayoutInProgress = true; |
|||
|
|||
try |
|||
{ |
|||
var arrangeSize = Layout?.Arrange(GetLayoutContext(), finalSize) ?? default; |
|||
|
|||
// The view manager might clear elements during this call.
|
|||
// That's why we call it before arranging cleared elements
|
|||
// off screen.
|
|||
_viewManager.OnOwnerArranged(); |
|||
|
|||
foreach (var element in Children) |
|||
{ |
|||
var virtInfo = GetVirtualizationInfo(element); |
|||
virtInfo.KeepAlive = false; |
|||
|
|||
if (virtInfo.Owner == ElementOwner.ElementFactory || |
|||
virtInfo.Owner == ElementOwner.PinnedPool) |
|||
{ |
|||
// Toss it away. And arrange it with size 0 so that XYFocus won't use it.
|
|||
element.Arrange(new Rect( |
|||
ClearedElementsArrangePosition.X - element.DesiredSize.Width, |
|||
ClearedElementsArrangePosition.Y - element.DesiredSize.Height, |
|||
0, |
|||
0)); |
|||
} |
|||
else |
|||
{ |
|||
var newBounds = element.Bounds; |
|||
virtInfo.ArrangeBounds = newBounds; |
|||
} |
|||
} |
|||
|
|||
_viewportManager.OnOwnerArranged(); |
|||
|
|||
return arrangeSize; |
|||
} |
|||
finally |
|||
{ |
|||
_isLayoutInProgress = false; |
|||
} |
|||
} |
|||
|
|||
protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e) |
|||
{ |
|||
InvalidateMeasure(); |
|||
_viewportManager.ResetScrollers(); |
|||
} |
|||
|
|||
protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e) |
|||
{ |
|||
_viewportManager.ResetScrollers(); |
|||
} |
|||
|
|||
protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs args) |
|||
{ |
|||
var property = args.Property; |
|||
|
|||
if (property == ItemsProperty) |
|||
{ |
|||
var newValue = (IEnumerable)args.NewValue; |
|||
var newDataSource = newValue as ItemsSourceView; |
|||
if (newValue != null && newDataSource == null) |
|||
{ |
|||
newDataSource = new ItemsSourceView(newValue); |
|||
} |
|||
|
|||
OnDataSourcePropertyChanged(ItemsSourceView, newDataSource); |
|||
} |
|||
else if (property == ItemTemplateProperty) |
|||
{ |
|||
OnItemTemplateChanged((IDataTemplate)args.OldValue, (IDataTemplate)args.NewValue); |
|||
} |
|||
else if (property == LayoutProperty) |
|||
{ |
|||
OnLayoutChanged((AttachedLayout)args.OldValue, (AttachedLayout)args.NewValue); |
|||
} |
|||
else if (property == HorizontalCacheLengthProperty) |
|||
{ |
|||
_viewportManager.HorizontalCacheLength = (double)args.NewValue; |
|||
} |
|||
else if (property == VerticalCacheLengthProperty) |
|||
{ |
|||
_viewportManager.VerticalCacheLength = (double)args.NewValue; |
|||
} |
|||
else |
|||
{ |
|||
base.OnPropertyChanged(args); |
|||
} |
|||
} |
|||
|
|||
internal IControl GetElementImpl(int index, bool forceCreate, bool supressAutoRecycle) |
|||
{ |
|||
var element = _viewManager.GetElement(index, forceCreate, supressAutoRecycle); |
|||
return element; |
|||
} |
|||
|
|||
internal void ClearElementImpl(IControl element) |
|||
{ |
|||
// Clearing an element due to a collection change
|
|||
// is more strict in that pinned elements will be forcibly
|
|||
// unpinned and sent back to the view generator.
|
|||
var isClearedDueToCollectionChange = |
|||
_processingItemsSourceChange != null && |
|||
(_processingItemsSourceChange.Action == NotifyCollectionChangedAction.Remove || |
|||
_processingItemsSourceChange.Action == NotifyCollectionChangedAction.Replace || |
|||
_processingItemsSourceChange.Action == NotifyCollectionChangedAction.Reset); |
|||
|
|||
_viewManager.ClearElement(element, isClearedDueToCollectionChange); |
|||
_viewportManager.OnElementCleared(element); |
|||
} |
|||
|
|||
private int GetElementIndexImpl(IControl element) |
|||
{ |
|||
var virtInfo = TryGetVirtualizationInfo(element); |
|||
return _viewManager.GetElementIndex(virtInfo); |
|||
} |
|||
|
|||
private IControl GetElementFromIndexImpl(int index) |
|||
{ |
|||
IControl result = null; |
|||
|
|||
var children = Children; |
|||
for (var i = 0; i < children.Count && result == null; ++i) |
|||
{ |
|||
var element = children[i]; |
|||
var virtInfo = TryGetVirtualizationInfo(element); |
|||
if (virtInfo?.IsRealized == true && virtInfo.Index == index) |
|||
{ |
|||
result = element; |
|||
} |
|||
} |
|||
|
|||
return result; |
|||
} |
|||
|
|||
private IControl GetOrCreateElementImpl(int index) |
|||
{ |
|||
if (index >= 0 && index >= ItemsSourceView.Count) |
|||
{ |
|||
throw new ArgumentException("Argument index is invalid.", "index"); |
|||
} |
|||
|
|||
if (_isLayoutInProgress) |
|||
{ |
|||
throw new NotSupportedException("GetOrCreateElement invocation is not allowed during layout."); |
|||
} |
|||
|
|||
var element = GetElementFromIndexImpl(index); |
|||
bool isAnchorOutsideRealizedRange = element == null; |
|||
|
|||
if (isAnchorOutsideRealizedRange) |
|||
{ |
|||
if (Layout == null) |
|||
{ |
|||
throw new InvalidOperationException("Cannot make an Anchor when there is no attached layout."); |
|||
} |
|||
|
|||
element = (IControl)GetLayoutContext().GetOrCreateElementAt(index); |
|||
element.Measure(Size.Infinity); |
|||
} |
|||
|
|||
_viewportManager.OnMakeAnchor(element, isAnchorOutsideRealizedRange); |
|||
InvalidateMeasure(); |
|||
|
|||
return element; |
|||
} |
|||
|
|||
internal void OnElementPrepared(IControl element, int index) |
|||
{ |
|||
_viewportManager.OnElementPrepared(element); |
|||
if (ElementPrepared != null) |
|||
{ |
|||
if (_elementPreparedArgs == null) |
|||
{ |
|||
_elementPreparedArgs = new ItemsRepeaterElementPreparedEventArgs(element, index); |
|||
} |
|||
else |
|||
{ |
|||
_elementPreparedArgs.Update(element, index); |
|||
} |
|||
|
|||
ElementPrepared(this, _elementPreparedArgs); |
|||
} |
|||
} |
|||
|
|||
internal void OnElementClearing(IControl element) |
|||
{ |
|||
if (ElementClearing != null) |
|||
{ |
|||
if (_elementClearingArgs == null) |
|||
{ |
|||
_elementClearingArgs = new ItemsRepeaterElementClearingEventArgs(element); |
|||
} |
|||
else |
|||
{ |
|||
_elementClearingArgs.Update(element); |
|||
} |
|||
|
|||
ElementClearing(this, _elementClearingArgs); |
|||
} |
|||
} |
|||
|
|||
internal void OnElementIndexChanged(IControl element, int oldIndex, int newIndex) |
|||
{ |
|||
if (ElementIndexChanged != null) |
|||
{ |
|||
if (_elementIndexChangedArgs == null) |
|||
{ |
|||
_elementIndexChangedArgs = new ItemsRepeaterElementIndexChangedEventArgs(element, oldIndex, newIndex); |
|||
} |
|||
else |
|||
{ |
|||
_elementIndexChangedArgs.Update(element, oldIndex, newIndex); |
|||
} |
|||
|
|||
ElementIndexChanged(this, _elementIndexChangedArgs); |
|||
} |
|||
} |
|||
|
|||
private void OnDataSourcePropertyChanged(ItemsSourceView oldValue, ItemsSourceView newValue) |
|||
{ |
|||
if (_isLayoutInProgress) |
|||
{ |
|||
throw new AvaloniaInternalException("Cannot set ItemsSourceView during layout."); |
|||
} |
|||
|
|||
ItemsSourceView?.Dispose(); |
|||
ItemsSourceView = newValue; |
|||
|
|||
if (oldValue != null) |
|||
{ |
|||
oldValue.CollectionChanged -= OnItemsSourceViewChanged; |
|||
} |
|||
|
|||
if (newValue != null) |
|||
{ |
|||
newValue.CollectionChanged += OnItemsSourceViewChanged; |
|||
} |
|||
|
|||
if (Layout != null) |
|||
{ |
|||
if (Layout is VirtualizingLayout virtualLayout) |
|||
{ |
|||
var args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset); |
|||
virtualLayout.OnItemsChanged(GetLayoutContext(), newValue, args); |
|||
} |
|||
else if (Layout is NonVirtualizingLayout nonVirtualLayout) |
|||
{ |
|||
// Walk through all the elements and make sure they are cleared for
|
|||
// non-virtualizing layouts.
|
|||
foreach (var element in Children) |
|||
{ |
|||
if (GetVirtualizationInfo(element).IsRealized) |
|||
{ |
|||
ClearElementImpl(element); |
|||
} |
|||
} |
|||
} |
|||
|
|||
InvalidateMeasure(); |
|||
} |
|||
} |
|||
|
|||
private void OnItemTemplateChanged(IDataTemplate oldValue, IDataTemplate newValue) |
|||
{ |
|||
if (_isLayoutInProgress && oldValue != null) |
|||
{ |
|||
throw new AvaloniaInternalException("ItemTemplate cannot be changed during layout."); |
|||
} |
|||
|
|||
// Since the ItemTemplate has changed, we need to re-evaluate all the items that
|
|||
// have already been created and are now in the tree. The easiest way to do that
|
|||
// would be to do a reset.. Note that this has to be done before we change the template
|
|||
// so that the cleared elements go back into the old template.
|
|||
if (Layout != null) |
|||
{ |
|||
if (Layout is VirtualizingLayout virtualLayout) |
|||
{ |
|||
var args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset); |
|||
_processingItemsSourceChange = args; |
|||
|
|||
try |
|||
{ |
|||
virtualLayout.OnItemsChanged(GetLayoutContext(), newValue, args); |
|||
} |
|||
finally |
|||
{ |
|||
_processingItemsSourceChange = null; |
|||
} |
|||
} |
|||
else if (Layout is NonVirtualizingLayout) |
|||
{ |
|||
// Walk through all the elements and make sure they are cleared for
|
|||
// non-virtualizing layouts.
|
|||
foreach (var element in Children) |
|||
{ |
|||
if (GetVirtualizationInfo(element).IsRealized) |
|||
{ |
|||
ClearElementImpl(element); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
ItemTemplateShim = new ItemTemplateWrapper(newValue); |
|||
|
|||
InvalidateMeasure(); |
|||
} |
|||
|
|||
private void OnLayoutChanged(AttachedLayout oldValue, AttachedLayout newValue) |
|||
{ |
|||
if (_isLayoutInProgress) |
|||
{ |
|||
throw new InvalidOperationException("Layout cannot be changed during layout."); |
|||
} |
|||
|
|||
_viewManager.OnLayoutChanging(); |
|||
|
|||
if (oldValue != null) |
|||
{ |
|||
oldValue.UninitializeForContext(LayoutContext); |
|||
oldValue.MeasureInvalidated -= InvalidateMeasureForLayout; |
|||
oldValue.ArrangeInvalidated -= InvalidateArrangeForLayout; |
|||
|
|||
// Walk through all the elements and make sure they are cleared
|
|||
foreach (var element in Children) |
|||
{ |
|||
if (GetVirtualizationInfo(element).IsRealized) |
|||
{ |
|||
ClearElementImpl(element); |
|||
} |
|||
} |
|||
|
|||
LayoutState = null; |
|||
} |
|||
|
|||
if (newValue != null) |
|||
{ |
|||
newValue.InitializeForContext(LayoutContext); |
|||
newValue.MeasureInvalidated += InvalidateMeasureForLayout; |
|||
newValue.ArrangeInvalidated += InvalidateArrangeForLayout; |
|||
} |
|||
|
|||
bool isVirtualizingLayout = newValue != null && newValue is VirtualizingLayout; |
|||
_viewportManager.OnLayoutChanged(isVirtualizingLayout); |
|||
InvalidateMeasure(); |
|||
} |
|||
|
|||
private void OnItemsSourceViewChanged(object sender, NotifyCollectionChangedEventArgs args) |
|||
{ |
|||
if (_isLayoutInProgress) |
|||
{ |
|||
// Bad things will follow if the data changes while we are in the middle of a layout pass.
|
|||
throw new InvalidOperationException("Changes in data source are not allowed during layout."); |
|||
} |
|||
|
|||
if (IsProcessingCollectionChange) |
|||
{ |
|||
throw new InvalidOperationException("Changes in the data source are not allowed during another change in the data source."); |
|||
} |
|||
|
|||
_processingItemsSourceChange = args; |
|||
|
|||
try |
|||
{ |
|||
_viewManager.OnItemsSourceChanged(sender, args); |
|||
|
|||
if (Layout != null) |
|||
{ |
|||
if (Layout is VirtualizingLayout virtualLayout) |
|||
{ |
|||
virtualLayout.OnItemsChanged(GetLayoutContext(), sender, args); |
|||
} |
|||
else |
|||
{ |
|||
// NonVirtualizingLayout
|
|||
InvalidateMeasure(); |
|||
} |
|||
} |
|||
} |
|||
finally |
|||
{ |
|||
_processingItemsSourceChange = null; |
|||
} |
|||
} |
|||
|
|||
private void InvalidateMeasureForLayout(object sender, EventArgs e) => InvalidateMeasure(); |
|||
|
|||
private void InvalidateArrangeForLayout(object sender, EventArgs e) => InvalidateArrange(); |
|||
|
|||
private VirtualizingLayoutContext GetLayoutContext() |
|||
{ |
|||
if (_layoutContext == null) |
|||
{ |
|||
_layoutContext = new RepeaterLayoutContext(this); |
|||
} |
|||
|
|||
return _layoutContext; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,24 @@ |
|||
// This source file is adapted from the WinUI project.
|
|||
// (https://github.com/microsoft/microsoft-ui-xaml)
|
|||
//
|
|||
// Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation.
|
|||
|
|||
using System; |
|||
|
|||
namespace Avalonia.Controls |
|||
{ |
|||
/// <summary>
|
|||
/// Provides data for the <see cref="ItemsRepeater.ElementClearing"/> event.
|
|||
/// </summary>
|
|||
public class ItemsRepeaterElementClearingEventArgs : EventArgs |
|||
{ |
|||
internal ItemsRepeaterElementClearingEventArgs(IControl element) => Element = element; |
|||
|
|||
/// <summary>
|
|||
/// Gets the element that is being cleared for re-use.
|
|||
/// </summary>
|
|||
public IControl Element { get; private set; } |
|||
|
|||
internal void Update(IControl element) => Element = element; |
|||
} |
|||
} |
|||
@ -0,0 +1,44 @@ |
|||
// This source file is adapted from the WinUI project.
|
|||
// (https://github.com/microsoft/microsoft-ui-xaml)
|
|||
//
|
|||
// Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation.
|
|||
|
|||
using System; |
|||
|
|||
namespace Avalonia.Controls |
|||
{ |
|||
/// <summary>
|
|||
/// Provides data for the <see cref="ItemsRepeater.ElementIndexChanged"/> event.
|
|||
/// </summary>
|
|||
public class ItemsRepeaterElementIndexChangedEventArgs : EventArgs |
|||
{ |
|||
internal ItemsRepeaterElementIndexChangedEventArgs(IControl element, int newIndex, int oldIndex) |
|||
{ |
|||
Element = element; |
|||
NewIndex = newIndex; |
|||
OldIndex = oldIndex; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Get the element for which the index changed.
|
|||
/// </summary>
|
|||
public IControl Element { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the index of the element after the change.
|
|||
/// </summary>
|
|||
public int NewIndex { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the index of the element before the change.
|
|||
/// </summary>
|
|||
public int OldIndex { get; private set; } |
|||
|
|||
internal void Update(IControl element, int newIndex, int oldIndex) |
|||
{ |
|||
Element = element; |
|||
NewIndex = newIndex; |
|||
OldIndex = oldIndex; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,35 @@ |
|||
// This source file is adapted from the WinUI project.
|
|||
// (https://github.com/microsoft/microsoft-ui-xaml)
|
|||
//
|
|||
// Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation.
|
|||
|
|||
namespace Avalonia.Controls |
|||
{ |
|||
/// <summary>
|
|||
/// Provides data for the <see cref="ItemsRepeater.ElementPrepared"/> event.
|
|||
/// </summary>
|
|||
public class ItemsRepeaterElementPreparedEventArgs |
|||
{ |
|||
internal ItemsRepeaterElementPreparedEventArgs(IControl element, int index) |
|||
{ |
|||
Element = element; |
|||
Index = index; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the prepared element.
|
|||
/// </summary>
|
|||
public IControl Element { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the index of the item the element was prepared for.
|
|||
/// </summary>
|
|||
public int Index { get; private set; } |
|||
|
|||
internal void Update(IControl element, int index) |
|||
{ |
|||
Element = element; |
|||
Index = index; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,145 @@ |
|||
// This source file is adapted from the WinUI project.
|
|||
// (https://github.com/microsoft/microsoft-ui-xaml)
|
|||
//
|
|||
// Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation.
|
|||
|
|||
using System; |
|||
using System.Collections; |
|||
using System.Collections.Generic; |
|||
using System.Collections.Specialized; |
|||
using System.Linq; |
|||
|
|||
namespace Avalonia.Controls |
|||
{ |
|||
/// <summary>
|
|||
/// Represents a standardized view of the supported interactions between a given ItemsSource
|
|||
/// object and an <see cref="ItemsRepeater"/> control.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// Components written to work with ItemsRepeater should consume the
|
|||
/// <see cref="ItemsRepeater.Items"/> via ItemsSourceView since this provides a normalized
|
|||
/// view of the Items. That way, each component does not need to know if the source is an
|
|||
/// IEnumerable, an IList, or something else.
|
|||
/// </remarks>
|
|||
public class ItemsSourceView : INotifyCollectionChanged, IDisposable |
|||
{ |
|||
private readonly IList _inner; |
|||
private INotifyCollectionChanged _notifyCollectionChanged; |
|||
private int _cachedSize = -1; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the ItemsSourceView class for the specified data source.
|
|||
/// </summary>
|
|||
/// <param name="source">The data source.</param>
|
|||
public ItemsSourceView(IEnumerable source) |
|||
{ |
|||
Contract.Requires<ArgumentNullException>(source != null); |
|||
|
|||
if (source is IList list) |
|||
{ |
|||
_inner = list; |
|||
} |
|||
else if (source is IEnumerable<object> objectEnumerable) |
|||
{ |
|||
_inner = new List<object>(objectEnumerable); |
|||
} |
|||
else |
|||
{ |
|||
_inner = new List<object>(source.Cast<object>()); |
|||
} |
|||
|
|||
ListenToCollectionChanges(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the number of items in the collection.
|
|||
/// </summary>
|
|||
public int Count |
|||
{ |
|||
get |
|||
{ |
|||
if (_cachedSize == -1) |
|||
{ |
|||
_cachedSize = _inner.Count; |
|||
} |
|||
|
|||
return _cachedSize; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value that indicates whether the items source can provide a unique key for each item.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// TODO: Not yet implemented in Avalonia.
|
|||
/// </remarks>
|
|||
public bool HasKeyIndexMapping => false; |
|||
|
|||
/// <summary>
|
|||
/// Occurs when the collection has changed to indicate the reason for the change and which items changed.
|
|||
/// </summary>
|
|||
public event NotifyCollectionChangedEventHandler CollectionChanged; |
|||
|
|||
/// <inheritdoc/>
|
|||
public void Dispose() |
|||
{ |
|||
if (_notifyCollectionChanged != null) |
|||
{ |
|||
_notifyCollectionChanged.CollectionChanged -= OnCollectionChanged; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Retrieves the item at the specified index.
|
|||
/// </summary>
|
|||
/// <param name="index">The index.</param>
|
|||
/// <returns>the item.</returns>
|
|||
public object GetAt(int index) => _inner[index]; |
|||
|
|||
/// <summary>
|
|||
/// Retrieves the index of the item that has the specified unique identifier (key).
|
|||
/// </summary>
|
|||
/// <param name="index">The index.</param>
|
|||
/// <returns>The key</returns>
|
|||
/// <remarks>
|
|||
/// TODO: Not yet implemented in Avalonia.
|
|||
/// </remarks>
|
|||
public string KeyFromIndex(int index) |
|||
{ |
|||
throw new NotImplementedException(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Retrieves the unique identifier (key) for the item at the specified index.
|
|||
/// </summary>
|
|||
/// <param name="key">The key.</param>
|
|||
/// <returns>The index.</returns>
|
|||
/// <remarks>
|
|||
/// TODO: Not yet implemented in Avalonia.
|
|||
/// </remarks>
|
|||
public int IndexFromKey(string key) |
|||
{ |
|||
throw new NotImplementedException(); |
|||
} |
|||
|
|||
protected void OnItemsSourceChanged(NotifyCollectionChangedEventArgs args) |
|||
{ |
|||
_cachedSize = _inner.Count; |
|||
CollectionChanged?.Invoke(this, args); |
|||
} |
|||
|
|||
private void ListenToCollectionChanges() |
|||
{ |
|||
if (_inner is INotifyCollectionChanged incc) |
|||
{ |
|||
incc.CollectionChanged += OnCollectionChanged; |
|||
_notifyCollectionChanged = incc; |
|||
} |
|||
} |
|||
|
|||
private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e) |
|||
{ |
|||
OnItemsSourceChanged(e); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,106 @@ |
|||
// This source file is adapted from the WinUI project.
|
|||
// (https://github.com/microsoft/microsoft-ui-xaml)
|
|||
//
|
|||
// Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation.
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
using System.Runtime.CompilerServices; |
|||
using Avalonia.Controls.Templates; |
|||
|
|||
namespace Avalonia.Controls |
|||
{ |
|||
internal class RecyclePool |
|||
{ |
|||
public static readonly AttachedProperty<IDataTemplate> OriginTemplateProperty = |
|||
AvaloniaProperty.RegisterAttached<Control, IDataTemplate>("OriginTemplate", typeof(RecyclePool)); |
|||
|
|||
private static ConditionalWeakTable<IDataTemplate, RecyclePool> s_pools = new ConditionalWeakTable<IDataTemplate, RecyclePool>(); |
|||
private readonly Dictionary<string, List<ElementInfo>> _elements = new Dictionary<string, List<ElementInfo>>(); |
|||
|
|||
public static RecyclePool GetPoolInstance(IDataTemplate dataTemplate) |
|||
{ |
|||
s_pools.TryGetValue(dataTemplate, out var result); |
|||
return result; |
|||
} |
|||
|
|||
public static void SetPoolInstance(IDataTemplate dataTemplate, RecyclePool value) => s_pools.Add(dataTemplate, value); |
|||
|
|||
public void PutElement(IControl element, string key, IControl owner) |
|||
{ |
|||
var ownerAsPanel = EnsureOwnerIsPanelOrNull(owner); |
|||
var elementInfo = new ElementInfo(element, ownerAsPanel); |
|||
|
|||
if (!_elements.TryGetValue(key, out var pool)) |
|||
{ |
|||
pool = new List<ElementInfo>(); |
|||
_elements.Add(key, pool); |
|||
} |
|||
|
|||
pool.Add(elementInfo); |
|||
} |
|||
|
|||
public IControl TryGetElement(string key, IControl owner) |
|||
{ |
|||
if (_elements.TryGetValue(key, out var elements)) |
|||
{ |
|||
if (elements.Count > 0) |
|||
{ |
|||
// Prefer an element from the same owner or with no owner so that we don't incur
|
|||
// the enter/leave cost during recycling.
|
|||
// TODO: prioritize elements with the same owner to those without an owner.
|
|||
var elementInfo = elements.FirstOrDefault(x => x.Owner == owner) ?? elements.LastOrDefault(); |
|||
elements.Remove(elementInfo); |
|||
|
|||
var ownerAsPanel = EnsureOwnerIsPanelOrNull(owner); |
|||
if (elementInfo.Owner != null && elementInfo.Owner != ownerAsPanel) |
|||
{ |
|||
// Element is still under its parent. remove it from its parent.
|
|||
var panel = elementInfo.Owner; |
|||
if (panel != null) |
|||
{ |
|||
int childIndex = panel.Children.IndexOf(elementInfo.Element); |
|||
if (childIndex == -1) |
|||
{ |
|||
throw new KeyNotFoundException("ItemsRepeater's child not found in its Children collection."); |
|||
} |
|||
|
|||
panel.Children.RemoveAt(childIndex); |
|||
} |
|||
} |
|||
|
|||
return elementInfo.Element; |
|||
} |
|||
} |
|||
|
|||
return null; |
|||
} |
|||
|
|||
private IPanel EnsureOwnerIsPanelOrNull(IControl owner) |
|||
{ |
|||
if (owner is IPanel panel) |
|||
{ |
|||
return panel; |
|||
} |
|||
else if (owner != null) |
|||
{ |
|||
throw new InvalidOperationException("Owner must be IPanel or null."); |
|||
} |
|||
|
|||
return null; |
|||
} |
|||
|
|||
private class ElementInfo |
|||
{ |
|||
public ElementInfo(IControl element, IPanel owner) |
|||
{ |
|||
Element = element; |
|||
Owner = owner; |
|||
} |
|||
|
|||
public IControl Element { get; } |
|||
public IPanel Owner { get;} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,65 @@ |
|||
// This source file is adapted from the WinUI project.
|
|||
// (https://github.com/microsoft/microsoft-ui-xaml)
|
|||
//
|
|||
// Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation.
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Text; |
|||
using Avalonia.Layout; |
|||
|
|||
namespace Avalonia.Controls |
|||
{ |
|||
internal class RepeaterLayoutContext : VirtualizingLayoutContext |
|||
{ |
|||
private readonly ItemsRepeater _owner; |
|||
|
|||
public RepeaterLayoutContext(ItemsRepeater owner) |
|||
{ |
|||
_owner = owner; |
|||
} |
|||
|
|||
protected override Point LayoutOriginCore |
|||
{ |
|||
get => _owner.LayoutOrigin; |
|||
set => _owner.LayoutOrigin = value; |
|||
} |
|||
|
|||
protected override object LayoutStateCore |
|||
{ |
|||
get => _owner.LayoutState; |
|||
set => _owner.LayoutState = value; |
|||
} |
|||
|
|||
protected override int RecommendedAnchorIndexCore |
|||
{ |
|||
get |
|||
{ |
|||
int anchorIndex = -1; |
|||
var anchor = _owner.SuggestedAnchor; |
|||
if (anchor != null) |
|||
{ |
|||
anchorIndex = _owner.GetElementIndex(anchor); |
|||
} |
|||
|
|||
return anchorIndex; |
|||
} |
|||
} |
|||
|
|||
protected override int ItemCountCore() => _owner.ItemsSourceView?.Count ?? 0; |
|||
|
|||
protected override ILayoutable GetOrCreateElementAtCore(int index, ElementRealizationOptions options) |
|||
{ |
|||
return _owner.GetElementImpl( |
|||
index, |
|||
(options & ElementRealizationOptions.ForceCreate) != 0, |
|||
(options & ElementRealizationOptions.SuppressAutoRecycle) != 0); |
|||
} |
|||
|
|||
protected override object GetItemAtCore(int index) => _owner.ItemsSourceView.GetAt(index); |
|||
|
|||
protected override void RecycleElementCore(ILayoutable element) => _owner.ClearElementImpl((IControl)element); |
|||
|
|||
protected override Rect RealizationRectCore() => _owner.RealizationWindow; |
|||
} |
|||
} |
|||
@ -0,0 +1,54 @@ |
|||
// This source file is adapted from the WinUI project.
|
|||
// (https://github.com/microsoft/microsoft-ui-xaml)
|
|||
//
|
|||
// Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation.
|
|||
|
|||
using System; |
|||
using System.Collections; |
|||
using System.Collections.Generic; |
|||
using System.Text; |
|||
|
|||
namespace Avalonia.Controls |
|||
{ |
|||
internal class UniqueIdElementPool : IEnumerable<KeyValuePair<string, IControl>> |
|||
{ |
|||
private readonly Dictionary<string, IControl> _elementMap = new Dictionary<string, IControl>(); |
|||
private readonly ItemsRepeater _owner; |
|||
|
|||
public UniqueIdElementPool(ItemsRepeater owner) => _owner = owner; |
|||
|
|||
public void Add(IControl element) |
|||
{ |
|||
var virtInfo = ItemsRepeater.GetVirtualizationInfo(element); |
|||
var key = virtInfo.UniqueId; |
|||
|
|||
if (_elementMap.ContainsKey(key)) |
|||
{ |
|||
throw new InvalidOperationException($"The unique id provided ({key}) is not unique."); |
|||
} |
|||
|
|||
_elementMap.Add(key, element); |
|||
} |
|||
|
|||
public IControl Remove(int index) |
|||
{ |
|||
// Check if there is already a element in the mapping and if so, use it.
|
|||
string key = _owner.ItemsSourceView.KeyFromIndex(index); |
|||
|
|||
if (_elementMap.TryGetValue(key, out var element)) |
|||
{ |
|||
_elementMap.Remove(key); |
|||
} |
|||
|
|||
return element; |
|||
} |
|||
|
|||
public void Clear() |
|||
{ |
|||
_elementMap.Clear(); |
|||
} |
|||
|
|||
public IEnumerator<KeyValuePair<string, IControl>> GetEnumerator() => _elementMap.GetEnumerator(); |
|||
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); |
|||
} |
|||
} |
|||
@ -0,0 +1,682 @@ |
|||
// This source file is adapted from the WinUI project.
|
|||
// (https://github.com/microsoft/microsoft-ui-xaml)
|
|||
//
|
|||
// Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation.
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Collections.Specialized; |
|||
using System.Linq; |
|||
using Avalonia.Controls.Templates; |
|||
using Avalonia.Input; |
|||
using Avalonia.Interactivity; |
|||
using Avalonia.Layout; |
|||
using Avalonia.VisualTree; |
|||
|
|||
namespace Avalonia.Controls |
|||
{ |
|||
internal sealed class ViewManager |
|||
{ |
|||
private const int FirstRealizedElementIndexDefault = int.MaxValue; |
|||
private const int LastRealizedElementIndexDefault = int.MinValue; |
|||
|
|||
private readonly ItemsRepeater _owner; |
|||
private readonly List<PinnedElementInfo> _pinnedPool = new List<PinnedElementInfo>(); |
|||
private readonly UniqueIdElementPool _resetPool; |
|||
private IControl _lastFocusedElement; |
|||
private bool _isDataSourceStableResetPending; |
|||
private int _firstRealizedElementIndexHeldByLayout = FirstRealizedElementIndexDefault; |
|||
private int _lastRealizedElementIndexHeldByLayout = LastRealizedElementIndexDefault; |
|||
private bool _eventsSubscribed; |
|||
|
|||
public ViewManager(ItemsRepeater owner) |
|||
{ |
|||
_owner = owner; |
|||
_resetPool = new UniqueIdElementPool(owner); |
|||
} |
|||
|
|||
public IControl GetElement(int index, bool forceCreate, bool suppressAutoRecycle) |
|||
{ |
|||
var element = forceCreate ? null : GetElementIfAlreadyHeldByLayout(index); |
|||
if (element == null) |
|||
{ |
|||
// check if this is the anchor made through repeater in preparation
|
|||
// for a bring into view.
|
|||
var madeAnchor = _owner.MadeAnchor; |
|||
if (madeAnchor != null) |
|||
{ |
|||
var anchorVirtInfo = ItemsRepeater.TryGetVirtualizationInfo(madeAnchor); |
|||
if (anchorVirtInfo.Index == index) |
|||
{ |
|||
element = madeAnchor; |
|||
} |
|||
} |
|||
} |
|||
if (element == null) { element = GetElementFromUniqueIdResetPool(index); }; |
|||
if (element == null) { element = GetElementFromPinnedElements(index); } |
|||
if (element == null) { element = GetElementFromElementFactory(index); } |
|||
|
|||
var virtInfo = ItemsRepeater.TryGetVirtualizationInfo(element); |
|||
if (suppressAutoRecycle) |
|||
{ |
|||
virtInfo.AutoRecycleCandidate = false; |
|||
} |
|||
else |
|||
{ |
|||
virtInfo.AutoRecycleCandidate = true; |
|||
virtInfo.KeepAlive = true; |
|||
} |
|||
|
|||
return element; |
|||
} |
|||
|
|||
public void ClearElement(IControl element, bool isClearedDueToCollectionChange) |
|||
{ |
|||
var virtInfo = ItemsRepeater.GetVirtualizationInfo(element); |
|||
var index = virtInfo.Index; |
|||
bool cleared = |
|||
ClearElementToUniqueIdResetPool(element, virtInfo) || |
|||
ClearElementToPinnedPool(element, virtInfo, isClearedDueToCollectionChange); |
|||
|
|||
if (!cleared) |
|||
{ |
|||
ClearElementToElementFactory(element); |
|||
} |
|||
|
|||
// Both First and Last indices need to be valid or default.
|
|||
if (index == _firstRealizedElementIndexHeldByLayout && index == _lastRealizedElementIndexHeldByLayout) |
|||
{ |
|||
// First and last were pointing to the same element and that is going away.
|
|||
InvalidateRealizedIndicesHeldByLayout(); |
|||
} |
|||
else if (index == _firstRealizedElementIndexHeldByLayout) |
|||
{ |
|||
// The FirstElement is going away, shrink the range by one.
|
|||
++_firstRealizedElementIndexHeldByLayout; |
|||
} |
|||
else if (index == _lastRealizedElementIndexHeldByLayout) |
|||
{ |
|||
// Last element is going away, shrink the range by one at the end.
|
|||
--_lastRealizedElementIndexHeldByLayout; |
|||
} |
|||
else |
|||
{ |
|||
// Index is either outside the range we are keeping track of or inside the range.
|
|||
// In both these cases, we just keep the range we have. If this clear was due to
|
|||
// a collection change, then in the CollectionChanged event, we will invalidate these guys.
|
|||
} |
|||
} |
|||
|
|||
public void ClearElementToElementFactory(IControl element) |
|||
{ |
|||
var virtInfo = ItemsRepeater.GetVirtualizationInfo(element); |
|||
var clearedIndex = virtInfo.Index; |
|||
_owner.OnElementClearing(element); |
|||
_owner.ItemTemplateShim.RecycleElement(_owner, element); |
|||
|
|||
virtInfo.MoveOwnershipToElementFactory(); |
|||
|
|||
if (_lastFocusedElement == element) |
|||
{ |
|||
// Focused element is going away. Remove the tracked last focused element
|
|||
// and pick a reasonable next focus if we can find one within the layout
|
|||
// realized elements.
|
|||
MoveFocusFromClearedIndex(clearedIndex); |
|||
} |
|||
|
|||
} |
|||
|
|||
private void MoveFocusFromClearedIndex(int clearedIndex) |
|||
{ |
|||
IControl focusedChild = null; |
|||
var focusCandidate = FindFocusCandidate(clearedIndex, focusedChild); |
|||
if (focusCandidate != null) |
|||
{ |
|||
focusCandidate.Focus(); |
|||
_lastFocusedElement = focusedChild; |
|||
|
|||
// Add pin to hold the focused element.
|
|||
UpdatePin(focusedChild, true /* addPin */); |
|||
} |
|||
else |
|||
{ |
|||
// We could not find a candiate.
|
|||
_lastFocusedElement = null; |
|||
} |
|||
} |
|||
|
|||
IControl FindFocusCandidate(int clearedIndex, IControl focusedChild) |
|||
{ |
|||
// Walk through all the children and find elements with index before and after the cleared index.
|
|||
// Note that during a delete the next element would now have the same index.
|
|||
int previousIndex = int.MinValue; |
|||
int nextIndex = int.MaxValue; |
|||
IControl nextElement = null; |
|||
IControl previousElement = null; |
|||
|
|||
foreach (var child in _owner.Children) |
|||
{ |
|||
var virtInfo = ItemsRepeater.TryGetVirtualizationInfo(child); |
|||
if (virtInfo?.IsHeldByLayout == true) |
|||
{ |
|||
int currentIndex = virtInfo.Index; |
|||
if (currentIndex < clearedIndex) |
|||
{ |
|||
if (currentIndex > previousIndex) |
|||
{ |
|||
previousIndex = currentIndex; |
|||
previousElement = child; |
|||
} |
|||
} |
|||
else if (currentIndex >= clearedIndex) |
|||
{ |
|||
// Note that we use >= above because if we deleted the focused element,
|
|||
// the next element would have the same index now.
|
|||
if (currentIndex < nextIndex) |
|||
{ |
|||
nextIndex = currentIndex; |
|||
nextElement = child; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
// TODO: Find the next element if one exists, if not use the previous element.
|
|||
// If the container itself is not focusable, find a descendent that is.
|
|||
|
|||
return nextElement; |
|||
} |
|||
|
|||
public int GetElementIndex(VirtualizationInfo virtInfo) |
|||
{ |
|||
if (virtInfo == null) |
|||
{ |
|||
throw new ArgumentException("Element is not a child of this ItemsRepeater."); |
|||
} |
|||
|
|||
return virtInfo.IsRealized || virtInfo.IsInUniqueIdResetPool ? virtInfo.Index : -1; |
|||
} |
|||
|
|||
public void PrunePinnedElements() |
|||
{ |
|||
EnsureEventSubscriptions(); |
|||
|
|||
// Go through pinned elements and make sure they still have
|
|||
// a reason to be pinned.
|
|||
for (var i = 0; i < _pinnedPool.Count; ++i) |
|||
{ |
|||
var elementInfo = _pinnedPool[i]; |
|||
var virtInfo = elementInfo.VirtualizationInfo; |
|||
|
|||
if (!virtInfo.IsPinned) |
|||
{ |
|||
_pinnedPool.RemoveAt(i); |
|||
--i; |
|||
|
|||
// Pinning was the only thing keeping this element alive.
|
|||
ClearElementToElementFactory(elementInfo.PinnedElement); |
|||
} |
|||
} |
|||
} |
|||
|
|||
public void UpdatePin(IControl element, bool addPin) |
|||
{ |
|||
var parent = element.VisualParent; |
|||
var child = (IVisual)element; |
|||
|
|||
while (parent != null) |
|||
{ |
|||
if (parent is ItemsRepeater repeater) |
|||
{ |
|||
var virtInfo = ItemsRepeater.GetVirtualizationInfo((IControl)child); |
|||
if (virtInfo.IsRealized) |
|||
{ |
|||
if (addPin) |
|||
{ |
|||
virtInfo.AddPin(); |
|||
} |
|||
else if (virtInfo.IsPinned) |
|||
{ |
|||
if (virtInfo.RemovePin() == 0) |
|||
{ |
|||
// ElementFactory is invoked during the measure pass.
|
|||
// We will clear the element then.
|
|||
repeater.InvalidateMeasure(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
child = parent; |
|||
parent = child.VisualParent; |
|||
} |
|||
} |
|||
|
|||
public void OnItemsSourceChanged(object sender, NotifyCollectionChangedEventArgs args) |
|||
{ |
|||
// Note: For items that have been removed, the index will not be touched. It will hold
|
|||
// the old index before it was removed. It is not valid anymore.
|
|||
switch (args.Action) |
|||
{ |
|||
case NotifyCollectionChangedAction.Add: |
|||
{ |
|||
var newIndex = args.NewStartingIndex; |
|||
var newCount = args.NewItems.Count; |
|||
EnsureFirstLastRealizedIndices(); |
|||
if (newIndex <= _lastRealizedElementIndexHeldByLayout) |
|||
{ |
|||
_lastRealizedElementIndexHeldByLayout += newCount; |
|||
foreach (var element in _owner.Children) |
|||
{ |
|||
var virtInfo = ItemsRepeater.GetVirtualizationInfo(element); |
|||
var dataIndex = virtInfo.Index; |
|||
|
|||
if (virtInfo.IsRealized && dataIndex >= newIndex) |
|||
{ |
|||
UpdateElementIndex(element, virtInfo, dataIndex + newCount); |
|||
} |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
// Indices held by layout are not affected
|
|||
// We could still have items in the pinned elements that need updates. This is usually a very small vector.
|
|||
for (var i = 0; i < _pinnedPool.Count; ++i) |
|||
{ |
|||
var elementInfo = _pinnedPool[i]; |
|||
var virtInfo = elementInfo.VirtualizationInfo; |
|||
var dataIndex = virtInfo.Index; |
|||
|
|||
if (virtInfo.IsRealized && dataIndex >= newIndex) |
|||
{ |
|||
var element = elementInfo.PinnedElement; |
|||
UpdateElementIndex(element, virtInfo, dataIndex + newCount); |
|||
} |
|||
} |
|||
} |
|||
break; |
|||
} |
|||
|
|||
case NotifyCollectionChangedAction.Replace: |
|||
{ |
|||
// Requirement: oldStartIndex == newStartIndex. It is not a replace if this is not true.
|
|||
// Two cases here
|
|||
// case 1: oldCount == newCount
|
|||
// indices are not affected. nothing to do here.
|
|||
// case 2: oldCount != newCount
|
|||
// Replaced with less or more items. This is like an insert or remove
|
|||
// depending on the counts.
|
|||
var oldStartIndex = args.OldStartingIndex; |
|||
var newStartingIndex = args.NewStartingIndex; |
|||
var oldCount = args.OldItems.Count; |
|||
var newCount = args.NewItems.Count; |
|||
if (oldStartIndex != newStartingIndex) |
|||
{ |
|||
throw new NotSupportedException("Replace is only allowed with OldStartingIndex equals to NewStartingIndex."); |
|||
} |
|||
|
|||
if (oldCount == 0) |
|||
{ |
|||
throw new NotSupportedException("Replace notification with args.OldItemsCount value of 0 is not allowed. Use Insert action instead."); |
|||
} |
|||
|
|||
if (newCount == 0) |
|||
{ |
|||
throw new NotSupportedException("Replace notification with args.NewItemCount value of 0 is not allowed. Use Remove action instead."); |
|||
} |
|||
|
|||
int countChange = newCount - oldCount; |
|||
if (countChange != 0) |
|||
{ |
|||
// countChange > 0 : countChange items were added
|
|||
// countChange < 0 : -countChange items were removed
|
|||
foreach (var element in _owner.Children) |
|||
{ |
|||
var virtInfo = ItemsRepeater.GetVirtualizationInfo(element); |
|||
var dataIndex = virtInfo.Index; |
|||
|
|||
if (virtInfo.IsRealized) |
|||
{ |
|||
if (dataIndex >= oldStartIndex + oldCount) |
|||
{ |
|||
UpdateElementIndex(element, virtInfo, dataIndex + countChange); |
|||
} |
|||
} |
|||
} |
|||
|
|||
EnsureFirstLastRealizedIndices(); |
|||
_lastRealizedElementIndexHeldByLayout += countChange; |
|||
} |
|||
break; |
|||
} |
|||
|
|||
case NotifyCollectionChangedAction.Remove: |
|||
{ |
|||
var oldStartIndex = args.OldStartingIndex; |
|||
var oldCount = args.OldItems.Count; |
|||
foreach (var element in _owner.Children) |
|||
{ |
|||
var virtInfo = ItemsRepeater.GetVirtualizationInfo(element); |
|||
var dataIndex = virtInfo.Index; |
|||
|
|||
if (virtInfo.IsRealized) |
|||
{ |
|||
if (virtInfo.AutoRecycleCandidate && oldStartIndex <= dataIndex && dataIndex < oldStartIndex + oldCount) |
|||
{ |
|||
// If we are doing the mapping, remove the element who's data was removed.
|
|||
_owner.ClearElementImpl(element); |
|||
} |
|||
else if (dataIndex >= (oldStartIndex + oldCount)) |
|||
{ |
|||
UpdateElementIndex(element, virtInfo, dataIndex - oldCount); |
|||
} |
|||
} |
|||
} |
|||
|
|||
InvalidateRealizedIndicesHeldByLayout(); |
|||
break; |
|||
} |
|||
|
|||
case NotifyCollectionChangedAction.Reset: |
|||
if (_owner.ItemsSourceView.HasKeyIndexMapping) |
|||
{ |
|||
_isDataSourceStableResetPending = true; |
|||
} |
|||
|
|||
// Walk through all the elements and make sure they are cleared, they will go into
|
|||
// the stable id reset pool.
|
|||
foreach (var element in _owner.Children) |
|||
{ |
|||
var virtInfo = ItemsRepeater.GetVirtualizationInfo(element); |
|||
if (virtInfo.IsRealized && virtInfo.AutoRecycleCandidate) |
|||
{ |
|||
_owner.ClearElementImpl(element); |
|||
} |
|||
} |
|||
|
|||
InvalidateRealizedIndicesHeldByLayout(); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
private void EnsureFirstLastRealizedIndices() |
|||
{ |
|||
if (_firstRealizedElementIndexHeldByLayout == FirstRealizedElementIndexDefault) |
|||
{ |
|||
// This will ensure that the indexes are updated.
|
|||
GetElementIfAlreadyHeldByLayout(0); |
|||
} |
|||
} |
|||
|
|||
public void OnLayoutChanging() |
|||
{ |
|||
if (_owner.ItemsSourceView?.HasKeyIndexMapping == true) |
|||
{ |
|||
_isDataSourceStableResetPending = true; |
|||
} |
|||
} |
|||
|
|||
public void OnOwnerArranged() |
|||
{ |
|||
if (_isDataSourceStableResetPending) |
|||
{ |
|||
_isDataSourceStableResetPending = false; |
|||
|
|||
foreach (var entry in _resetPool) |
|||
{ |
|||
// TODO: Task 14204306: ItemsRepeater: Find better focus candidate when focused element is deleted in the ItemsSource.
|
|||
// Focused element is getting cleared. Need to figure out semantics on where
|
|||
// focus should go when the focused element is removed from the data collection.
|
|||
ClearElement(entry.Value, true /* isClearedDueToCollectionChange */); |
|||
} |
|||
|
|||
_resetPool.Clear(); |
|||
} |
|||
} |
|||
|
|||
// We optimize for the case where index is not realized to return null as quickly as we can.
|
|||
// Flow layouts manage containers on their own and will never ask for an index that is already realized.
|
|||
// If an index that is realized is requested by the layout, we unfortunately have to walk the
|
|||
// children. Not ideal, but a reasonable default to provide consistent behavior between virtualizing
|
|||
// and non-virtualizing hosts.
|
|||
private IControl GetElementIfAlreadyHeldByLayout(int index) |
|||
{ |
|||
IControl element = null; |
|||
|
|||
bool cachedFirstLastIndicesInvalid = _firstRealizedElementIndexHeldByLayout == FirstRealizedElementIndexDefault; |
|||
bool isRequestedIndexInRealizedRange = (_firstRealizedElementIndexHeldByLayout <= index && index <= _lastRealizedElementIndexHeldByLayout); |
|||
|
|||
if (cachedFirstLastIndicesInvalid || isRequestedIndexInRealizedRange) |
|||
{ |
|||
foreach (var child in _owner.Children) |
|||
{ |
|||
var virtInfo = ItemsRepeater.TryGetVirtualizationInfo(child); |
|||
if (virtInfo?.IsHeldByLayout == true) |
|||
{ |
|||
// Only give back elements held by layout. If someone else is holding it, they will be served by other methods.
|
|||
int childIndex = virtInfo.Index; |
|||
_firstRealizedElementIndexHeldByLayout = Math.Min(_firstRealizedElementIndexHeldByLayout, childIndex); |
|||
_lastRealizedElementIndexHeldByLayout = Math.Max(_lastRealizedElementIndexHeldByLayout, childIndex); |
|||
if (virtInfo.Index == index) |
|||
{ |
|||
element = child; |
|||
// If we have valid first/last indices, we don't have to walk the rest, but if we
|
|||
// do not, then we keep walking through the entire children collection to get accurate
|
|||
// indices once.
|
|||
if (!cachedFirstLastIndicesInvalid) |
|||
{ |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
return element; |
|||
} |
|||
|
|||
private IControl GetElementFromUniqueIdResetPool(int index) |
|||
{ |
|||
IControl element = null; |
|||
// See if you can get it from the reset pool.
|
|||
if (_isDataSourceStableResetPending) |
|||
{ |
|||
element = _resetPool.Remove(index); |
|||
if (element != null) |
|||
{ |
|||
// Make sure that the index is updated to the current one
|
|||
var virtInfo = ItemsRepeater.GetVirtualizationInfo(element); |
|||
virtInfo.MoveOwnershipToLayoutFromUniqueIdResetPool(); |
|||
UpdateElementIndex(element, virtInfo, index); |
|||
} |
|||
} |
|||
|
|||
return element; |
|||
} |
|||
|
|||
private IControl GetElementFromPinnedElements(int index) |
|||
{ |
|||
IControl element = null; |
|||
|
|||
// See if you can find something among the pinned elements.
|
|||
for (var i = 0; i < _pinnedPool.Count; ++i) |
|||
{ |
|||
var elementInfo = _pinnedPool[i]; |
|||
var virtInfo = elementInfo.VirtualizationInfo; |
|||
|
|||
if (virtInfo.Index == index) |
|||
{ |
|||
_pinnedPool.RemoveAt(i); |
|||
element = elementInfo.PinnedElement; |
|||
elementInfo.VirtualizationInfo.MoveOwnershipToLayoutFromPinnedPool(); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
return element; |
|||
} |
|||
|
|||
private IControl GetElementFromElementFactory(int index) |
|||
{ |
|||
// The view generator is the provider of last resort.
|
|||
|
|||
var itemTemplateFactory = _owner.ItemTemplateShim; |
|||
if (itemTemplateFactory == null) |
|||
{ |
|||
// If no ItemTemplate was provided, use a default
|
|||
var factory = FuncDataTemplate.Default; |
|||
_owner.ItemTemplate = factory; |
|||
itemTemplateFactory = _owner.ItemTemplateShim; |
|||
} |
|||
|
|||
var data = _owner.ItemsSourceView.GetAt(index); |
|||
var element = itemTemplateFactory.GetElement(_owner, data); |
|||
|
|||
var virtInfo = ItemsRepeater.TryGetVirtualizationInfo(element); |
|||
if (virtInfo == null) |
|||
{ |
|||
virtInfo = ItemsRepeater.CreateAndInitializeVirtualizationInfo(element); |
|||
} |
|||
|
|||
// Prepare the element
|
|||
element.DataContext = data; |
|||
|
|||
virtInfo.MoveOwnershipToLayoutFromElementFactory( |
|||
index, |
|||
/* uniqueId: */ |
|||
_owner.ItemsSourceView.HasKeyIndexMapping ? |
|||
_owner.ItemsSourceView.KeyFromIndex(index) : |
|||
string.Empty); |
|||
|
|||
// The view generator is the only provider that prepares the element.
|
|||
var repeater = _owner; |
|||
|
|||
// Add the element to the children collection here before raising OnElementPrepared so
|
|||
// that handlers can walk up the tree in case they want to find their IndexPath in the
|
|||
// nested case.
|
|||
var children = repeater.Children; |
|||
if (element.VisualParent != repeater) |
|||
{ |
|||
children.Add(element); |
|||
} |
|||
|
|||
repeater.OnElementPrepared(element, index); |
|||
|
|||
// Update realized indices
|
|||
_firstRealizedElementIndexHeldByLayout = Math.Min(_firstRealizedElementIndexHeldByLayout, index); |
|||
_lastRealizedElementIndexHeldByLayout = Math.Max(_lastRealizedElementIndexHeldByLayout, index); |
|||
|
|||
return element; |
|||
} |
|||
|
|||
private bool ClearElementToUniqueIdResetPool(IControl element, VirtualizationInfo virtInfo) |
|||
{ |
|||
if (_isDataSourceStableResetPending) |
|||
{ |
|||
_resetPool.Add(element); |
|||
virtInfo.MoveOwnershipToUniqueIdResetPoolFromLayout(); |
|||
} |
|||
|
|||
return _isDataSourceStableResetPending; |
|||
} |
|||
|
|||
private bool ClearElementToPinnedPool(IControl element, VirtualizationInfo virtInfo, bool isClearedDueToCollectionChange) |
|||
{ |
|||
if (_isDataSourceStableResetPending) |
|||
{ |
|||
_resetPool.Add(element); |
|||
virtInfo.MoveOwnershipToUniqueIdResetPoolFromLayout(); |
|||
} |
|||
|
|||
return _isDataSourceStableResetPending; |
|||
} |
|||
|
|||
private void UpdateFocusedElement() |
|||
{ |
|||
IControl focusedElement = null; |
|||
|
|||
var child = FocusManager.Instance.Current; |
|||
|
|||
if (child != null) |
|||
{ |
|||
var parent = child.VisualParent; |
|||
var owner = _owner; |
|||
|
|||
// Find out if the focused element belongs to one of our direct
|
|||
// children.
|
|||
while (parent != null) |
|||
{ |
|||
if (parent is ItemsRepeater repeater) |
|||
{ |
|||
var element = child as IControl; |
|||
if (repeater == owner && ItemsRepeater.GetVirtualizationInfo(element).IsRealized) |
|||
{ |
|||
focusedElement = element; |
|||
} |
|||
|
|||
break; |
|||
} |
|||
|
|||
child = parent as IInputElement; |
|||
parent = child.VisualParent; |
|||
} |
|||
} |
|||
|
|||
// If the focused element has changed,
|
|||
// we need to unpin the old one and pin the new one.
|
|||
if (_lastFocusedElement != focusedElement) |
|||
{ |
|||
if (_lastFocusedElement != null) |
|||
{ |
|||
UpdatePin(_lastFocusedElement, false /* addPin */); |
|||
} |
|||
|
|||
if (focusedElement != null) |
|||
{ |
|||
UpdatePin(focusedElement, true /* addPin */); |
|||
} |
|||
|
|||
_lastFocusedElement = focusedElement; |
|||
} |
|||
} |
|||
|
|||
private void OnFocusChanged(object sender, RoutedEventArgs e) => UpdateFocusedElement(); |
|||
|
|||
private void EnsureEventSubscriptions() |
|||
{ |
|||
if (!_eventsSubscribed) |
|||
{ |
|||
_owner.GotFocus += OnFocusChanged; |
|||
_owner.LostFocus += OnFocusChanged; |
|||
} |
|||
} |
|||
|
|||
private void UpdateElementIndex(IControl element, VirtualizationInfo virtInfo, int index) |
|||
{ |
|||
var oldIndex = virtInfo.Index; |
|||
if (oldIndex != index) |
|||
{ |
|||
virtInfo.UpdateIndex(index); |
|||
_owner.OnElementIndexChanged(element, oldIndex, index); |
|||
} |
|||
} |
|||
|
|||
private void InvalidateRealizedIndicesHeldByLayout() |
|||
{ |
|||
_firstRealizedElementIndexHeldByLayout = FirstRealizedElementIndexDefault; |
|||
_lastRealizedElementIndexHeldByLayout = LastRealizedElementIndexDefault; |
|||
} |
|||
|
|||
private struct PinnedElementInfo |
|||
{ |
|||
public PinnedElementInfo(IControl element) |
|||
{ |
|||
PinnedElement = element; |
|||
VirtualizationInfo = ItemsRepeater.GetVirtualizationInfo(element); |
|||
} |
|||
|
|||
public IControl PinnedElement { get; } |
|||
public VirtualizationInfo VirtualizationInfo { get; } |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,501 @@ |
|||
// This source file is adapted from the WinUI project.
|
|||
// (https://github.com/microsoft/microsoft-ui-xaml)
|
|||
//
|
|||
// Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation.
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Reactive.Linq; |
|||
using System.Threading.Tasks; |
|||
using Avalonia.Layout; |
|||
using Avalonia.Threading; |
|||
using Avalonia.VisualTree; |
|||
|
|||
namespace Avalonia.Controls |
|||
{ |
|||
internal class ViewportManager |
|||
{ |
|||
private const double CacheBufferPerSideInflationPixelDelta = 40.0; |
|||
private readonly ItemsRepeater _owner; |
|||
private bool _ensuredScroller; |
|||
private IScrollAnchorProvider _scroller; |
|||
private IControl _makeAnchorElement; |
|||
private bool _isAnchorOutsideRealizedRange; |
|||
private Task _cacheBuildAction; |
|||
private Rect _visibleWindow; |
|||
private Rect _layoutExtent; |
|||
// This is the expected shift by the layout.
|
|||
private Point _expectedViewportShift; |
|||
// This is what is pending and not been accounted for.
|
|||
// Sometimes the scrolling surface cannot service a shift (for example
|
|||
// it is already at the top and cannot shift anymore.)
|
|||
private Point _pendingViewportShift; |
|||
// Unshiftable shift amount that this view manager can
|
|||
// handle on its own to fake it to the layout as if the shift
|
|||
// actually happened. This can happen in cases where no scrollviewer
|
|||
// in the parent chain can scroll in the shift direction.
|
|||
private Point _unshiftableShift; |
|||
private double _maximumHorizontalCacheLength = 0.0; |
|||
private double _maximumVerticalCacheLength = 0.0; |
|||
private double _horizontalCacheBufferPerSide; |
|||
private double _verticalCacheBufferPerSide; |
|||
private bool _isBringIntoViewInProgress; |
|||
// For non-virtualizing layouts, we do not need to keep
|
|||
// updating viewports and invalidating measure often. So when
|
|||
// a non virtualizing layout is used, we stop doing all that work.
|
|||
bool _managingViewportDisabled; |
|||
private IDisposable _effectiveViewportChangedRevoker; |
|||
private bool _layoutUpdatedSubscribed; |
|||
|
|||
public ViewportManager(ItemsRepeater owner) |
|||
{ |
|||
_owner = owner; |
|||
} |
|||
|
|||
public IControl SuggestedAnchor |
|||
{ |
|||
get |
|||
{ |
|||
// The element generated during the ItemsRepeater.MakeAnchor call has precedence over the next tick.
|
|||
var suggestedAnchor = _makeAnchorElement; |
|||
var owner = _owner; |
|||
|
|||
if (suggestedAnchor == null) |
|||
{ |
|||
var anchorElement = _scroller?.CurrentAnchor; |
|||
|
|||
if (anchorElement != null) |
|||
{ |
|||
// We can't simply return anchorElement because, in case of nested Repeaters, it may not
|
|||
// be a direct child of ours, or even an indirect child. We need to walk up the tree starting
|
|||
// from anchorElement to figure out what child of ours (if any) to use as the suggested element.
|
|||
var child = anchorElement; |
|||
var parent = child.VisualParent as IControl; |
|||
|
|||
while (parent != null) |
|||
{ |
|||
if (parent == owner) |
|||
{ |
|||
suggestedAnchor = child; |
|||
break; |
|||
} |
|||
|
|||
child = parent; |
|||
parent = parent.VisualParent as IControl; |
|||
} |
|||
} |
|||
} |
|||
|
|||
return suggestedAnchor; |
|||
} |
|||
} |
|||
|
|||
public bool HasScroller => _scroller != null; |
|||
|
|||
public IControl MadeAnchor => _makeAnchorElement; |
|||
|
|||
public double HorizontalCacheLength |
|||
{ |
|||
get => _maximumHorizontalCacheLength; |
|||
set |
|||
{ |
|||
if (_maximumHorizontalCacheLength != value) |
|||
{ |
|||
ValidateCacheLength(value); |
|||
_maximumHorizontalCacheLength = value; |
|||
} |
|||
} |
|||
} |
|||
|
|||
public double VerticalCacheLength |
|||
{ |
|||
get => _maximumVerticalCacheLength; |
|||
set |
|||
{ |
|||
if (_maximumVerticalCacheLength != value) |
|||
{ |
|||
ValidateCacheLength(value); |
|||
_maximumVerticalCacheLength = value; |
|||
} |
|||
} |
|||
} |
|||
|
|||
private Rect GetLayoutVisibleWindowDiscardAnchor() |
|||
{ |
|||
var visibleWindow = _visibleWindow; |
|||
|
|||
if (HasScroller) |
|||
{ |
|||
visibleWindow = new Rect( |
|||
visibleWindow.X + _layoutExtent.X + _expectedViewportShift.X + _unshiftableShift.X, |
|||
visibleWindow.Y + _layoutExtent.Y + _expectedViewportShift.Y + _unshiftableShift.Y, |
|||
visibleWindow.Width, |
|||
visibleWindow.Height); |
|||
} |
|||
|
|||
return visibleWindow; |
|||
} |
|||
|
|||
public Rect GetLayoutVisibleWindow() |
|||
{ |
|||
var visibleWindow = _visibleWindow; |
|||
|
|||
if (_makeAnchorElement != null) |
|||
{ |
|||
// The anchor is not necessarily laid out yet. Its position should default
|
|||
// to zero and the layout origin is expected to change once layout is done.
|
|||
// Until then, we need a window that's going to protect the anchor from
|
|||
// getting recycled.
|
|||
visibleWindow = visibleWindow.WithX(0).WithY(0); |
|||
} |
|||
else if (HasScroller) |
|||
{ |
|||
visibleWindow = new Rect( |
|||
visibleWindow.X + _layoutExtent.X + _expectedViewportShift.X + _unshiftableShift.X, |
|||
visibleWindow.Y + _layoutExtent.Y + _expectedViewportShift.Y + _unshiftableShift.Y, |
|||
visibleWindow.Width, |
|||
visibleWindow.Height); |
|||
} |
|||
|
|||
return visibleWindow; |
|||
} |
|||
|
|||
public Rect GetLayoutRealizationWindow() |
|||
{ |
|||
var realizationWindow = GetLayoutVisibleWindow(); |
|||
if (HasScroller) |
|||
{ |
|||
realizationWindow = new Rect( |
|||
realizationWindow.X - _horizontalCacheBufferPerSide, |
|||
realizationWindow.Y - _verticalCacheBufferPerSide, |
|||
realizationWindow.Width + _horizontalCacheBufferPerSide * 2.0, |
|||
realizationWindow.Height + _verticalCacheBufferPerSide * 2.0); |
|||
} |
|||
|
|||
return realizationWindow; |
|||
} |
|||
|
|||
public void SetLayoutExtent(Rect extent) |
|||
{ |
|||
_expectedViewportShift = new Point( |
|||
_expectedViewportShift.X + _layoutExtent.X - extent.X, |
|||
_expectedViewportShift.Y + _layoutExtent.Y - extent.Y); |
|||
|
|||
// We tolerate viewport imprecisions up to 1 pixel to avoid invaliding layout too much.
|
|||
if (Math.Abs(_expectedViewportShift.X) > 1 || Math.Abs(_expectedViewportShift.Y) > 1) |
|||
{ |
|||
// There are cases where we might be expecting a shift but not get it. We will
|
|||
// be waiting for the effective viewport event but if the scroll viewer is not able
|
|||
// to perform the shift (perhaps because it cannot scroll in negative offset),
|
|||
// then we will end up not realizing elements in the visible
|
|||
// window. To avoid this, we register to layout updated for this layout pass. If we
|
|||
// get an effective viewport, we know we have a new viewport and we unregister from
|
|||
// layout updated. If we get the layout updated handler, then we know that the
|
|||
// scroller was unable to perform the shift and we invalidate measure and unregister
|
|||
// from the layout updated event.
|
|||
if (!_layoutUpdatedSubscribed) |
|||
{ |
|||
_owner.LayoutUpdated += OnLayoutUpdated; |
|||
_layoutUpdatedSubscribed = true; |
|||
} |
|||
} |
|||
|
|||
_layoutExtent = extent; |
|||
_pendingViewportShift = _expectedViewportShift; |
|||
|
|||
// We just finished a measure pass and have a new extent.
|
|||
// Let's make sure the scrollers will run its arrange so that they track the anchor.
|
|||
((IControl)_scroller)?.InvalidateArrange(); |
|||
} |
|||
|
|||
public Point GetOrigin() => _layoutExtent.TopLeft; |
|||
|
|||
public void OnLayoutChanged(bool isVirtualizing) |
|||
{ |
|||
_managingViewportDisabled = !isVirtualizing; |
|||
|
|||
_layoutExtent = default; |
|||
_expectedViewportShift = default; |
|||
_pendingViewportShift = default; |
|||
_unshiftableShift = default; |
|||
|
|||
_effectiveViewportChangedRevoker?.Dispose(); |
|||
|
|||
if (!_managingViewportDisabled) |
|||
{ |
|||
_effectiveViewportChangedRevoker = SubscribeToEffectiveViewportChanged(_owner); |
|||
} |
|||
} |
|||
|
|||
public void OnElementPrepared(IControl element) |
|||
{ |
|||
// If we have an anchor element, we do not want the
|
|||
// scroll anchor provider to start anchoring some other element.
|
|||
////element.CanBeScrollAnchor(true);
|
|||
} |
|||
|
|||
public void OnElementCleared(ILayoutable element) |
|||
{ |
|||
////element.CanBeScrollAnchor(false);
|
|||
} |
|||
|
|||
public void OnOwnerMeasuring() |
|||
{ |
|||
// This is because of a bug that causes effective viewport to not
|
|||
// fire if you register during arrange.
|
|||
// Bug 17411076: EffectiveViewport: registering for effective viewport in arrange should invalidate viewport
|
|||
EnsureScroller(); |
|||
} |
|||
|
|||
public void OnOwnerArranged() |
|||
{ |
|||
_expectedViewportShift = default; |
|||
|
|||
if (!_managingViewportDisabled) |
|||
{ |
|||
// This is because of a bug that causes effective viewport to not
|
|||
// fire if you register during arrange.
|
|||
// Bug 17411076: EffectiveViewport: registering for effective viewport in arrange should invalidate viewport
|
|||
// EnsureScroller();
|
|||
|
|||
if (HasScroller) |
|||
{ |
|||
double maximumHorizontalCacheBufferPerSide = _maximumHorizontalCacheLength * _visibleWindow.Width / 2.0; |
|||
double maximumVerticalCacheBufferPerSide = _maximumVerticalCacheLength * _visibleWindow.Height / 2.0; |
|||
|
|||
bool continueBuildingCache = |
|||
_horizontalCacheBufferPerSide < maximumHorizontalCacheBufferPerSide || |
|||
_verticalCacheBufferPerSide < maximumVerticalCacheBufferPerSide; |
|||
|
|||
if (continueBuildingCache) |
|||
{ |
|||
_horizontalCacheBufferPerSide += CacheBufferPerSideInflationPixelDelta; |
|||
_verticalCacheBufferPerSide += CacheBufferPerSideInflationPixelDelta; |
|||
|
|||
_horizontalCacheBufferPerSide = Math.Min(_horizontalCacheBufferPerSide, maximumHorizontalCacheBufferPerSide); |
|||
_verticalCacheBufferPerSide = Math.Min(_verticalCacheBufferPerSide, maximumVerticalCacheBufferPerSide); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
private void OnLayoutUpdated(object sender, EventArgs args) |
|||
{ |
|||
_owner.LayoutUpdated -= OnLayoutUpdated; |
|||
if (_managingViewportDisabled) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
// We were expecting a viewport shift but we never got one and we are not going to in this
|
|||
// layout pass. We likely will never get this shift, so lets assume that we are never going to get it and
|
|||
// adjust our expected shift to track that. One case where this can happen is when there is no scrollviewer
|
|||
// that can scroll in the direction where the shift is expected.
|
|||
if (_pendingViewportShift.X != 0 || _pendingViewportShift.Y != 0) |
|||
{ |
|||
// Assume this is never going to come.
|
|||
_unshiftableShift = new Point( |
|||
_unshiftableShift.X + _pendingViewportShift.X, |
|||
_unshiftableShift.Y + _pendingViewportShift.Y); |
|||
_pendingViewportShift = default; |
|||
_expectedViewportShift = default; |
|||
|
|||
TryInvalidateMeasure(); |
|||
} |
|||
} |
|||
|
|||
public void OnMakeAnchor(IControl anchor, bool isAnchorOutsideRealizedRange) |
|||
{ |
|||
_makeAnchorElement = anchor; |
|||
_isAnchorOutsideRealizedRange = isAnchorOutsideRealizedRange; |
|||
} |
|||
|
|||
public void OnBringIntoViewRequested(RequestBringIntoViewEventArgs args) |
|||
{ |
|||
if (!_managingViewportDisabled) |
|||
{ |
|||
// During the time between a bring into view request and the element coming into view we do not
|
|||
// want the anchor provider to pick some anchor and jump to it. Instead we want to anchor on the
|
|||
// element that is being brought into view. We can do this by making just that element as a potential
|
|||
// anchor candidate and ensure no other element of this repeater is an anchor candidate.
|
|||
// Once the layout pass is done and we render the frame, the element will be in frame and we can
|
|||
// switch back to letting the anchor provider pick a suitable anchor.
|
|||
|
|||
// get the targetChild - i.e the immediate child of this repeater that is being brought into view.
|
|||
// Note that the element being brought into view could be a descendant.
|
|||
var targetChild = GetImmediateChildOfRepeater((IControl)args.TargetObject); |
|||
|
|||
// Make sure that only the target child can be the anchor during the bring into view operation.
|
|||
foreach (var child in _owner.Children) |
|||
{ |
|||
////if (child.CanBeScrollAnchor && child != targetChild)
|
|||
////{
|
|||
//// child.CanBeScrollAnchor = false;
|
|||
////}
|
|||
} |
|||
|
|||
// Register to rendering event to go back to how things were before where any child can be the anchor.
|
|||
_isBringIntoViewInProgress = true; |
|||
////if (!m_renderingToken)
|
|||
////{
|
|||
//// winrt::Windows::UI::Xaml::Media::CompositionTarget compositionTarget{ nullptr };
|
|||
//// m_renderingToken = compositionTarget.Rendering(winrt::auto_revoke, { this, &ViewportManagerWithPlatformFeatures::OnCompositionTargetRendering });
|
|||
////}
|
|||
} |
|||
} |
|||
|
|||
private IControl GetImmediateChildOfRepeater(IControl descendant) |
|||
{ |
|||
var targetChild = descendant; |
|||
var parent = descendant.Parent; |
|||
while (parent != null && parent != _owner) |
|||
{ |
|||
targetChild = parent; |
|||
parent = (IControl)parent.VisualParent; |
|||
} |
|||
|
|||
if (parent == null) |
|||
{ |
|||
throw new InvalidOperationException("OnBringIntoViewRequested called with args.target element not under the ItemsRepeater that recieved the call"); |
|||
} |
|||
|
|||
return targetChild; |
|||
} |
|||
|
|||
public void ResetScrollers() |
|||
{ |
|||
_scroller = null; |
|||
_effectiveViewportChangedRevoker?.Dispose(); |
|||
_effectiveViewportChangedRevoker = null; |
|||
_ensuredScroller = false; |
|||
} |
|||
|
|||
private void OnEffectiveViewportChanged(TransformedBounds? bounds) |
|||
{ |
|||
if (!bounds.HasValue) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
var globalClip = bounds.Value.Clip; |
|||
var transform = _owner.GetVisualRoot().TransformToVisual(_owner).Value; |
|||
var clip = globalClip.TransformToAABB(transform); |
|||
var effectiveViewport = clip.Intersect(bounds.Value.Bounds); |
|||
|
|||
UpdateViewport(effectiveViewport); |
|||
|
|||
_pendingViewportShift = default; |
|||
_unshiftableShift = default; |
|||
if (_visibleWindow.IsEmpty) |
|||
{ |
|||
// We got cleared.
|
|||
_layoutExtent = default; |
|||
} |
|||
|
|||
// We got a new viewport, we dont need to wait for layout updated anymore to
|
|||
// see if our request for a pending shift was handled.
|
|||
if (_layoutUpdatedSubscribed) |
|||
{ |
|||
_owner.LayoutUpdated -= OnLayoutUpdated; |
|||
} |
|||
} |
|||
|
|||
private void EnsureScroller() |
|||
{ |
|||
if (!_ensuredScroller) |
|||
{ |
|||
ResetScrollers(); |
|||
|
|||
var parent = _owner.GetVisualParent(); |
|||
while (parent != null) |
|||
{ |
|||
if (parent is IScrollAnchorProvider scroller) |
|||
{ |
|||
_scroller = scroller; |
|||
break; |
|||
} |
|||
|
|||
parent = parent.VisualParent; |
|||
} |
|||
|
|||
if (_scroller == null) |
|||
{ |
|||
// We usually update the viewport in the post arrange handler. But, since we don't have
|
|||
// a scroller, let's do it now.
|
|||
UpdateViewport(Rect.Empty); |
|||
} |
|||
else if (!_managingViewportDisabled) |
|||
{ |
|||
_effectiveViewportChangedRevoker?.Dispose(); |
|||
_effectiveViewportChangedRevoker = SubscribeToEffectiveViewportChanged(_owner); |
|||
} |
|||
|
|||
_ensuredScroller = true; |
|||
} |
|||
} |
|||
|
|||
private void UpdateViewport(Rect viewport) |
|||
{ |
|||
var currentVisibleWindow = viewport; |
|||
|
|||
if (-currentVisibleWindow.X <= ItemsRepeater.ClearedElementsArrangePosition.X && |
|||
-currentVisibleWindow.Y <= ItemsRepeater.ClearedElementsArrangePosition.Y) |
|||
{ |
|||
// We got cleared.
|
|||
_visibleWindow = default; |
|||
} |
|||
else |
|||
{ |
|||
_visibleWindow = currentVisibleWindow; |
|||
} |
|||
|
|||
TryInvalidateMeasure(); |
|||
} |
|||
|
|||
private static void ValidateCacheLength(double cacheLength) |
|||
{ |
|||
if (cacheLength < 0.0 || double.IsInfinity(cacheLength) || double.IsNaN(cacheLength)) |
|||
{ |
|||
throw new ArgumentException("The maximum cache length must be equal or superior to zero."); |
|||
} |
|||
} |
|||
|
|||
private void TryInvalidateMeasure() |
|||
{ |
|||
// Don't invalidate measure if we have an invalid window.
|
|||
if (!_visibleWindow.IsEmpty) |
|||
{ |
|||
// We invalidate measure instead of just invalidating arrange because
|
|||
// we don't invalidate measure in UpdateViewport if the view is changing to
|
|||
// avoid layout cycles.
|
|||
_owner.InvalidateMeasure(); |
|||
} |
|||
} |
|||
|
|||
private IDisposable SubscribeToEffectiveViewportChanged(IControl control) |
|||
{ |
|||
// HACK: This is a bit of a hack. We need the effective viewport of the ItemsRepeater -
|
|||
// we can get this from TransformedBounds, but this property is updated after layout has
|
|||
// run, resulting in the UI being updated too late when scrolling quickly. We can
|
|||
// partially remedey this by triggering also on Bounds changes, but this won't work so
|
|||
// well for nested ItemsRepeaters.
|
|||
//
|
|||
// UWP uses the EffectiveBoundsChanged event (which I think was implemented specially
|
|||
// for this case): we need to implement that in Avalonia.
|
|||
return control.GetObservable(Visual.TransformedBoundsProperty) |
|||
.Merge(control.GetObservable(Visual.BoundsProperty).Select(_ => control.TransformedBounds)) |
|||
.Skip(1) |
|||
.Subscribe(OnEffectiveViewportChanged); |
|||
} |
|||
|
|||
private class ScrollerInfo |
|||
{ |
|||
public ScrollerInfo(ScrollViewer scroller) |
|||
{ |
|||
Scroller = scroller; |
|||
} |
|||
|
|||
public ScrollViewer Scroller { get; } |
|||
} |
|||
}; |
|||
} |
|||
@ -0,0 +1,118 @@ |
|||
// This source file is adapted from the WinUI project.
|
|||
// (https://github.com/microsoft/microsoft-ui-xaml)
|
|||
//
|
|||
// Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation.
|
|||
|
|||
using System; |
|||
|
|||
namespace Avalonia.Controls |
|||
{ |
|||
internal enum ElementOwner |
|||
{ |
|||
// All elements are originally owned by the view generator.
|
|||
ElementFactory, |
|||
// Ownership is transferred to the layout when it calls GetElement.
|
|||
Layout, |
|||
// Ownership is transferred to the pinned pool if the element is cleared (outside of
|
|||
// a 'remove' collection change of course).
|
|||
PinnedPool, |
|||
// Ownership is transfered to the reset pool if the element is cleared by a reset and
|
|||
// the data source supports unique ids.
|
|||
UniqueIdResetPool, |
|||
// Ownership is transfered to the animator if the element is cleared due to a
|
|||
// 'remove'-like collection change.
|
|||
Animator |
|||
} |
|||
|
|||
internal class VirtualizationInfo |
|||
{ |
|||
private int _pinCounter; |
|||
private object _data; |
|||
|
|||
public Rect ArrangeBounds { get; set; } |
|||
public bool AutoRecycleCandidate { get; set; } |
|||
public int Index { get; private set; } |
|||
public bool IsPinned => _pinCounter > 0; |
|||
public bool IsHeldByLayout => Owner == ElementOwner.Layout; |
|||
public bool IsRealized => IsHeldByLayout || Owner == ElementOwner.PinnedPool; |
|||
public bool IsInUniqueIdResetPool => Owner == ElementOwner.UniqueIdResetPool; |
|||
public bool KeepAlive { get; set; } |
|||
public ElementOwner Owner { get; private set; } = ElementOwner.ElementFactory; |
|||
public string UniqueId { get; private set; } |
|||
|
|||
public void MoveOwnershipToLayoutFromElementFactory(int index, string uniqueId) |
|||
{ |
|||
Owner = ElementOwner.Layout; |
|||
Index = index; |
|||
UniqueId = uniqueId; |
|||
} |
|||
|
|||
public void MoveOwnershipToLayoutFromUniqueIdResetPool() |
|||
{ |
|||
Owner = ElementOwner.Layout; |
|||
} |
|||
|
|||
public void MoveOwnershipToLayoutFromPinnedPool() |
|||
{ |
|||
Owner = ElementOwner.Layout; |
|||
} |
|||
|
|||
public void MoveOwnershipToElementFactory() |
|||
{ |
|||
Owner = ElementOwner.ElementFactory; |
|||
_pinCounter = 0; |
|||
Index = -1; |
|||
UniqueId = string.Empty; |
|||
ArrangeBounds = ItemsRepeater.InvalidRect; |
|||
} |
|||
|
|||
public void MoveOwnershipToUniqueIdResetPoolFromLayout() |
|||
{ |
|||
Owner = ElementOwner.UniqueIdResetPool; |
|||
// Keep the pinCounter the same. If the container survives the reset
|
|||
// it can go on being pinned as if nothing happened.
|
|||
} |
|||
|
|||
public void MoveOwnershipToAnimator() |
|||
{ |
|||
// During a unique id reset, some elements might get removed.
|
|||
// Their ownership will go from the UniqueIdResetPool to the Animator.
|
|||
// The common path though is for ownership to go from Layout to Animator.
|
|||
Owner = ElementOwner.Animator; |
|||
Index = -1; |
|||
_pinCounter = 0; |
|||
} |
|||
|
|||
public void MoveOwnershipToPinnedPool() |
|||
{ |
|||
Owner = ElementOwner.PinnedPool; |
|||
} |
|||
|
|||
public int AddPin() |
|||
{ |
|||
if (!IsRealized) |
|||
{ |
|||
throw new InvalidOperationException("You can't pin an unrealized element."); |
|||
} |
|||
|
|||
return ++_pinCounter; |
|||
} |
|||
|
|||
public int RemovePin() |
|||
{ |
|||
if (!IsRealized) |
|||
{ |
|||
throw new InvalidOperationException("You can't unpin an unrealized element."); |
|||
} |
|||
|
|||
if (!IsPinned) |
|||
{ |
|||
throw new InvalidOperationException("UnpinElement was called more often than PinElement."); |
|||
} |
|||
|
|||
return --_pinCounter; |
|||
} |
|||
|
|||
public void UpdateIndex(int newIndex) => Index = newIndex; |
|||
} |
|||
} |
|||
@ -1,24 +1,24 @@ |
|||
<UserControl xmlns="https://github.com/avaloniaui" |
|||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" |
|||
x:Class="Avalonia.Diagnostics.DevTools"> |
|||
<Grid RowDefinitions="*,Auto" Margin="4"> |
|||
<Grid RowDefinitions="*,Auto" Margin="4"> |
|||
|
|||
<TabControl Grid.Row="0" Items="{Binding Tools}" SelectedItem="{Binding SelectedTool}"> |
|||
<TabControl.ItemTemplate> |
|||
<DataTemplate> |
|||
<TextBlock Text="{Binding Name}" /> |
|||
</DataTemplate> |
|||
</TabControl.ItemTemplate> |
|||
</TabControl> |
|||
<TabControl Grid.Row="0" Items="{Binding Tools}" SelectedItem="{Binding SelectedTool}"> |
|||
<TabControl.ItemTemplate> |
|||
<DataTemplate> |
|||
<TextBlock Text="{Binding Name}" /> |
|||
</DataTemplate> |
|||
</TabControl.ItemTemplate> |
|||
</TabControl> |
|||
|
|||
<StackPanel Grid.Row="1" Spacing="4" Orientation="Horizontal"> |
|||
<TextBlock>Hold Ctrl+Shift over a control to inspect.</TextBlock> |
|||
<Separator Width="8" /> |
|||
<TextBlock>Focused:</TextBlock> |
|||
<TextBlock Text="{Binding FocusedControl}" /> |
|||
<Separator Width="8" /> |
|||
<TextBlock>Pointer Over:</TextBlock> |
|||
<TextBlock Text="{Binding PointerOverElement}" /> |
|||
</StackPanel> |
|||
</Grid> |
|||
<StackPanel Grid.Row="1" Spacing="4" Orientation="Horizontal"> |
|||
<TextBlock>Hold Ctrl+Shift over a control to inspect.</TextBlock> |
|||
<Separator Width="8" /> |
|||
<TextBlock>Focused:</TextBlock> |
|||
<TextBlock Text="{Binding FocusedControl}" /> |
|||
<Separator Width="8" /> |
|||
<TextBlock>Pointer Over:</TextBlock> |
|||
<TextBlock Text="{Binding PointerOverElement}" /> |
|||
</StackPanel> |
|||
</Grid> |
|||
</UserControl> |
|||
|
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue