open-source-mirrors
/
jellyfin
mirror of https://github.com/jellyfin/jellyfin
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ae4ffa75be'
${ noResults }
jellyfin/MediaBrowser.UI.Controls/VirtualizingWrapPanel.cs

735 lines
28 KiB
Raw Normal View History Unescape

Pushing missing changes
12 years ago
using System;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Media;
namespace MediaBrowser.UI.Controls
{
/// <summary>
/// http://www.codeproject.com/Articles/75847/Virtualizing-WrapPanel
/// Positions child elements in sequential position from left to right, breaking content
/// to the next line at the edge of the containing box. Subsequent ordering happens
/// sequentially from top to bottom or from right to left, depending on the value of
/// the Orientation property.
/// </summary>
[DefaultProperty("Orientation")]
public class VirtualizingWrapPanel : VirtualizingPanel, IScrollInfo
{
/// <summary>
/// Identifies the ItemHeight dependency property.
/// </summary>
public static readonly DependencyProperty ItemHeightProperty = DependencyProperty.Register("ItemHeight", typeof(double), typeof(VirtualizingWrapPanel), new PropertyMetadata(100.0, new PropertyChangedCallback(VirtualizingWrapPanel.OnAppearancePropertyChanged)));
/// <summary>
/// Identifies the Orientation dependency property.
/// </summary>
public static readonly DependencyProperty OrientationProperty = DependencyProperty.Register("Orientation", typeof(Orientation), typeof(VirtualizingWrapPanel), new PropertyMetadata(Orientation.Horizontal, new PropertyChangedCallback(VirtualizingWrapPanel.OnAppearancePropertyChanged)));
/// <summary>
/// Identifies the ItemWidth dependency property.
/// </summary>
public static readonly DependencyProperty ItemWidthProperty = DependencyProperty.Register("ItemWidth", typeof(double), typeof(VirtualizingWrapPanel), new PropertyMetadata(100.0, new PropertyChangedCallback(VirtualizingWrapPanel.OnAppearancePropertyChanged)));
/// <summary>
/// Identifies the ScrollStep dependency property.
/// </summary>
public static readonly DependencyProperty ScrollStepProperty = DependencyProperty.Register("ScrollStep", typeof(double), typeof(VirtualizingWrapPanel), new PropertyMetadata(10.0, new PropertyChangedCallback(VirtualizingWrapPanel.OnAppearancePropertyChanged)));
private bool canHorizontallyScroll;
private bool canVerticallyScroll;
private Size contentExtent = new Size(0.0, 0.0);
private Point contentOffset = default(Point);
private ScrollViewer scrollOwner;
private Size viewport = new Size(0.0, 0.0);
private int previousItemCount;
/// <summary>
/// Gets or sets a value that specifies the height of all items that are
/// contained within a VirtualizingWrapPanel. This is a dependency property.
/// </summary>
public double ItemHeight
{
get
{
return (double)base.GetValue(VirtualizingWrapPanel.ItemHeightProperty);
}
set
{
base.SetValue(VirtualizingWrapPanel.ItemHeightProperty, value);
}
}
/// <summary>
/// Gets or sets a value that specifies the width of all items that are
/// contained within a VirtualizingWrapPanel. This is a dependency property.
/// </summary>
public double ItemWidth
{
get
{
return (double)base.GetValue(VirtualizingWrapPanel.ItemWidthProperty);
}
set
{
base.SetValue(VirtualizingWrapPanel.ItemWidthProperty, value);
}
}
/// <summary>
/// Gets or sets a value that specifies the dimension in which child
/// content is arranged. This is a dependency property.
/// </summary>
public Orientation Orientation
{
get
{
return (Orientation)base.GetValue(VirtualizingWrapPanel.OrientationProperty);
}
set
{
base.SetValue(VirtualizingWrapPanel.OrientationProperty, value);
}
}
/// <summary>
/// Gets or sets a value that indicates whether scrolling on the horizontal axis is possible.
/// </summary>
public bool CanHorizontallyScroll
{
get
{
return this.canHorizontallyScroll;
}
set
{
if (this.canHorizontallyScroll != value)
{
this.canHorizontallyScroll = value;
base.InvalidateMeasure();
}
}
}
/// <summary>
/// Gets or sets a value that indicates whether scrolling on the vertical axis is possible.
/// </summary>
public bool CanVerticallyScroll
{
get
{
return this.canVerticallyScroll;
}
set
{
if (this.canVerticallyScroll != value)
{
this.canVerticallyScroll = value;
base.InvalidateMeasure();
}
}
}
/// <summary>
/// Gets or sets a ScrollViewer element that controls scrolling behavior.
/// </summary>
public ScrollViewer ScrollOwner
{
get
{
return this.scrollOwner;
}
set
{
this.scrollOwner = value;
}
}
/// <summary>
/// Gets the vertical offset of the scrolled content.
/// </summary>
public double VerticalOffset
{
get
{
return this.contentOffset.Y;
}
}
/// <summary>
/// Gets the vertical size of the viewport for this content.
/// </summary>
public double ViewportHeight
{
get
{
return this.viewport.Height;
}
}
/// <summary>
/// Gets the horizontal size of the viewport for this content.
/// </summary>
public double ViewportWidth
{
get
{
return this.viewport.Width;
}
}
/// <summary>
/// Gets or sets a value for mouse wheel scroll step.
/// </summary>
public double ScrollStep
{
get
{
return (double)base.GetValue(VirtualizingWrapPanel.ScrollStepProperty);
}
set
{
base.SetValue(VirtualizingWrapPanel.ScrollStepProperty, value);
}
}
/// <summary>
/// Gets the vertical size of the extent.
/// </summary>
public double ExtentHeight
{
get
{
return this.contentExtent.Height;
}
}
/// <summary>
/// Gets the horizontal size of the extent.
/// </summary>
public double ExtentWidth
{
get
{
return this.contentExtent.Width;
}
}
/// <summary>
/// Gets the horizontal offset of the scrolled content.
/// </summary>
public double HorizontalOffset
{
get
{
return this.contentOffset.X;
}
}
/// <summary>
/// Scrolls down within content by one logical unit.
/// </summary>
public void LineDown()
{
this.SetVerticalOffset(this.VerticalOffset + this.ScrollStep);
}
/// <summary>
/// Scrolls left within content by one logical unit.
/// </summary>
public void LineLeft()
{
this.SetHorizontalOffset(this.HorizontalOffset - this.ScrollStep);
}
/// <summary>
/// Scrolls right within content by one logical unit.
/// </summary>
public void LineRight()
{
this.SetHorizontalOffset(this.HorizontalOffset + this.ScrollStep);
}
/// <summary>
/// Scrolls up within content by one logical unit.
/// </summary>
public void LineUp()
{
this.SetVerticalOffset(this.VerticalOffset - this.ScrollStep);
}
/// <summary>
/// Forces content to scroll until the coordinate space of a Visual object is visible.
/// </summary>
public Rect MakeVisible(Visual visual, Rect rectangle)
{
this.MakeVisible(visual as UIElement);
return rectangle;
}
/// <summary>
/// Scrolls down within content after a user clicks the wheel button on a mouse.
/// </summary>
public void MouseWheelDown()
{
this.SetVerticalOffset(this.VerticalOffset + this.ScrollStep);
}
/// <summary>
/// Scrolls left within content after a user clicks the wheel button on a mouse.
/// </summary>
public void MouseWheelLeft()
{
this.SetHorizontalOffset(this.HorizontalOffset - this.ScrollStep);
}
/// <summary>
/// Scrolls right within content after a user clicks the wheel button on a mouse.
/// </summary>
public void MouseWheelRight()
{
this.SetHorizontalOffset(this.HorizontalOffset + this.ScrollStep);
}
/// <summary>
/// Scrolls up within content after a user clicks the wheel button on a mouse.
/// </summary>
public void MouseWheelUp()
{
this.SetVerticalOffset(this.VerticalOffset - this.ScrollStep);
}
/// <summary>
/// Scrolls down within content by one page.
/// </summary>
public void PageDown()
{
this.SetVerticalOffset(this.VerticalOffset + this.ViewportHeight);
}
/// <summary>
/// Scrolls left within content by one page.
/// </summary>
public void PageLeft()
{
this.SetHorizontalOffset(this.HorizontalOffset - this.ViewportHeight);
}
/// <summary>
/// Scrolls right within content by one page.
/// </summary>
public void PageRight()
{
this.SetHorizontalOffset(this.HorizontalOffset + this.ViewportHeight);
}
/// <summary>
/// Scrolls up within content by one page.
/// </summary>
public void PageUp()
{
this.SetVerticalOffset(this.VerticalOffset - this.viewport.Height);
}
/// <summary>
/// Sets the amount of vertical offset.
/// </summary>
public void SetVerticalOffset(double offset)
{
if (offset < 0.0 || this.ViewportHeight >= this.ExtentHeight)
{
offset = 0.0;
}
else
{
if (offset + this.ViewportHeight >= this.ExtentHeight)
{
offset = this.ExtentHeight - this.ViewportHeight;
}
}
this.contentOffset.Y = offset;
if (this.ScrollOwner != null)
{
this.ScrollOwner.InvalidateScrollInfo();
}
base.InvalidateMeasure();
}
/// <summary>
/// Sets the amount of horizontal offset.
/// </summary>
public void SetHorizontalOffset(double offset)
{
if (offset < 0.0 || this.ViewportWidth >= this.ExtentWidth)
{
offset = 0.0;
}
else
{
if (offset + this.ViewportWidth >= this.ExtentWidth)
{
offset = this.ExtentWidth - this.ViewportWidth;
}
}
this.contentOffset.X = offset;
if (this.ScrollOwner != null)
{
this.ScrollOwner.InvalidateScrollInfo();
}
base.InvalidateMeasure();
}
/// <summary>
/// Note: Works only for vertical.
/// </summary>
internal void PageLast()
{
this.contentOffset.Y = this.ExtentHeight;
if (this.ScrollOwner != null)
{
this.ScrollOwner.InvalidateScrollInfo();
}
base.InvalidateMeasure();
}
/// <summary>
/// Note: Works only for vertical.
/// </summary>
internal void PageFirst()
{
this.contentOffset.Y = 0.0;
if (this.ScrollOwner != null)
{
this.ScrollOwner.InvalidateScrollInfo();
}
base.InvalidateMeasure();
}
/// <summary>
/// When items are removed, remove the corresponding UI if necessary.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
protected override void OnItemsChanged(object sender, ItemsChangedEventArgs args)
{
switch (args.Action)
{
case NotifyCollectionChangedAction.Remove:
case NotifyCollectionChangedAction.Replace:
case NotifyCollectionChangedAction.Move:
base.RemoveInternalChildRange(args.Position.Index, args.ItemUICount);
return;
case NotifyCollectionChangedAction.Reset:
{
ItemsControl itemsControl = ItemsControl.GetItemsOwner(this);
if (itemsControl != null)
{
if (this.previousItemCount != itemsControl.Items.Count)
{
if (this.Orientation == Orientation.Horizontal)
{
this.SetVerticalOffset(0.0);
}
else
{
this.SetHorizontalOffset(0.0);
}
}
this.previousItemCount = itemsControl.Items.Count;
}
return;
}
default:
return;
}
}
/// <summary>
/// Measure the children.
/// </summary>
/// <param name="availableSize">The available size.</param>
/// <returns>The desired size.</returns>
protected override Size MeasureOverride(Size availableSize)
{
this.InvalidateScrollInfo(availableSize);
int firstVisibleIndex;
int lastVisibleIndex;
if (this.Orientation == Orientation.Horizontal)
{
this.GetVerticalVisibleRange(out firstVisibleIndex, out lastVisibleIndex);
}
else
{
this.GetHorizontalVisibleRange(out firstVisibleIndex, out lastVisibleIndex);
}
UIElementCollection children = base.Children;
IItemContainerGenerator generator = base.ItemContainerGenerator;
if (generator != null)
{
GeneratorPosition startPos = generator.GeneratorPositionFromIndex(firstVisibleIndex);
int childIndex = (startPos.Offset == 0) ? startPos.Index : (startPos.Index + 1);
if (childIndex == -1)
{
this.RefreshOffset();
}
using (generator.StartAt(startPos, GeneratorDirection.Forward, true))
{
int itemIndex = firstVisibleIndex;
while (itemIndex <= lastVisibleIndex)
{
bool newlyRealized;
UIElement child = generator.GenerateNext(out newlyRealized) as UIElement;
if (newlyRealized)
{
if (childIndex >= children.Count)
{
base.AddInternalChild(child);
}
else
{
base.InsertInternalChild(childIndex, child);
}
generator.PrepareItemContainer(child);
}
if (child != null)
{
child.Measure(new Size(this.ItemWidth, this.ItemHeight));
}
itemIndex++;
childIndex++;
}
}
this.CleanUpChildren(firstVisibleIndex, lastVisibleIndex);
}
if (IsCloseTo(availableSize.Height, double.PositiveInfinity) || IsCloseTo(availableSize.Width, double.PositiveInfinity))
{
return base.MeasureOverride(availableSize);
}
var itemsControl = ItemsControl.GetItemsOwner(this);
var numItems = itemsControl.Items.Count;
var width = availableSize.Width;
var height = availableSize.Height;
if (Orientation == Orientation.Vertical)
{
var numRows = Math.Floor(availableSize.Height / ItemHeight);
height = numRows * ItemHeight;
var requiredColumns = Math.Ceiling(numItems / numRows);
width = Math.Min(requiredColumns * ItemWidth, width);
}
else
{
var numColumns = Math.Floor(availableSize.Width / ItemWidth);
width = numColumns * ItemWidth;
//if (numItems > 0 && numItems < numColumns)
//{
// width = Math.Min(numColumns, numItems) * ItemWidth;
//}
var requiredRows = Math.Ceiling(numItems / numColumns);
height = Math.Min(requiredRows * ItemHeight, height);
}
return new Size(width, height);
}
/// <summary>
/// Arranges the children.
/// </summary>
/// <param name="finalSize">The available size.</param>
/// <returns>The used size.</returns>
protected override Size ArrangeOverride(Size finalSize)
{
bool isHorizontal = this.Orientation == Orientation.Horizontal;
this.InvalidateScrollInfo(finalSize);
int i = 0;
foreach (object item in base.Children)
{
this.ArrangeChild(isHorizontal, finalSize, i++, item as UIElement);
}
return finalSize;
}
private static void OnAppearancePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
UIElement panel = d as UIElement;
if (panel != null)
{
panel.InvalidateMeasure();
}
}
private void MakeVisible(UIElement element)
{
ItemContainerGenerator generator = base.ItemContainerGenerator.GetItemContainerGeneratorForPanel(this);
if (element != null && generator != null)
{
for (int itemIndex = generator.IndexFromContainer(element); itemIndex == -1; itemIndex = generator.IndexFromContainer(element))
{
element = element.ParentOfType<UIElement>();
}
ScrollViewer scrollViewer = element.ParentOfType<ScrollViewer>();
if (scrollViewer != null)
{
GeneralTransform elementTransform = element.TransformToVisual(scrollViewer);
Rect elementRectangle = elementTransform.TransformBounds(new Rect(new Point(0.0, 0.0), element.RenderSize));
if (this.Orientation == Orientation.Horizontal)
{
var padding = ItemHeight / 3;
if (elementRectangle.Bottom > this.ViewportHeight)
{
this.SetVerticalOffset(this.contentOffset.Y + elementRectangle.Bottom - this.ViewportHeight + padding);
return;
}
if (elementRectangle.Top < 0.0)
{
this.SetVerticalOffset(this.contentOffset.Y + elementRectangle.Top - padding);
return;
}
}
else
{
var padding = ItemWidth / 3;
if (elementRectangle.Right > this.ViewportWidth)
{
this.SetHorizontalOffset(this.contentOffset.X + elementRectangle.Right - this.ViewportWidth + padding);
return;
}
if (elementRectangle.Left < 0.0)
{
this.SetHorizontalOffset(this.contentOffset.X + elementRectangle.Left - padding);
}
}
}
}
}
private void GetVerticalVisibleRange(out int firstVisibleItemIndex, out int lastVisibleItemIndex)
{
int childrenPerRow = this.GetVerticalChildrenCountPerRow(this.contentExtent);
firstVisibleItemIndex = (int)Math.Floor(this.VerticalOffset / this.ItemHeight) * childrenPerRow;
lastVisibleItemIndex = (int)Math.Ceiling((this.VerticalOffset + this.ViewportHeight) / this.ItemHeight) * childrenPerRow - 1;
this.AdjustVisibleRange(ref firstVisibleItemIndex, ref lastVisibleItemIndex);
}
private void GetHorizontalVisibleRange(out int firstVisibleItemIndex, out int lastVisibleItemIndex)
{
int childrenPerRow = this.GetHorizontalChildrenCountPerRow(this.contentExtent);
firstVisibleItemIndex = (int)Math.Floor(this.HorizontalOffset / this.ItemWidth) * childrenPerRow;
lastVisibleItemIndex = (int)Math.Ceiling((this.HorizontalOffset + this.ViewportWidth) / this.ItemWidth) * childrenPerRow - 1;
this.AdjustVisibleRange(ref firstVisibleItemIndex, ref lastVisibleItemIndex);
}
private void AdjustVisibleRange(ref int firstVisibleItemIndex, ref int lastVisibleItemIndex)
{
firstVisibleItemIndex--;
lastVisibleItemIndex++;
ItemsControl itemsControl = ItemsControl.GetItemsOwner(this);
if (itemsControl != null)
{
if (firstVisibleItemIndex < 0)
{
firstVisibleItemIndex = 0;
}
if (lastVisibleItemIndex >= itemsControl.Items.Count)
{
lastVisibleItemIndex = itemsControl.Items.Count - 1;
}
}
}
private void CleanUpChildren(int minIndex, int maxIndex)
{
UIElementCollection children = base.Children;
IItemContainerGenerator generator = base.ItemContainerGenerator;
for (int i = children.Count - 1; i >= 0; i--)
{
GeneratorPosition pos = new GeneratorPosition(i, 0);
int itemIndex = generator.IndexFromGeneratorPosition(pos);
if (itemIndex < minIndex || itemIndex > maxIndex)
{
generator.Remove(pos, 1);
base.RemoveInternalChildRange(i, 1);
}
}
}
private void ArrangeChild(bool isHorizontal, Size finalSize, int index, UIElement child)
{
if (child == null)
{
return;
}
int count = isHorizontal ? this.GetVerticalChildrenCountPerRow(finalSize) : this.GetHorizontalChildrenCountPerRow(finalSize);
int itemIndex = base.ItemContainerGenerator.IndexFromGeneratorPosition(new GeneratorPosition(index, 0));
int row = isHorizontal ? (itemIndex / count) : (itemIndex % count);
int column = isHorizontal ? (itemIndex % count) : (itemIndex / count);
Rect rect = new Rect((double)column * this.ItemWidth, (double)row * this.ItemHeight, this.ItemWidth, this.ItemHeight);
if (isHorizontal)
{
rect.Y -= this.VerticalOffset;
}
else
{
rect.X -= this.HorizontalOffset;
}
child.Arrange(rect);
}
private void InvalidateScrollInfo(Size availableSize)
{
ItemsControl ownerItemsControl = ItemsControl.GetItemsOwner(this);
if (ownerItemsControl != null)
{
Size extent = this.GetExtent(availableSize, ownerItemsControl.Items.Count);
if (extent != this.contentExtent)
{
this.contentExtent = extent;
this.RefreshOffset();
}
if (availableSize != this.viewport)
{
this.viewport = availableSize;
this.InvalidateScrollOwner();
}
}
}
private void RefreshOffset()
{
if (this.Orientation == Orientation.Horizontal)
{
this.SetVerticalOffset(this.VerticalOffset);
return;
}
this.SetHorizontalOffset(this.HorizontalOffset);
}
private void InvalidateScrollOwner()
{
if (this.ScrollOwner != null)
{
this.ScrollOwner.InvalidateScrollInfo();
}
}
private Size GetExtent(Size availableSize, int itemCount)
{
if (this.Orientation == Orientation.Horizontal)
{
int childrenPerRow = this.GetVerticalChildrenCountPerRow(availableSize);
return new Size((double)childrenPerRow * this.ItemWidth, this.ItemHeight * Math.Ceiling((double)itemCount / (double)childrenPerRow));
}
int childrenPerRow2 = this.GetHorizontalChildrenCountPerRow(availableSize);
return new Size(this.ItemWidth * Math.Ceiling((double)itemCount / (double)childrenPerRow2), (double)childrenPerRow2 * this.ItemHeight);
}
private int GetVerticalChildrenCountPerRow(Size availableSize)
{
int childrenCountPerRow;
if (availableSize.Width == double.PositiveInfinity)
{
childrenCountPerRow = base.Children.Count;
}
else
{
childrenCountPerRow = Math.Max(1, (int)Math.Floor(availableSize.Width / this.ItemWidth));
}
return childrenCountPerRow;
}
private int GetHorizontalChildrenCountPerRow(Size availableSize)
{
int childrenCountPerRow;
if (availableSize.Height == double.PositiveInfinity)
{
childrenCountPerRow = base.Children.Count;
}
else
{
childrenCountPerRow = Math.Max(1, (int)Math.Floor(availableSize.Height / this.ItemHeight));
}
return childrenCountPerRow;
}
private static bool IsCloseTo(double value1, double value2)
{
return AreClose(value1, value2);
}
private static bool AreClose(double value1, double value2)
{
if (value1 == value2)
{
return true;
}
double num = (Math.Abs(value1) + Math.Abs(value2) + 10.0) * 2.2204460492503131E-16;
double num2 = value1 - value2;
return -num < num2 && num > num2;
}
}
}