tsai
/
Avalonia
mirror of https://github.com/AvaloniaUI/Avalonia.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Remove old Grid classes.

pull/2563/head
Jumar Macato 7 years ago
parent
973e82386e
commit
52c562bffd
No known key found for this signature in database GPG Key ID: B19884DAC3A5BF3F
6 changed files with 2555 additions and 4696 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      src/Avalonia.Controls/Avalonia.Controls.csproj
  2. 2886
      src/Avalonia.Controls/Grid.cs
  3. 2824
      src/Avalonia.Controls/GridWPF.cs
  4. 705
      src/Avalonia.Controls/Utils/GridLayout.cs
  5. 651
      src/Avalonia.Controls/Utils/SharedSizeScopeHost.cs
  6. 184
      tests/Avalonia.Controls.UnitTests/GridLayoutTests.cs

1
src/Avalonia.Controls/Avalonia.Controls.csproj
View File

@ -11,7 +11,6 @@
<ProjectReference Include="..\Avalonia.Remote.Protocol\Avalonia.Remote.Protocol.csproj" />
<ProjectReference Include="..\Avalonia.Visuals\Avalonia.Visuals.csproj" />
<ProjectReference Include="..\Avalonia.Styling\Avalonia.Styling.csproj" />
<Compile Remove="Grid.cs"/>
</ItemGroup>
<Import Project="..\..\build\Rx.props" />
<Import Project="..\..\build\JetBrains.Annotations.props" />

2886
src/Avalonia.Controls/Grid.cs
View File

File diff suppressed because it is too large

2824
src/Avalonia.Controls/GridWPF.cs
View File

File diff suppressed because it is too large

705
src/Avalonia.Controls/Utils/GridLayout.cs
View File

@ -1,705 +0,0 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Runtime.CompilerServices;
using Avalonia.Layout;
using JetBrains.Annotations;
namespace Avalonia.Controls.Utils
{
/// <summary>
/// Contains algorithms that can help to measure and arrange a Grid.
/// </summary>
internal class GridLayout
{
/// <summary>
/// Initialize a new <see cref="GridLayout"/> instance from the column definitions.
/// The instance doesn't care about whether the definitions are rows or columns.
/// It will not calculate the column or row differently.
/// </summary>
internal GridLayout([NotNull] ColumnDefinitions columns)
{
if (columns == null) throw new ArgumentNullException(nameof(columns));
_conventions = columns.Count == 0
? new List<LengthConvention> { new LengthConvention() }
: columns.Select(x => new LengthConvention(x.Width, x.MinWidth, x.MaxWidth)).ToList();
}
/// <summary>
/// Initialize a new <see cref="GridLayout"/> instance from the row definitions.
/// The instance doesn't care about whether the definitions are rows or columns.
/// It will not calculate the column or row differently.
/// </summary>
internal GridLayout([NotNull] RowDefinitions rows)
{
if (rows == null) throw new ArgumentNullException(nameof(rows));
_conventions = rows.Count == 0
? new List<LengthConvention> { new LengthConvention() }
: rows.Select(x => new LengthConvention(x.Height, x.MinHeight, x.MaxHeight)).ToList();
}
/// <summary>
/// Gets the layout tolerance. If any length offset is less than this value, we will treat them the same.
/// </summary>
private const double LayoutTolerance = 1.0 / 256.0;
/// <summary>
/// Gets all the length conventions that come from column/row definitions.
/// These conventions provide cell limitations, such as the expected pixel length, the min/max pixel length and the * count.
/// </summary>
[NotNull]
private readonly List<LengthConvention> _conventions;
/// <summary>
/// Gets all the length conventions that come from the grid children.
/// </summary>
[NotNull]
private readonly List<AdditionalLengthConvention> _additionalConventions =
new List<AdditionalLengthConvention>();
/// <summary>
/// Appending these elements into the convention list helps lay them out according to their desired sizes.
/// <para/>
/// Some elements are not only in a single grid cell, they have one or more column/row spans,
/// and these elements may affect the grid layout especially the measuring procedure.<para/>
/// Append these elements into the convention list can help to layout them correctly through
/// their desired size. Only a small subset of children need to be measured before layout starts
/// and they will be called via the<paramref name="getDesiredLength"/> callback.
/// </summary>
/// <typeparam name="T">The grid children type.</typeparam>
/// <param name="source">
/// Contains the safe column/row index and its span.
/// Notice that we will not verify whether the range is in the column/row count,
/// so you should get the safe column/row info first.
/// </param>
/// <param name="getDesiredLength">
/// This callback will be called if the <see cref="GridLayout"/> thinks that a child should be
/// measured first. Usually, these are the children that have the * or Auto length.
/// </param>
internal void AppendMeasureConventions<T>([NotNull] IDictionary<T, (int index, int span)> source,
[NotNull] Func<T, double> getDesiredLength)
{
if (source == null) throw new ArgumentNullException(nameof(source));
if (getDesiredLength == null) throw new ArgumentNullException(nameof(getDesiredLength));
// M1/7. Find all the Auto and * length columns/rows. (M1/7 means the 1st procedure of measurement.)
// Only these columns/rows' layout can be affected by the child desired size.
//
// Find all columns/rows that have Auto or * length. We'll measure the children in advance.
// Only these kind of columns/rows will affect the Grid layout.
// Please note:
// - If the column / row has Auto length, the Grid.DesiredSize and the column width
// will be affected by the child's desired size.
// - If the column / row has* length, the Grid.DesiredSize will be affected by the
// child's desired size but the column width not.
// +-----------------------------------------------------------+
// | * | A | * | P | A | * | P | * | * |
// +-----------------------------------------------------------+
// _conventions: | min | max | | | min | | min max | max |
// _additionalC: |<- desired ->| |< desired >|
// _additionalC: |< desired >| |<- desired ->|
// 寻找所有行列范围中包含 Auto 和 * 的元素，使用全部可用尺寸提前测量。
// 因为只有这部分元素的布局才会被 Grid 的子元素尺寸影响。
// 请注意：
// - Auto 长度的行列必定会受到子元素布局影响，会影响到行列的布局长度和 Grid 本身的 DesiredSize；
// - 而对于 * 长度，只有 Grid.DesiredSize 会受到子元素布局影响，而行列长度不会受影响。
// Find all the Auto and * length columns/rows.
var found = new Dictionary<T, (int index, int span)>();
for (var i = 0; i < _conventions.Count; i++)
{
var index = i;
var convention = _conventions[index];
if (convention.Length.IsAuto || convention.Length.IsStar)
{
foreach (var pair in source.Where(x =>
x.Value.index <= index && index < x.Value.index + x.Value.span))
{
found[pair.Key] = pair.Value;
}
}
}
// Append these layout into the additional convention list.
foreach (var pair in found)
{
var t = pair.Key;
var (index, span) = pair.Value;
var desiredLength = getDesiredLength(t);
if (Math.Abs(desiredLength) > LayoutTolerance)
{
_additionalConventions.Add(new AdditionalLengthConvention(index, span, desiredLength));
}
}
}
/// <summary>
/// Run measure procedure according to the <paramref name="containerLength"/> and gets the <see cref="MeasureResult"/>.
/// </summary>
/// <param name="containerLength">
/// The container length. Usually, it is the constraint of the <see cref="Layoutable.MeasureOverride"/> method.
/// </param>
/// <param name="conventions">
/// Overriding conventions that allows the algorithm to handle external inputa
/// </param>
/// <returns>
/// The measured result that containing the desired size and all the column/row lengths.
/// </returns>
[NotNull, Pure]
internal MeasureResult Measure(double containerLength, IReadOnlyList<LengthConvention> conventions = null)
{
// Prepare all the variables that this method needs to use.
conventions = conventions ?? _conventions.Select(x => x.Clone()).ToList();
var starCount = conventions.Where(x => x.Length.IsStar).Sum(x => x.Length.Value);
var aggregatedLength = 0.0;
double starUnitLength;
// M2/7. Aggregate all the pixel lengths. Then we can get the remaining length by `containerLength - aggregatedLength`.
// We mark the aggregated length as "fix" because we can completely determine their values. Same as below.
//
// +-----------------------------------------------------------+
// | * | A | * | P | A | * | P | * | * |
// +-----------------------------------------------------------+
// |#fix#| |#fix#|
//
// 将全部的固定像素长度的行列长度累加。这样，containerLength - aggregatedLength 便能得到剩余长度。
// 我们会将所有能够确定下长度的行列标记为 fix。下同。
// 请注意：
// - 我们并没有直接从 containerLength 一直减下去，而是使用 aggregatedLength 进行累加，是因为无穷大相减得到的是 NaN，不利于后续计算。
aggregatedLength += conventions.Where(x => x.Length.IsAbsolute).Sum(x => x.Length.Value);
// M3/7. Fix all the * lengths that have reached the minimum.
//
// +-----------------------------------------------------------+
// | * | A | * | P | A | * | P | * | * |
// +-----------------------------------------------------------+
// | min | max | | | min | | min max | max |
// | fix | |#fix#| fix |
var shouldTestStarMin = true;
while (shouldTestStarMin)
{
// Calculate the unit * length to estimate the length of each column/row that has * length.
// Under this estimated length, check if there is a minimum value that has a length less than its constraint.
// If there is such a *, then fix the size of this cell, and then loop it again until there is no * that can be constrained by the minimum value.
//
// 计算单位 * 的长度，以便预估出每一个 * 行列的长度。
// 在此预估的长度下，从前往后寻找是否存在某个 * 长度已经小于其约束的最小值。
// 如果发现存在这样的 *，那么将此单元格的尺寸固定下来（Fix），然后循环重来，直至再也没有能被最小值约束的 *。
var @fixed = false;
starUnitLength = (containerLength - aggregatedLength) / starCount;
foreach (var convention in conventions.Where(x => x.Length.IsStar))
{
var (star, min) = (convention.Length.Value, convention.MinLength);
var starLength = star * starUnitLength;
if (starLength < min)
{
convention.Fix(min);
starLength = min;
aggregatedLength += starLength;
starCount -= star;
@fixed = true;
break;
}
}
shouldTestStarMin = @fixed;
}
// M4/7. Determine the absolute pixel size of all columns/rows that have an Auto length.
//
// +-----------------------------------------------------------+
// | * | A | * | P | A | * | P | * | * |
// +-----------------------------------------------------------+
// | min | max | | | min | | min max | max |
// |#fix#| | fix |#fix#| fix | fix |
var shouldTestAuto = true;
while (shouldTestAuto)
{
var @fixed = false;
starUnitLength = (containerLength - aggregatedLength) / starCount;
for (var i = 0; i < conventions.Count; i++)
{
var convention = conventions[i];
if (!convention.Length.IsAuto)
{
continue;
}
var more = ApplyAdditionalConventionsForAuto(conventions, i, starUnitLength);
convention.Fix(more);
aggregatedLength += more;
@fixed = true;
break;
}
shouldTestAuto = @fixed;
}
// M5/7. Expand the stars according to the additional conventions (usually the child desired length).
// We can't fix this kind of length, so we just mark them as desired (des).
//
// +-----------------------------------------------------------+
// | * | A | * | P | A | * | P | * | * |
// +-----------------------------------------------------------+
// | min | max | | | min | | min max | max |
// |#des#| fix |#des#| fix | fix | fix | fix | #des# |#des#|
var (minLengths, desiredStarMin) = AggregateAdditionalConventionsForStars(conventions);
aggregatedLength += desiredStarMin;
// M6/7. Determine the desired length of the grid for current container length. Its value is stored in desiredLength.
// Assume if the container has infinite length, the grid desired length is stored in greedyDesiredLength.
//
// +-----------------------------------------------------------+
// | * | A | * | P | A | * | P | * | * |
// +-----------------------------------------------------------+
// | min | max | | | min | | min max | max |
// |#des#| fix |#des#| fix | fix | fix | fix | #des# |#des#|
// Note: This table will be stored as the intermediate result into the MeasureResult and it will be reused by Arrange procedure.
//
// desiredLength = Math.Max(0.0, des + fix + des + fix + fix + fix + fix + des + des)
// greedyDesiredLength = des + fix + des + fix + fix + fix + fix + des + des
var desiredLength = containerLength - aggregatedLength >= 0.0 ? aggregatedLength : containerLength;
var greedyDesiredLength = aggregatedLength;
// M7/7. Expand all the rest stars. These stars have no conventions or only have
// max value they can be expanded from zero to constraint.
//
// +-----------------------------------------------------------+
// | * | A | * | P | A | * | P | * | * |
// +-----------------------------------------------------------+
// | min | max | | | min | | min max | max |
// |#fix#| fix |#fix#| fix | fix | fix | fix | #fix# |#fix#|
// Note: This table will be stored as the final result into the MeasureResult.
var dynamicConvention = ExpandStars(conventions, containerLength);
Clip(dynamicConvention, containerLength);
// Returns the measuring result.
return new MeasureResult(containerLength, desiredLength, greedyDesiredLength,
conventions, dynamicConvention, minLengths);
}
/// <summary>
/// Run arrange procedure according to the <paramref name="measure"/> and gets the <see cref="ArrangeResult"/>.
/// </summary>
/// <param name="finalLength">
/// The container length. Usually, it is the finalSize of the <see cref="Layoutable.ArrangeOverride"/> method.
/// </param>
/// <param name="measure">
/// The result that the measuring procedure returns. If it is null, a new measure procedure will run.
/// </param>
/// <returns>
/// The measured result that containing the desired size and all the column/row length.
/// </returns>
[NotNull, Pure]
public ArrangeResult Arrange(double finalLength, [CanBeNull] MeasureResult measure)
{
measure = measure ?? Measure(finalLength);
// If the arrange final length does not equal to the measure length, we should measure again.
if (finalLength - measure.ContainerLength > LayoutTolerance)
{
// If the final length is larger, we will rerun the whole measure.
measure = Measure(finalLength, measure.LeanLengthList);
}
else if (finalLength - measure.ContainerLength < -LayoutTolerance)
{
// If the final length is smaller, we measure the M6/6 procedure only.
var dynamicConvention = ExpandStars(measure.LeanLengthList, finalLength);
measure = new MeasureResult(finalLength, measure.DesiredLength, measure.GreedyDesiredLength,
measure.LeanLengthList, dynamicConvention, measure.MinLengths);
}
return new ArrangeResult(measure.LengthList);
}
/// <summary>
/// Use the <see cref="_additionalConventions"/> to calculate the fixed length of the Auto column/row.
/// </summary>
/// <param name="conventions">The convention list that all the * with minimum length are fixed.</param>
/// <param name="index">The column/row index that should be fixed.</param>
/// <param name="starUnitLength">The unit * length for the current rest length.</param>
/// <returns>The final length of the Auto length column/row.</returns>
[Pure]
private double ApplyAdditionalConventionsForAuto(IReadOnlyList<LengthConvention> conventions,
int index, double starUnitLength)
{
// 1. Calculate all the * length with starUnitLength.
// 2. Exclude all the fixed length and all the * length.
// 3. Compare the rest of the desired length and the convention.
// +-----------------+
// | * | A | * |
// +-----------------+
// | exl | | exl |
// |< desired >|
// |< desired >|
var more = 0.0;
foreach (var additional in _additionalConventions)
{
// If the additional convention's last column/row contains the Auto column/row, try to determine the Auto column/row length.
if (index == additional.Index + additional.Span - 1)
{
var min = Enumerable.Range(additional.Index, additional.Span)
.Select(x =>
{
var c = conventions[x];
if (c.Length.IsAbsolute) return c.Length.Value;
if (c.Length.IsStar) return c.Length.Value * starUnitLength;
return 0.0;
}).Sum();
more = Math.Max(additional.Min - min, more);
}
}
return Math.Min(conventions[index].MaxLength, more);
}
/// <summary>
/// Calculate the total desired length of all the * length.
/// Bug Warning:
/// - The behavior of this method is undefined! Different UI Frameworks have different behaviors.
/// - We ignore all the span columns/rows and just take single cells into consideration.
/// </summary>
/// <param name="conventions">All the conventions that have almost been fixed except the rest *.</param>
/// <returns>The total desired length of all the * length.</returns>
[Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
private (List<double>, double) AggregateAdditionalConventionsForStars(
IReadOnlyList<LengthConvention> conventions)
{
// 1. Determine all one-span column's desired widths or row's desired heights.
// 2. Order the multi-span conventions by its last index
// (Notice that the sorted data is much smaller than the source.)
// 3. Determine each multi-span last index by calculating the maximum desired size.
// Before we determine the behavior of this method, we just aggregate the one-span * columns.
var fixedLength = conventions.Where(x => x.Length.IsAbsolute).Sum(x => x.Length.Value);
// Prepare a lengthList variable indicating the fixed length of each column/row.
var lengthList = conventions.Select(x => x.Length.IsAbsolute ? x.Length.Value : 0.0).ToList();
foreach (var group in _additionalConventions
.Where(x => x.Span == 1 && conventions[x.Index].Length.IsStar)
.ToLookup(x => x.Index))
{
lengthList[group.Key] = Math.Max(lengthList[group.Key], group.Max(x => x.Min));
}
// Now the lengthList is fixed by every one-span columns/rows.
// Then we should determine the multi-span column's/row's length.
foreach (var group in _additionalConventions
.Where(x => x.Span > 1)
.ToLookup(x => x.Index + x.Span - 1)
// Order the multi-span columns/rows by last index.
.OrderBy(x => x.Key))
{
var length = group.Max(x => x.Min - Enumerable.Range(x.Index, x.Span - 1).Sum(r => lengthList[r]));
lengthList[group.Key] = Math.Max(lengthList[group.Key], length > 0 ? length : 0);
}
return (lengthList, lengthList.Sum() - fixedLength);
}
/// <summary>
/// This method implements the last procedure (M7/7) of measure.
/// It expands all the * length to the fixed length according to the <paramref name="constraint"/>.
/// </summary>
/// <param name="conventions">All the conventions that have almost been fixed except the remaining *.</param>
/// <param name="constraint">The container length.</param>
/// <returns>The final pixel length list.</returns>
[Pure]
private static List<double> ExpandStars(IEnumerable<LengthConvention> conventions, double constraint)
{
// Initial.
var dynamicConvention = conventions.Select(x => x.Clone()).ToList();
constraint -= dynamicConvention.Where(x => x.Length.IsAbsolute).Sum(x => x.Length.Value);
var starUnitLength = 0.0;
// M6/6.
if (constraint >= 0)
{
var starCount = dynamicConvention.Where(x => x.Length.IsStar).Sum(x => x.Length.Value);
var shouldTestStarMax = true;
while (shouldTestStarMax)
{
var @fixed = false;
starUnitLength = constraint / starCount;
foreach (var convention in dynamicConvention.Where(x =>
x.Length.IsStar && !double.IsPositiveInfinity(x.MaxLength)))
{
var (star, max) = (convention.Length.Value, convention.MaxLength);
var starLength = star * starUnitLength;
if (starLength > max)
{
convention.Fix(max);
starLength = max;
constraint -= starLength;
starCount -= star;
@fixed = true;
break;
}
}
shouldTestStarMax = @fixed;
}
}
Debug.Assert(dynamicConvention.All(x => !x.Length.IsAuto));
var starUnit = starUnitLength;
var result = dynamicConvention.Select(x =>
{
if (x.Length.IsStar)
{
return double.IsInfinity(starUnit) ? double.PositiveInfinity : starUnit * x.Length.Value;
}
return x.Length.Value;
}).ToList();
return result;
}
/// <summary>
/// If the container length is not infinity. It may be not enough to contain all the columns/rows.
/// We should clip the columns/rows that have been out of the container bounds.
/// Note: This method may change the items value of <paramref name="lengthList"/>.
/// </summary>
/// <param name="lengthList">A list of all the column widths and row heights with a fixed pixel length</param>
/// <param name="constraint">the container length. It can be positive infinity.</param>
private static void Clip([NotNull] IList<double> lengthList, double constraint)
{
if (double.IsInfinity(constraint))
{
return;
}
var measureLength = 0.0;
for (var i = 0; i < lengthList.Count; i++)
{
var length = lengthList[i];
if (constraint - measureLength > length)
{
measureLength += length;
}
else
{
lengthList[i] = constraint - measureLength;
measureLength = constraint;
}
}
}
/// <summary>
/// Contains the convention of each column/row.
/// This is mostly the same as <see cref="RowDefinition"/> or <see cref="ColumnDefinition"/>.
/// We use this because we can treat the column and the row the same.
/// </summary>
[DebuggerDisplay("{" + nameof(DebuggerDisplay) + ",nq}")]
internal class LengthConvention : ICloneable
{
/// <summary>
/// Initialize a new instance of <see cref="LengthConvention"/>.
/// </summary>
public LengthConvention()
{
Length = new GridLength(1.0, GridUnitType.Star);
MinLength = 0.0;
MaxLength = double.PositiveInfinity;
}
/// <summary>
/// Initialize a new instance of <see cref="LengthConvention"/>.
/// </summary>
public LengthConvention(GridLength length, double minLength, double maxLength)
{
Length = length;
MinLength = minLength;
MaxLength = maxLength;
if (length.IsAbsolute)
{
_isFixed = true;
}
}
/// <summary>
/// Gets the <see cref="GridLength"/> of a column or a row.
/// </summary>
internal GridLength Length { get; private set; }
/// <summary>
/// Gets the minimum convention for a column or a row.
/// </summary>
internal double MinLength { get; }
/// <summary>
/// Gets the maximum convention for a column or a row.
/// </summary>
internal double MaxLength { get; }
/// <summary>
/// Fix the <see cref="LengthConvention"/>.
/// If all columns/rows are fixed, we can get the size of all columns/rows in pixels.
/// </summary>
/// <param name="pixel">
/// The pixel length that should be used to fix the convention.
/// </param>
/// <exception cref="InvalidOperationException">
/// If the convention is pixel length, this exception will throw.
/// </exception>
public void Fix(double pixel)
{
if (_isFixed)
{
throw new InvalidOperationException("Cannot fix the length convention if it is fixed.");
}
Length = new GridLength(pixel);
_isFixed = true;
}
/// <summary>
/// Gets a value that indicates whether this convention is fixed.
/// </summary>
private bool _isFixed;
/// <summary>
/// Helps the debugger to display the intermediate column/row calculation result.
/// </summary>
private string DebuggerDisplay =>
$"{(_isFixed ? Length.Value.ToString(CultureInfo.InvariantCulture) : (Length.GridUnitType == GridUnitType.Auto ? "Auto" : $"{Length.Value}*"))}, ∈[{MinLength}, {MaxLength}]";
/// <inheritdoc />
object ICloneable.Clone() => Clone();
/// <summary>
/// Get a deep copy of this convention list.
/// We need this because we want to store some intermediate states.
/// </summary>
internal LengthConvention Clone() => new LengthConvention(Length, MinLength, MaxLength);
}
/// <summary>
/// Contains the convention that comes from the grid children.
/// Some children span multiple columns or rows, so even a simple column/row can have multiple conventions.
/// </summary>
[DebuggerDisplay("{" + nameof(DebuggerDisplay) + ",nq}")]
internal struct AdditionalLengthConvention
{
/// <summary>
/// Initialize a new instance of <see cref="AdditionalLengthConvention"/>.
/// </summary>
public AdditionalLengthConvention(int index, int span, double min)
{
Index = index;
Span = span;
Min = min;
}
/// <summary>
/// Gets the start index of this additional convention.
/// </summary>
public int Index { get; }
/// <summary>
/// Gets the span of this additional convention.
/// </summary>
public int Span { get; }
/// <summary>
/// Gets the minimum length of this additional convention.
/// This value is usually provided by the child's desired length.
/// </summary>
public double Min { get; }
/// <summary>
/// Helps the debugger to display the intermediate column/row calculation result.
/// </summary>
private string DebuggerDisplay =>
$"{{{string.Join(",", Enumerable.Range(Index, Span))}}}, ∈[{Min},∞)";
}
/// <summary>
/// Stores the result of the measuring procedure.
/// This result can be used to measure children and assign the desired size.
/// Passing this result to <see cref="Arrange"/> can reduce calculation.
/// </summary>
[DebuggerDisplay("{" + nameof(LengthList) + ",nq}")]
internal class MeasureResult
{
/// <summary>
/// Initialize a new instance of <see cref="MeasureResult"/>.
/// </summary>
internal MeasureResult(double containerLength, double desiredLength, double greedyDesiredLength,
IReadOnlyList<LengthConvention> leanConventions, IReadOnlyList<double> expandedConventions, IReadOnlyList<double> minLengths)
{
ContainerLength = containerLength;
DesiredLength = desiredLength;
GreedyDesiredLength = greedyDesiredLength;
LeanLengthList = leanConventions;
LengthList = expandedConventions;
MinLengths = minLengths;
}
/// <summary>
/// Gets the container length for this result.
/// This property will be used by <see cref="Arrange"/> to determine whether to measure again or not.
/// </summary>
public double ContainerLength { get; }
/// <summary>
/// Gets the desired length of this result.
/// Just return this value as the desired size in <see cref="Layoutable.MeasureOverride"/>.
/// </summary>
public double DesiredLength { get; }
/// <summary>
/// Gets the desired length if the container has infinite length.
/// </summary>
public double GreedyDesiredLength { get; }
/// <summary>
/// Contains the column/row calculation intermediate result.
/// This value is used by <see cref="Arrange"/> for reducing repeat calculation.
/// </summary>
public IReadOnlyList<LengthConvention> LeanLengthList { get; }
/// <summary>
/// Gets the length list for each column/row.
/// </summary>
public IReadOnlyList<double> LengthList { get; }
public IReadOnlyList<double> MinLengths { get; }
}
/// <summary>
/// Stores the result of the measuring procedure.
/// This result can be used to arrange children and assign the render size.
/// </summary>
[DebuggerDisplay("{" + nameof(LengthList) + ",nq}")]
internal class ArrangeResult
{
/// <summary>
/// Initialize a new instance of <see cref="ArrangeResult"/>.
/// </summary>
internal ArrangeResult(IReadOnlyList<double> lengthList)
{
LengthList = lengthList;
}
/// <summary>
/// Gets the length list for each column/row.
/// </summary>
public IReadOnlyList<double> LengthList { get; }
}
}
}

651
src/Avalonia.Controls/Utils/SharedSizeScopeHost.cs
View File

@ -1,651 +0,0 @@
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Reactive.Disposables;
using System.Reactive.Subjects;
using Avalonia.Collections;
using Avalonia.Controls.Utils;
using Avalonia.Layout;
using Avalonia.VisualTree;
namespace Avalonia.Controls
{
/// <summary>
/// Shared size scope implementation.
/// Shares the size information between participating grids.
/// An instance of this class is attached to every <see cref="Control"/> that has its
/// IsSharedSizeScope property set to true.
/// </summary>
internal sealed class SharedSizeScopeHost : IDisposable
{
private enum MeasurementState
{
Invalidated,
Measuring,
Cached
}
/// <summary>
/// Class containing the measured rows/columns for a single grid.
/// Monitors changes to the row/column collections as well as the SharedSizeGroup changes
/// for the individual items in those collections.
/// Notifies the <see cref="SharedSizeScopeHost"/> of SharedSizeGroup changes.
/// </summary>
private sealed class MeasurementCache : IDisposable
{
readonly CompositeDisposable _subscriptions;
readonly Subject<(string, string, MeasurementResult)> _groupChanged = new Subject<(string, string, MeasurementResult)>();
public ISubject<(string oldName, string newName, MeasurementResult result)> GroupChanged => _groupChanged;
public MeasurementCache(Grid grid)
{
Grid = grid;
Results = grid.RowDefinitions.Cast<DefinitionBase>()
.Concat(grid.ColumnDefinitions)
.Select(d => new MeasurementResult(grid, d))
.ToList();
grid.RowDefinitions.CollectionChanged += DefinitionsCollectionChanged;
grid.ColumnDefinitions.CollectionChanged += DefinitionsCollectionChanged;
_subscriptions = new CompositeDisposable(
Disposable.Create(() => grid.RowDefinitions.CollectionChanged -= DefinitionsCollectionChanged),
Disposable.Create(() => grid.ColumnDefinitions.CollectionChanged -= DefinitionsCollectionChanged),
grid.RowDefinitions.TrackItemPropertyChanged(DefinitionPropertyChanged),
grid.ColumnDefinitions.TrackItemPropertyChanged(DefinitionPropertyChanged));
}
// method to be hooked up once RowDefinitions/ColumnDefinitions collections can be replaced on a grid
private void DefinitionsChanged(object sender, AvaloniaPropertyChangedEventArgs e)
{
// route to collection changed as a Reset.
DefinitionsCollectionChanged(null, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}
private void DefinitionPropertyChanged(Tuple<object, PropertyChangedEventArgs> propertyChanged)
{
if (propertyChanged.Item2.PropertyName == nameof(DefinitionBase.SharedSizeGroup))
{
var result = Results.Single(mr => ReferenceEquals(mr.Definition, propertyChanged.Item1));
var oldName = result.SizeGroup?.Name;
var newName = (propertyChanged.Item1 as DefinitionBase).SharedSizeGroup;
_groupChanged.OnNext((oldName, newName, result));
}
}
private void DefinitionsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
int offset = 0;
if (sender is ColumnDefinitions)
offset = Grid.RowDefinitions.Count;
var newItems = e.NewItems?.OfType<DefinitionBase>().Select(db => new MeasurementResult(Grid, db)).ToList() ?? new List<MeasurementResult>();
var oldItems = e.OldStartingIndex >= 0
? Results.GetRange(e.OldStartingIndex + offset, e.OldItems.Count)
: new List<MeasurementResult>();
void NotifyNewItems()
{
foreach (var item in newItems)
{
if (string.IsNullOrEmpty(item.Definition.SharedSizeGroup))
continue;
_groupChanged.OnNext((null, item.Definition.SharedSizeGroup, item));
}
}
void NotifyOldItems()
{
foreach (var item in oldItems)
{
if (string.IsNullOrEmpty(item.Definition.SharedSizeGroup))
continue;
_groupChanged.OnNext((item.Definition.SharedSizeGroup, null, item));
}
}
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
Results.InsertRange(e.NewStartingIndex + offset, newItems);
NotifyNewItems();
break;
case NotifyCollectionChangedAction.Remove:
Results.RemoveRange(e.OldStartingIndex + offset, oldItems.Count);
NotifyOldItems();
break;
case NotifyCollectionChangedAction.Move:
Results.RemoveRange(e.OldStartingIndex + offset, oldItems.Count);
Results.InsertRange(e.NewStartingIndex + offset, oldItems);
break;
case NotifyCollectionChangedAction.Replace:
Results.RemoveRange(e.OldStartingIndex + offset, oldItems.Count);
Results.InsertRange(e.NewStartingIndex + offset, newItems);
NotifyOldItems();
NotifyNewItems();
break;
case NotifyCollectionChangedAction.Reset:
oldItems = Results;
newItems = Results = Grid.RowDefinitions.Cast<DefinitionBase>()
.Concat(Grid.ColumnDefinitions)
.Select(d => new MeasurementResult(Grid, d))
.ToList();
NotifyOldItems();
NotifyNewItems();
break;
}
}
/// <summary>
/// Updates the Results collection with Grid Measure results.
/// </summary>
/// <param name="rowResult">Result of the GridLayout.Measure method for the RowDefinitions in the grid.</param>
/// <param name="columnResult">Result of the GridLayout.Measure method for the ColumnDefinitions in the grid.</param>
public void UpdateMeasureResult(GridLayout.MeasureResult rowResult, GridLayout.MeasureResult columnResult)
{
MeasurementState = MeasurementState.Cached;
for (int i = 0; i < Grid.RowDefinitions.Count; i++)
{
Results[i].MeasuredResult = rowResult.LengthList[i];
Results[i].MinLength = rowResult.MinLengths[i];
}
for (int i = 0; i < Grid.ColumnDefinitions.Count; i++)
{
Results[i + Grid.RowDefinitions.Count].MeasuredResult = columnResult.LengthList[i];
Results[i + Grid.RowDefinitions.Count].MinLength = columnResult.MinLengths[i];
}
}
/// <summary>
/// Clears the measurement cache, in preparation for the Measure pass.
/// </summary>
public void InvalidateMeasure()
{
var newItems = new List<MeasurementResult>();
var oldItems = new List<MeasurementResult>();
MeasurementState = MeasurementState.Invalidated;
Results.ForEach(r =>
{
r.MeasuredResult = double.NaN;
r.SizeGroup?.Reset();
});
}
/// <summary>
/// Clears the <see cref="IObservable{T}"/> subscriptions.
/// </summary>
public void Dispose()
{
_subscriptions.Dispose();
_groupChanged.OnCompleted();
}
/// <summary>
/// Gets the <see cref="Grid"/> for which this cache has been created.
/// </summary>
public Grid Grid { get; }
/// <summary>
/// Gets the <see cref="MeasurementState"/> of this cache.
/// </summary>
public MeasurementState MeasurementState { get; private set; }
/// <summary>
/// Gets the list of <see cref="MeasurementResult"/> instances.
/// </summary>
/// <remarks>
/// The list is a 1-1 map of the concatenation of RowDefinitions and ColumnDefinitions
/// </remarks>
public List<MeasurementResult> Results { get; private set; }
}
/// <summary>
/// Class containing the Measure result for a single Row/Column in a grid.
/// </summary>
private class MeasurementResult
{
public MeasurementResult(Grid owningGrid, DefinitionBase definition)
{
OwningGrid = owningGrid;
Definition = definition;
MeasuredResult = double.NaN;
}
/// <summary>
/// Gets the <see cref="RowDefinition"/>/<see cref="ColumnDefinition"/> related to this <see cref="MeasurementResult"/>
/// </summary>
public DefinitionBase Definition { get; }
/// <summary>
/// Gets or sets the actual result of the Measure operation for this column.
/// </summary>
public double MeasuredResult { get; set; }
/// <summary>
/// Gets or sets the Minimum constraint for a Row/Column - relevant for star Rows/Columns in unconstrained grids.
/// </summary>
public double MinLength { get; set; }
/// <summary>
/// Gets or sets the <see cref="Group"/> that this result belongs to.
/// </summary>
public Group SizeGroup { get; set; }
/// <summary>
/// Gets the Grid that is the parent of the Row/Column
/// </summary>
public Grid OwningGrid { get; }
/// <summary>
/// Calculates the effective length that this Row/Column wishes to enforce in the SharedSizeGroup.
/// </summary>
/// <returns>A tuple of length and the priority in the shared size group.</returns>
public (double length, int priority) GetPriorityLength()
{
var length = (Definition as ColumnDefinition)?.Width ?? ((RowDefinition)Definition).Height;
if (length.IsAbsolute)
return (MeasuredResult, 1);
if (length.IsAuto)
return (MeasuredResult, 2);
if (MinLength > 0)
return (MinLength, 3);
return (MeasuredResult, 4);
}
}
/// <summary>
/// Visitor class used to gather the final length for a given SharedSizeGroup.
/// </summary>
/// <remarks>
/// The values are applied according to priorities defined in <see cref="MeasurementResult.GetPriorityLength"/>.
/// </remarks>
private class LentgthGatherer
{
/// <summary>
/// Gets the final Length to be applied to every Row/Column in a SharedSizeGroup
/// </summary>
public double Length { get; private set; }
private int gatheredPriority = 6;
/// <summary>
/// Visits the <paramref name="result"/> applying the result of <see cref="MeasurementResult.GetPriorityLength"/> to its internal cache.
/// </summary>
/// <param name="result">The <see cref="MeasurementResult"/> instance to visit.</param>
public void Visit(MeasurementResult result)
{
var (length, priority) = result.GetPriorityLength();
if (gatheredPriority < priority)
return;
gatheredPriority = priority;
if (gatheredPriority == priority)
{
Length = Math.Max(length,Length);
}
else
{
Length = length;
}
}
}
/// <summary>
/// Representation of a SharedSizeGroup, containing Rows/Columns with the same SharedSizeGroup property value.
/// </summary>
private class Group
{
private double? cachedResult;
private List<MeasurementResult> _results = new List<MeasurementResult>();
/// <summary>
/// Gets the name of the SharedSizeGroup.
/// </summary>
public string Name { get; }
public Group(string name)
{
Name = name;
}
/// <summary>
/// Gets the collection of the <see cref="MeasurementResult"/> instances.
/// </summary>
public IReadOnlyList<MeasurementResult> Results => _results;
/// <summary>
/// Gets the final, calculated length for all Rows/Columns in the SharedSizeGroup.
/// </summary>
public double CalculatedLength => (cachedResult ?? (cachedResult = Gather())).Value;
/// <summary>
/// Clears the previously cached result in preparation for measurement.
/// </summary>
public void Reset()
{
cachedResult = null;
}
/// <summary>
/// Ads a measurement result to this group and sets it's <see cref="MeasurementResult.SizeGroup"/> property
/// to this instance.
/// </summary>
/// <param name="result">The <see cref="MeasurementResult"/> to include in this group.</param>
public void Add(MeasurementResult result)
{
if (_results.Contains(result))
throw new AvaloniaInternalException(
$"SharedSizeScopeHost: Invalid call to Group.Add - The SharedSizeGroup {Name} already contains the passed result");
result.SizeGroup = this;
_results.Add(result);
}
/// <summary>
/// Removes the measurement result from this group and clears its <see cref="MeasurementResult.SizeGroup"/> value.
/// </summary>
/// <param name="result">The <see cref="MeasurementResult"/> to clear.</param>
public void Remove(MeasurementResult result)
{
if (!_results.Contains(result))
throw new AvaloniaInternalException(
$"SharedSizeScopeHost: Invalid call to Group.Remove - The SharedSizeGroup {Name} does not contain the passed result");
result.SizeGroup = null;
_results.Remove(result);
}
private double Gather()
{
var visitor = new LentgthGatherer();
_results.ForEach(visitor.Visit);
return visitor.Length;
}
}
private readonly AvaloniaList<MeasurementCache> _measurementCaches = new AvaloniaList<MeasurementCache>();
private readonly Dictionary<string, Group> _groups = new Dictionary<string, Group>();
private bool _invalidating;
/// <summary>
/// Removes the SharedSizeScope and notifies all affected grids of the change.
/// </summary>
public void Dispose()
{
// while (_measurementCaches.Any())
// _measurementCaches[0].Grid.SharedScopeChanged();
}
/// <summary>
/// Registers the grid in this SharedSizeScope, to be called when the grid is added to the visual tree.
/// </summary>
/// <param name="toAdd">The <see cref="Grid"/> to add to this scope.</param>
internal void RegisterGrid(Grid toAdd)
{
if (_measurementCaches.Any(mc => ReferenceEquals(mc.Grid, toAdd)))
throw new AvaloniaInternalException("SharedSizeScopeHost: tried to register a grid twice!");
var cache = new MeasurementCache(toAdd);
_measurementCaches.Add(cache);
AddGridToScopes(cache);
}
/// <summary>
/// Removes the registration for a grid in this SharedSizeScope.
/// </summary>
/// <param name="toRemove">The <see cref="Grid"/> to remove.</param>
internal void UnegisterGrid(Grid toRemove)
{
var cache = _measurementCaches.FirstOrDefault(mc => ReferenceEquals(mc.Grid, toRemove));
if (cache == null)
throw new AvaloniaInternalException("SharedSizeScopeHost: tried to unregister a grid that wasn't registered before!");
_measurementCaches.Remove(cache);
RemoveGridFromScopes(cache);
cache.Dispose();
}
/// <summary>
/// Helper method to check if a grid needs to forward its Mesure results to, and requrest Arrange results from this scope.
/// </summary>
/// <param name="toCheck">The <see cref="Grid"/> that should be checked.</param>
/// <returns>True if the grid should forward its calls.</returns>
internal bool ParticipatesInScope(Grid toCheck)
{
return _measurementCaches.FirstOrDefault(mc => ReferenceEquals(mc.Grid, toCheck))
?.Results.Any(r => r.SizeGroup != null) ?? false;
}
/// <summary>
/// Notifies the SharedSizeScope that a grid had requested its measurement to be invalidated.
/// Forwards the same call to all affected grids in this scope.
/// </summary>
/// <param name="grid">The <see cref="Grid"/> that had it's Measure invalidated.</param>
internal void InvalidateMeasure(Grid grid)
{
// prevent stack overflow
if (_invalidating)
return;
_invalidating = true;
InvalidateMeasureImpl(grid);
_invalidating = false;
}
/// <summary>
/// Updates the measurement cache with the results of the <paramref name="grid"/> measurement pass.
/// </summary>
/// <param name="grid">The <see cref="Grid"/> that has been measured.</param>
/// <param name="rowResult">Measurement result for the grid's <see cref="RowDefinitions"/></param>
/// <param name="columnResult">Measurement result for the grid's <see cref="ColumnDefinitions"/></param>
internal void UpdateMeasureStatus(Grid grid, GridLayout.MeasureResult rowResult, GridLayout.MeasureResult columnResult)
{
var cache = _measurementCaches.FirstOrDefault(mc => ReferenceEquals(mc.Grid, grid));
if (cache == null)
throw new AvaloniaInternalException("SharedSizeScopeHost: Attempted to update measurement status for a grid that wasn't registered!");
cache.UpdateMeasureResult(rowResult, columnResult);
}
/// <summary>
/// Calculates the measurement result including the impact of any SharedSizeGroups that might affect this grid.
/// </summary>
/// <param name="grid">The <see cref="Grid"/> that is being Arranged</param>
/// <param name="rowResult">The <paramref name="grid"/>'s cached measurement result.</param>
/// <param name="columnResult">The <paramref name="grid"/>'s cached measurement result.</param>
/// <returns>Row and column measurement result updated with the SharedSizeScope constraints.</returns>
internal (GridLayout.MeasureResult, GridLayout.MeasureResult) HandleArrange(Grid grid, GridLayout.MeasureResult rowResult, GridLayout.MeasureResult columnResult)
{
return (
Arrange(grid.RowDefinitions, rowResult),
Arrange(grid.ColumnDefinitions, columnResult)
);
}
/// <summary>
/// Invalidates the measure of all grids affected by the SharedSizeGroups contained within.
/// </summary>
/// <param name="grid">The <see cref="Grid"/> that is being invalidated.</param>
private void InvalidateMeasureImpl(Grid grid)
{
var cache = _measurementCaches.FirstOrDefault(mc => ReferenceEquals(mc.Grid, grid));
if (cache == null)
throw new AvaloniaInternalException(
$"SharedSizeScopeHost: InvalidateMeasureImpl - called with a grid not present in the internal cache");
// already invalidated the cache, early out.
if (cache.MeasurementState == MeasurementState.Invalidated)
return;
// we won't calculate, so we should not invalidate.
if (!ParticipatesInScope(grid))
return;
cache.InvalidateMeasure();
// maybe there is a condition to only call arrange on some of the calls?
grid.InvalidateMeasure();
// find all the scopes within the invalidated grid
var scopeNames = cache.Results
.Where(mr => mr.SizeGroup != null)
.Select(mr => mr.SizeGroup.Name)
.Distinct();
// find all grids related to those scopes
var otherGrids = scopeNames.SelectMany(sn => _groups[sn].Results)
.Select(r => r.OwningGrid)
.Where(g => g.IsMeasureValid)
.Distinct();
// invalidate them as well
foreach (var otherGrid in otherGrids)
{
InvalidateMeasureImpl(otherGrid);
}
}
/// <summary>
/// <see cref="IObserver{T}"/> callback notifying the scope that a <see cref="MeasurementResult"/> has changed its
/// SharedSizeGroup
/// </summary>
/// <param name="change">Old and New name (either can be null) of the SharedSizeGroup, as well as the result.</param>
private void SharedGroupChanged((string oldName, string newName, MeasurementResult result) change)
{
RemoveFromGroup(change.oldName, change.result);
AddToGroup(change.newName, change.result);
}
/// <summary>
/// Handles the impact of SharedSizeGroups on the Arrange of <see cref="RowDefinitions"/>/<see cref="ColumnDefinitions"/>
/// </summary>
/// <param name="definitions">Rows/Columns that were measured</param>
/// <param name="measureResult">The initial measurement result.</param>
/// <returns>Modified measure result</returns>
private GridLayout.MeasureResult Arrange(IReadOnlyList<DefinitionBase> definitions, GridLayout.MeasureResult measureResult)
{
var conventions = measureResult.LeanLengthList.ToList();
var lengths = measureResult.LengthList.ToList();
var desiredLength = 0.0;
for (int i = 0; i < definitions.Count; i++)
{
var definition = definitions[i];
// for empty SharedSizeGroups pass on unmodified result.
if (string.IsNullOrEmpty(definition.SharedSizeGroup))
{
desiredLength += measureResult.LengthList[i];
continue;
}
var group = _groups[definition.SharedSizeGroup];
// Length calculated over all Definitions participating in a SharedSizeGroup.
var length = group.CalculatedLength;
conventions[i] = new GridLayout.LengthConvention(
new GridLength(length),
measureResult.LeanLengthList[i].MinLength,
measureResult.LeanLengthList[i].MaxLength
);
lengths[i] = length;
desiredLength += length;
}
return new GridLayout.MeasureResult(
measureResult.ContainerLength,
desiredLength,
measureResult.GreedyDesiredLength,//??
conventions,
lengths,
measureResult.MinLengths);
}
/// <summary>
/// Adds all measurement results for a grid to their repsective scopes.
/// </summary>
/// <param name="cache">The <see cref="MeasurementCache"/> for a grid to be added.</param>
private void AddGridToScopes(MeasurementCache cache)
{
cache.GroupChanged.Subscribe(SharedGroupChanged);
foreach (var result in cache.Results)
{
var scopeName = result.Definition.SharedSizeGroup;
AddToGroup(scopeName, result);
}
}
/// <summary>
/// Handles adding the <see cref="MeasurementResult"/> to a SharedSizeGroup.
/// Does nothing for empty SharedSizeGroups.
/// </summary>
/// <param name="scopeName">The name (can be null or empty) of the group to add the <paramref name="result"/> to.</param>
/// <param name="result">The <see cref="MeasurementResult"/> to add to a scope.</param>
private void AddToGroup(string scopeName, MeasurementResult result)
{
if (string.IsNullOrEmpty(scopeName))
return;
if (!_groups.TryGetValue(scopeName, out var group))
_groups.Add(scopeName, group = new Group(scopeName));
group.Add(result);
}
/// <summary>
/// Removes all measurement results for a grid from their respective scopes.
/// </summary>
/// <param name="cache">The <see cref="MeasurementCache"/> for a grid to be removed.</param>
private void RemoveGridFromScopes(MeasurementCache cache)
{
foreach (var result in cache.Results)
{
var scopeName = result.Definition.SharedSizeGroup;
RemoveFromGroup(scopeName, result);
}
}
/// <summary>
/// Handles removing the <see cref="MeasurementResult"/> from a SharedSizeGroup.
/// Does nothing for empty SharedSizeGroups.
/// </summary>
/// <param name="scopeName">The name (can be null or empty) of the group to remove the <paramref name="result"/> from.</param>
/// <param name="result">The <see cref="MeasurementResult"/> to remove from a scope.</param>
private void RemoveFromGroup(string scopeName, MeasurementResult result)
{
if (string.IsNullOrEmpty(scopeName))
return;
if (!_groups.TryGetValue(scopeName, out var group))
throw new AvaloniaInternalException($"SharedSizeScopeHost: The scope {scopeName} wasn't found in the shared size scope");
group.Remove(result);
if (!group.Results.Any())
_groups.Remove(scopeName);
}
}
}

184
tests/Avalonia.Controls.UnitTests/GridLayoutTests.cs
View File

@ -1,184 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using Avalonia.Controls.Utils;
using Xunit;
namespace Avalonia.Controls.UnitTests
{
public class GridLayoutTests
{
private const double Inf = double.PositiveInfinity;
[Theory]
[InlineData("100, 200, 300", 0d, 0d, new[] { 0d, 0d, 0d })]
[InlineData("100, 200, 300", 800d, 600d, new[] { 100d, 200d, 300d })]
[InlineData("100, 200, 300", 600d, 600d, new[] { 100d, 200d, 300d })]
[InlineData("100, 200, 300", 400d, 400d, new[] { 100d, 200d, 100d })]
public void MeasureArrange_AllPixelLength_Correct(string length, double containerLength,
double expectedDesiredLength, IList expectedLengthList)
{
TestRowDefinitionsOnly(length, containerLength, expectedDesiredLength, expectedLengthList);
}
[Theory]
[InlineData("*,2*,3*", 0d, 0d, new[] { 0d, 0d, 0d })]
[InlineData("*,2*,3*", 600d, 0d, new[] { 100d, 200d, 300d })]
public void MeasureArrange_AllStarLength_Correct(string length, double containerLength,
double expectedDesiredLength, IList expectedLengthList)
{
TestRowDefinitionsOnly(length, containerLength, expectedDesiredLength, expectedLengthList);
}
[Theory]
[InlineData("100,2*,3*", 0d, 0d, new[] { 0d, 0d, 0d })]
[InlineData("100,2*,3*", 600d, 100d, new[] { 100d, 200d, 300d })]
[InlineData("100,2*,3*", 100d, 100d, new[] { 100d, 0d, 0d })]
[InlineData("100,2*,3*", 50d, 50d, new[] { 50d, 0d, 0d })]
public void MeasureArrange_MixStarPixelLength_Correct(string length, double containerLength,
double expectedDesiredLength, IList expectedLengthList)
{
TestRowDefinitionsOnly(length, containerLength, expectedDesiredLength, expectedLengthList);
}
[Theory]
[InlineData("100,200,Auto", 0d, 0d, new[] { 0d, 0d, 0d })]
[InlineData("100,200,Auto", 600d, 300d, new[] { 100d, 200d, 0d })]
[InlineData("100,200,Auto", 300d, 300d, new[] { 100d, 200d, 0d })]
[InlineData("100,200,Auto", 200d, 200d, new[] { 100d, 100d, 0d })]
[InlineData("100,200,Auto", 100d, 100d, new[] { 100d, 0d, 0d })]
[InlineData("100,200,Auto", 50d, 50d, new[] { 50d, 0d, 0d })]
public void MeasureArrange_MixAutoPixelLength_Correct(string length, double containerLength,
double expectedDesiredLength, IList expectedLengthList)
{
TestRowDefinitionsOnly(length, containerLength, expectedDesiredLength, expectedLengthList);
}
[Theory]
[InlineData("*,2*,Auto", 0d, 0d, new[] { 0d, 0d, 0d })]
[InlineData("*,2*,Auto", 600d, 0d, new[] { 200d, 400d, 0d })]
public void MeasureArrange_MixAutoStarLength_Correct(string length, double containerLength,
double expectedDesiredLength, IList expectedLengthList)
{
TestRowDefinitionsOnly(length, containerLength, expectedDesiredLength, expectedLengthList);
}
[Theory]
[InlineData("*,200,Auto", 0d, 0d, new[] { 0d, 0d, 0d })]
[InlineData("*,200,Auto", 600d, 200d, new[] { 400d, 200d, 0d })]
[InlineData("*,200,Auto", 200d, 200d, new[] { 0d, 200d, 0d })]
[InlineData("*,200,Auto", 100d, 100d, new[] { 0d, 100d, 0d })]
public void MeasureArrange_MixAutoStarPixelLength_Correct(string length, double containerLength,
double expectedDesiredLength, IList expectedLengthList)
{
TestRowDefinitionsOnly(length, containerLength, expectedDesiredLength, expectedLengthList);
}
/// <summary>
/// This is needed because Mono somehow converts double array to object array in attribute metadata
/// </summary>
static void AssertEqual(IList expected, IReadOnlyList<double> actual)
{
var conv = expected.Cast<double>().ToArray();
Assert.Equal(conv, actual);
}
[SuppressMessage("ReSharper", "ParameterOnlyUsedForPreconditionCheck.Local")]
private static void TestRowDefinitionsOnly(string length, double containerLength,
double expectedDesiredLength, IList expectedLengthList)
{
// Arrange
var layout = new GridLayout(new RowDefinitions(length));
// Measure - Action & Assert
var measure = layout.Measure(containerLength);
Assert.Equal(expectedDesiredLength, measure.DesiredLength);
AssertEqual(expectedLengthList, measure.LengthList);
// Arrange - Action & Assert
var arrange = layout.Arrange(containerLength, measure);
AssertEqual(expectedLengthList, arrange.LengthList);
}
[Theory]
[InlineData("100, 200, 300", 600d, new[] { 100d, 200d, 300d }, new[] { 100d, 200d, 300d })]
[InlineData("*,2*,3*", 0d, new[] { Inf, Inf, Inf }, new[] { 0d, 0d, 0d })]
[InlineData("100,2*,3*", 100d, new[] { 100d, Inf, Inf }, new[] { 100d, 0d, 0d })]
[InlineData("100,200,Auto", 300d, new[] { 100d, 200d, 0d }, new[] { 100d, 200d, 0d })]
[InlineData("*,2*,Auto", 0d, new[] { Inf, Inf, 0d }, new[] { 0d, 0d, 0d })]
[InlineData("*,200,Auto", 200d, new[] { Inf, 200d, 0d }, new[] { 0d, 200d, 0d })]
public void MeasureArrange_InfiniteMeasure_Correct(string length, double expectedDesiredLength,
IList expectedMeasureList, IList expectedArrangeList)
{
// Arrange
var layout = new GridLayout(new RowDefinitions(length));
// Measure - Action & Assert
var measure = layout.Measure(Inf);
Assert.Equal(expectedDesiredLength, measure.DesiredLength);
AssertEqual(expectedMeasureList, measure.LengthList);
// Arrange - Action & Assert
var arrange = layout.Arrange(measure.DesiredLength, measure);
AssertEqual(expectedArrangeList, arrange.LengthList);
}
[Theory]
[InlineData("Auto,*,*", new[] { 100d, 100d, 100d }, 600d, 300d, new[] { 100d, 250d, 250d })]
public void MeasureArrange_ChildHasSize_Correct(string length,
IList childLengthList, double containerLength,
double expectedDesiredLength, IList expectedLengthList)
{
// Arrange
var lengthList = new ColumnDefinitions(length);
var layout = new GridLayout(lengthList);
layout.AppendMeasureConventions(
Enumerable.Range(0, lengthList.Count).ToDictionary(x => x, x => (x, 1)),
x => (double)childLengthList[x]);
// Measure - Action & Assert
var measure = layout.Measure(containerLength);
Assert.Equal(expectedDesiredLength, measure.DesiredLength);
AssertEqual(expectedLengthList, measure.LengthList);
// Arrange - Action & Assert
var arrange = layout.Arrange(containerLength, measure);
AssertEqual(expectedLengthList, arrange.LengthList);
}
[Theory]
[InlineData(Inf, 250d, new[] { 100d, Inf, Inf }, new[] { 100d, 50d, 100d })]
[InlineData(400d, 250d, new[] { 100d, 100d, 200d }, new[] { 100d, 100d, 200d })]
[InlineData(325d, 250d, new[] { 100d, 75d, 150d }, new[] { 100d, 75d, 150d })]
[InlineData(250d, 250d, new[] { 100d, 50d, 100d }, new[] { 100d, 50d, 100d })]
[InlineData(160d, 160d, new[] { 100d, 20d, 40d }, new[] { 100d, 20d, 40d })]
public void MeasureArrange_ChildHasSizeAndHasMultiSpan_Correct(
double containerLength, double expectedDesiredLength,
IList expectedMeasureLengthList, IList expectedArrangeLengthList)
{
var length = "100,*,2*";
var childLengthList = new[] { 150d, 150d, 150d };
var spans = new[] { 1, 2, 1 };
// Arrange
var lengthList = new ColumnDefinitions(length);
var layout = new GridLayout(lengthList);
layout.AppendMeasureConventions(
Enumerable.Range(0, lengthList.Count).ToDictionary(x => x, x => (x, spans[x])),
x => childLengthList[x]);
// Measure - Action & Assert
var measure = layout.Measure(containerLength);
Assert.Equal(expectedDesiredLength, measure.DesiredLength);
AssertEqual(expectedMeasureLengthList, measure.LengthList);
// Arrange - Action & Assert
var arrange = layout.Arrange(
double.IsInfinity(containerLength) ? measure.DesiredLength : containerLength,
measure);
AssertEqual(expectedArrangeLengthList, arrange.LengthList);
}
}
}
Write Preview
Loading…
Cancel
Save