Datasets:

dlxjj
/

imradv3

﻿using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using ScreenGrab.Extensions;

namespace ScreenGrab;

/// <summary>
///     Source <see href="https://github.com/budul100/WpfAutoGrid.Core" />
///     Defines a flexible grid area that consists of columns and rows.
///     Depending on the orientation, either the rows or the columns are auto-generated,
///     and the children's position is set according to their index.
///     Partially based on work at http://rachel53461.wordpress.com/2011/09/17/wpf-grids-rowcolumn-count-properties/
/// </summary>
public class AutoGrid : Grid
{
    #region Protected Methods

    /// <summary>
    ///     Measures the children of a <see cref="T:System.Windows.Controls.Grid" /> in anticipation of arranging them during
    ///     the <see cref="M:ArrangeOverride" /> pass.
    /// </summary>
    /// <param name="constraint">Indicates an upper limit size that should not be exceeded.</param>
    /// <returns>
    ///     <see cref="Size" /> that represents the required size to arrange child content.
    /// </returns>
    protected override Size MeasureOverride(Size constraint)
    {
        PerformLayout();
        return base.MeasureOverride(constraint);
    }

    #endregion Protected Methods

    #region Public Fields

    public static readonly DependencyProperty ChildHorizontalAlignmentProperty = DependencyProperty.Register(
        "ChildHorizontalAlignment",
        typeof(HorizontalAlignment?),
        typeof(AutoGrid),
        new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsMeasure,
            OnChildHorizontalAlignmentChanged));

    public static readonly DependencyProperty ChildMarginProperty = DependencyProperty.Register(
        "ChildMargin",
        typeof(Thickness?),
        typeof(AutoGrid),
        new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsMeasure, OnChildMarginChanged));

    public static readonly DependencyProperty ChildVerticalAlignmentProperty = DependencyProperty.Register(
        "ChildVerticalAlignment",
        typeof(VerticalAlignment?),
        typeof(AutoGrid),
        new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsMeasure,
            OnChildVerticalAlignmentChanged));

    public static readonly DependencyProperty ColumnCountProperty = DependencyProperty.RegisterAttached(
        "ColumnCount",
        typeof(int),
        typeof(AutoGrid),
        new FrameworkPropertyMetadata(1, FrameworkPropertyMetadataOptions.AffectsMeasure, ColumnCountChanged));

    public static readonly DependencyProperty ColumnsProperty = DependencyProperty.RegisterAttached(
        "Columns",
        typeof(string),
        typeof(AutoGrid),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.AffectsMeasure, ColumnsChanged));

    public static readonly DependencyProperty ColumnWidthProperty = DependencyProperty.RegisterAttached(
        "ColumnWidth",
        typeof(GridLength),
        typeof(AutoGrid),
        new FrameworkPropertyMetadata(GridLength.Auto, FrameworkPropertyMetadataOptions.AffectsMeasure,
            FixedColumnWidthChanged));

    public static readonly DependencyProperty IsAutoIndexingProperty = DependencyProperty.Register(
        "IsAutoIndexing",
        typeof(bool),
        typeof(AutoGrid),
        new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsMeasure));

    public static readonly DependencyProperty OrientationProperty = DependencyProperty.Register(
        "Orientation",
        typeof(Orientation),
        typeof(AutoGrid),
        new FrameworkPropertyMetadata(Orientation.Horizontal, FrameworkPropertyMetadataOptions.AffectsMeasure));

    public static readonly DependencyProperty RowCountProperty = DependencyProperty.RegisterAttached(
        "RowCount",
        typeof(int),
        typeof(AutoGrid),
        new FrameworkPropertyMetadata(1, FrameworkPropertyMetadataOptions.AffectsMeasure, RowCountChanged));

    public static readonly DependencyProperty RowHeightProperty = DependencyProperty.RegisterAttached(
        "RowHeight",
        typeof(GridLength),
        typeof(AutoGrid),
        new FrameworkPropertyMetadata(GridLength.Auto, FrameworkPropertyMetadataOptions.AffectsMeasure,
            FixedRowHeightChanged));

    public static readonly DependencyProperty RowsProperty = DependencyProperty.RegisterAttached(
        "Rows",
        typeof(string),
        typeof(AutoGrid),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.AffectsMeasure, RowsChanged));

    #endregion Public Fields

    #region Public Properties

    /// <summary>
    ///     Gets or sets the child horizontal alignment.
    /// </summary>
    /// <value>The child horizontal alignment.</value>
    [Category("Layout")]
    [Description("Presets the horizontal alignment of all child controls")]
    public HorizontalAlignment? ChildHorizontalAlignment
    {
        get => (HorizontalAlignment?)GetValue(ChildHorizontalAlignmentProperty);
        set => SetValue(ChildHorizontalAlignmentProperty, value);
    }

    /// <summary>
    ///     Gets or sets the child margin.
    /// </summary>
    /// <value>The child margin.</value>
    [Category("Layout")]
    [Description("Presets the margin of all child controls")]
    public Thickness? ChildMargin
    {
        get => (Thickness?)GetValue(ChildMarginProperty);
        set => SetValue(ChildMarginProperty, value);
    }

    /// <summary>
    ///     Gets or sets the child vertical alignment.
    /// </summary>
    /// <value>The child vertical alignment.</value>
    [Category("Layout")]
    [Description("Presets the vertical alignment of all child controls")]
    public VerticalAlignment? ChildVerticalAlignment
    {
        get => (VerticalAlignment?)GetValue(ChildVerticalAlignmentProperty);
        set => SetValue(ChildVerticalAlignmentProperty, value);
    }

    /// <summary>
    ///     Gets or sets the column count
    /// </summary>
    [Category("Layout")]
    [Description("Defines a set number of columns")]
    public int ColumnCount
    {
        get => (int)GetValue(ColumnCountProperty);
        set => SetValue(ColumnCountProperty, value);
    }

    /// <summary>
    ///     Gets or sets the columns
    /// </summary>
    [Category("Layout")]
    [Description("Defines all columns using comma separated grid length notation")]
    public string Columns
    {
        get => (string)GetValue(ColumnsProperty);
        set => SetValue(ColumnsProperty, value);
    }

    /// <summary>
    ///     Gets or sets the fixed column width
    /// </summary>
    [Category("Layout")]
    [Description("Presets the width of all columns set using the ColumnCount property")]
    public GridLength ColumnWidth
    {
        get => (GridLength)GetValue(ColumnWidthProperty);
        set => SetValue(ColumnWidthProperty, value);
    }

    /// <summary>
    ///     Gets or sets a value indicating whether the children are automatically indexed.
    ///     <remarks>
    ///         The default is <c>true</c>.
    ///         Note that if children are already indexed, setting this property to <c>false</c> will not remove their indices.
    ///     </remarks>
    /// </summary>
    [Category("Layout")]
    [Description("Set to false to disable the auto layout functionality")]
    public bool IsAutoIndexing
    {
        get => (bool)GetValue(IsAutoIndexingProperty);
        set => SetValue(IsAutoIndexingProperty, value);
    }

    /// <summary>
    ///     Gets or sets the orientation.
    ///     <remarks>The default is Vertical.</remarks>
    /// </summary>
    /// <value>The orientation.</value>
    [Category("Layout")]
    [Description(
        "Defines the directionality of the autolayout. Use vertical for a column first layout, horizontal for a row first layout.")]
    public Orientation Orientation
    {
        get => (Orientation)GetValue(OrientationProperty);
        set => SetValue(OrientationProperty, value);
    }

    /// <summary>
    ///     Gets or sets the number of rows
    /// </summary>
    [Category("Layout")]
    [Description("Defines a set number of rows")]
    public int RowCount
    {
        get => (int)GetValue(RowCountProperty);
        set => SetValue(RowCountProperty, value);
    }

    /// <summary>
    ///     Gets or sets the fixed row height
    /// </summary>
    [Category("Layout")]
    [Description("Presets the height of all rows set using the RowCount property")]
    public GridLength RowHeight
    {
        get => (GridLength)GetValue(RowHeightProperty);
        set => SetValue(RowHeightProperty, value);
    }

    /// <summary>
    ///     Gets or sets the rows
    /// </summary>
    [Category("Layout")]
    [Description("Defines all rows using comma separated grid length notation")]
    public string Rows
    {
        get => (string)GetValue(RowsProperty);
        set => SetValue(RowsProperty, value);
    }

    #endregion Public Properties

    #region Public Methods

    /// <summary>
    ///     Handles the column count changed event
    /// </summary>
    public static void ColumnCountChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if ((int)e.NewValue < 0)
            return;

        if (d is not AutoGrid grid) return;
        //var grid = d as AutoGrid;

        // look for an existing column definition for the height
        var width = GridLength.Auto;
        if (grid.ColumnDefinitions.Count > 0)
            width = grid.ColumnDefinitions[0].Width;

        // clear and rebuild
        grid.ColumnDefinitions.Clear();
        for (var i = 0; i < (int)e.NewValue; i++)
            grid.ColumnDefinitions.Add(
                new ColumnDefinition { Width = width });
    }

    /// <summary>
    ///     Handle the columns changed event
    /// </summary>
    public static void ColumnsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (string.IsNullOrEmpty((string)e.NewValue))
            return;

        if (d is not AutoGrid grid) return;
        //var grid = d as AutoGrid;
        grid.ColumnDefinitions.Clear();

        var defs = Parse((string)e.NewValue);
        foreach (var def in defs)
            grid.ColumnDefinitions.Add(new ColumnDefinition { Width = def });
    }

    /// <summary>
    ///     Handle the fixed column width changed event
    /// </summary>
    public static void FixedColumnWidthChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is not AutoGrid grid) return;
        //var grid = d as AutoGrid;

        // add a default column if missing
        if (grid.ColumnDefinitions.Count == 0)
            grid.ColumnDefinitions.Add(new ColumnDefinition());

        // set all existing columns to this width
        for (var i = 0; i < grid.ColumnDefinitions.Count; i++)
            grid.ColumnDefinitions[i].Width = (GridLength)e.NewValue;
    }

    /// <summary>
    ///     Handle the fixed row height changed event
    /// </summary>
    public static void FixedRowHeightChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is not AutoGrid grid) return;
        //var grid = d as AutoGrid;

        // add a default row if missing
        if (grid.RowDefinitions.Count == 0)
            grid.RowDefinitions.Add(new RowDefinition());

        // set all existing rows to this height
        for (var i = 0; i < grid.RowDefinitions.Count; i++)
            grid.RowDefinitions[i].Height = (GridLength)e.NewValue;
    }

    /// <summary>
    ///     Parse an array of grid lengths from comma delim text
    /// </summary>
    public static GridLength[] Parse(string text)
    {
        var tokens = text.Split(',');
        var definitions = new GridLength[tokens.Length];
        for (var i = 0; i < tokens.Length; i++)
        {
            var str = tokens[i];
            double value;

            // ratio
            if (str.Contains('*'))
            {
                if (!double.TryParse(str.Replace("*", ""), out value))
                    value = 1.0;

                definitions[i] = new GridLength(value, GridUnitType.Star);
                continue;
            }

            // pixels
            if (double.TryParse(str, out value))
            {
                definitions[i] = new GridLength(value);
                continue;
            }

            // auto
            definitions[i] = GridLength.Auto;
        }

        return definitions;
    }

    /// <summary>
    ///     Handles the row count changed event
    /// </summary>
    public static void RowCountChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if ((int)e.NewValue < 0)
            return;

        if (d is not AutoGrid grid) return;
        //var grid = d as AutoGrid;

        // look for an existing row to get the height
        var height = GridLength.Auto;
        if (grid.RowDefinitions.Count > 0)
            height = grid.RowDefinitions[0].Height;

        // clear and rebuild
        grid.RowDefinitions.Clear();
        for (var i = 0; i < (int)e.NewValue; i++)
            grid.RowDefinitions.Add(
                new RowDefinition { Height = height });
    }

    /// <summary>
    ///     Handle the rows changed event
    /// </summary>
    public static void RowsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (string.IsNullOrEmpty((string)e.NewValue))
            return;

        if (d is not AutoGrid grid) return;
        //var grid = d as AutoGrid;
        grid.RowDefinitions.Clear();

        var defs = Parse((string)e.NewValue);
        foreach (var def in defs)
            grid.RowDefinitions.Add(new RowDefinition { Height = def });
    }

    #endregion Public Methods

    #region Private Methods

    /// <summary>
    ///     Called when [child horizontal alignment changed].
    /// </summary>
    private static void OnChildHorizontalAlignmentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is not AutoGrid grid) return;
        //var grid = d as AutoGrid;
        foreach (UIElement child in grid.Children)
            if (grid.ChildHorizontalAlignment.HasValue)
                child.SetValue(HorizontalAlignmentProperty, grid.ChildHorizontalAlignment);
            else
                child.SetValue(HorizontalAlignmentProperty, DependencyProperty.UnsetValue);
    }

    /// <summary>
    ///     Called when [child layout changed].
    /// </summary>
    private static void OnChildMarginChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is not AutoGrid grid) return;
        //var grid = d as AutoGrid;
        foreach (UIElement child in grid.Children)
            if (grid.ChildMargin.HasValue)
                child.SetValue(MarginProperty, grid.ChildMargin);
            else
                child.SetValue(MarginProperty, DependencyProperty.UnsetValue);
    }

    /// <summary>
    ///     Called when [child vertical alignment changed].
    /// </summary>
    private static void OnChildVerticalAlignmentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is not AutoGrid grid) return;
        //var grid = d as AutoGrid;
        foreach (UIElement child in grid.Children)
            if (grid.ChildVerticalAlignment.HasValue)
                child.SetValue(VerticalAlignmentProperty, grid.ChildVerticalAlignment);
            else
                child.SetValue(VerticalAlignmentProperty, DependencyProperty.UnsetValue);
    }

    ///// <summary>
    ///// Handled the redraw properties changed event
    ///// </summary>
    //private static void OnPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    //{ }

    /// <summary>
    ///     Apply child margins and layout effects such as alignment
    /// </summary>
    private void ApplyChildLayout(UIElement child)
    {
        if (ChildMargin != null) child.SetIfDefault(MarginProperty, ChildMargin.Value);
        if (ChildHorizontalAlignment != null)
            child.SetIfDefault(HorizontalAlignmentProperty, ChildHorizontalAlignment.Value);
        if (ChildVerticalAlignment != null) child.SetIfDefault(VerticalAlignmentProperty, ChildVerticalAlignment.Value);
    }

    /// <summary>
    ///     Clamp a value to its maximum.
    /// </summary>
    private int Clamp(int value, int max)
    {
        return value > max ? max : value;
    }

    /// <summary>
    ///     Perform the grid layout of row and column indexes
    /// </summary>
    private void PerformLayout()
    {
        var fillRowFirst = Orientation == Orientation.Horizontal;
        var rowCount = RowDefinitions.Count;
        var colCount = ColumnDefinitions.Count;

        if (rowCount == 0 || colCount == 0)
            return;

        var position = 0;
        var skip = new bool[rowCount, colCount];
        foreach (UIElement child in Children)
        {
            var childIsCollapsed = child.Visibility == Visibility.Collapsed;
            if (IsAutoIndexing && !childIsCollapsed)
            {
                if (fillRowFirst)
                {
                    var row = Clamp(position / colCount, rowCount - 1);
                    var col = Clamp(position % colCount, colCount - 1);
                    if (skip[row, col])
                    {
                        position++;
                        row = position / colCount;
                        col = position % colCount;
                    }

                    SetRow(child, row);
                    SetColumn(child, col);
                    position += GetColumnSpan(child);

                    var offset = GetRowSpan(child) - 1;
                    while (offset > 0) skip[row + offset--, col] = true;
                }
                else
                {
                    var row = Clamp(position % rowCount, rowCount - 1);
                    var col = Clamp(position / rowCount, colCount - 1);
                    if (skip[row, col])
                    {
                        position++;
                        row = position % rowCount;
                        col = position / rowCount;
                    }

                    SetRow(child, row);
                    SetColumn(child, col);
                    position += GetRowSpan(child);

                    var offset = GetColumnSpan(child) - 1;
                    while (offset > 0) skip[row, col + offset--] = true;
                }
            }

            ApplyChildLayout(child);
        }
    }

    #endregion Private Methods
}

	using System.ComponentModel;
	using System.Windows;
	using System.Windows.Controls;
	using ScreenGrab.Extensions;

	namespace ScreenGrab;

	/// <summary>
	/// Source <see href="https://github.com/budul100/WpfAutoGrid.Core" />
	/// Defines a flexible grid area that consists of columns and rows.
	/// Depending on the orientation, either the rows or the columns are auto-generated,
	/// and the children's position is set according to their index.
	/// Partially based on work at http://rachel53461.wordpress.com/2011/09/17/wpf-grids-rowcolumn-count-properties/
	/// </summary>
	public class AutoGrid : Grid
	{
	#region Protected Methods

	/// <summary>
	/// Measures the children of a <see cref="T:System.Windows.Controls.Grid" /> in anticipation of arranging them during
	/// the <see cref="M:ArrangeOverride" /> pass.
	/// </summary>
	/// <param name="constraint">Indicates an upper limit size that should not be exceeded.</param>
	/// <returns>
	/// <see cref="Size" /> that represents the required size to arrange child content.
	/// </returns>
	protected override Size MeasureOverride(Size constraint)
	{
	PerformLayout();
	return base.MeasureOverride(constraint);
	}

	#endregion Protected Methods

	#region Public Fields

	public static readonly DependencyProperty ChildHorizontalAlignmentProperty = DependencyProperty.Register(
	"ChildHorizontalAlignment",
	typeof(HorizontalAlignment?),
	typeof(AutoGrid),
	new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsMeasure,
	OnChildHorizontalAlignmentChanged));

	public static readonly DependencyProperty ChildMarginProperty = DependencyProperty.Register(
	"ChildMargin",
	typeof(Thickness?),
	typeof(AutoGrid),
	new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsMeasure, OnChildMarginChanged));

	public static readonly DependencyProperty ChildVerticalAlignmentProperty = DependencyProperty.Register(
	"ChildVerticalAlignment",
	typeof(VerticalAlignment?),
	typeof(AutoGrid),
	new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsMeasure,
	OnChildVerticalAlignmentChanged));

	public static readonly DependencyProperty ColumnCountProperty = DependencyProperty.RegisterAttached(
	"ColumnCount",
	typeof(int),
	typeof(AutoGrid),
	new FrameworkPropertyMetadata(1, FrameworkPropertyMetadataOptions.AffectsMeasure, ColumnCountChanged));

	public static readonly DependencyProperty ColumnsProperty = DependencyProperty.RegisterAttached(
	"Columns",
	typeof(string),
	typeof(AutoGrid),
	new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.AffectsMeasure, ColumnsChanged));

	public static readonly DependencyProperty ColumnWidthProperty = DependencyProperty.RegisterAttached(
	"ColumnWidth",
	typeof(GridLength),
	typeof(AutoGrid),
	new FrameworkPropertyMetadata(GridLength.Auto, FrameworkPropertyMetadataOptions.AffectsMeasure,
	FixedColumnWidthChanged));

	public static readonly DependencyProperty IsAutoIndexingProperty = DependencyProperty.Register(
	"IsAutoIndexing",
	typeof(bool),
	typeof(AutoGrid),
	new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsMeasure));

	public static readonly DependencyProperty OrientationProperty = DependencyProperty.Register(
	"Orientation",
	typeof(Orientation),
	typeof(AutoGrid),
	new FrameworkPropertyMetadata(Orientation.Horizontal, FrameworkPropertyMetadataOptions.AffectsMeasure));

	public static readonly DependencyProperty RowCountProperty = DependencyProperty.RegisterAttached(
	"RowCount",
	typeof(int),
	typeof(AutoGrid),
	new FrameworkPropertyMetadata(1, FrameworkPropertyMetadataOptions.AffectsMeasure, RowCountChanged));

	public static readonly DependencyProperty RowHeightProperty = DependencyProperty.RegisterAttached(
	"RowHeight",
	typeof(GridLength),
	typeof(AutoGrid),
	new FrameworkPropertyMetadata(GridLength.Auto, FrameworkPropertyMetadataOptions.AffectsMeasure,
	FixedRowHeightChanged));

	public static readonly DependencyProperty RowsProperty = DependencyProperty.RegisterAttached(
	"Rows",
	typeof(string),
	typeof(AutoGrid),
	new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.AffectsMeasure, RowsChanged));

	#endregion Public Fields

	#region Public Properties

	/// <summary>
	/// Gets or sets the child horizontal alignment.
	/// </summary>
	/// <value>The child horizontal alignment.</value>
	[Category("Layout")]
	[Description("Presets the horizontal alignment of all child controls")]
	public HorizontalAlignment? ChildHorizontalAlignment
	{
	get => (HorizontalAlignment?)GetValue(ChildHorizontalAlignmentProperty);
	set => SetValue(ChildHorizontalAlignmentProperty, value);
	}

	/// <summary>
	/// Gets or sets the child margin.
	/// </summary>
	/// <value>The child margin.</value>
	[Category("Layout")]
	[Description("Presets the margin of all child controls")]
	public Thickness? ChildMargin
	{
	get => (Thickness?)GetValue(ChildMarginProperty);
	set => SetValue(ChildMarginProperty, value);
	}

	/// <summary>
	/// Gets or sets the child vertical alignment.
	/// </summary>
	/// <value>The child vertical alignment.</value>
	[Category("Layout")]
	[Description("Presets the vertical alignment of all child controls")]
	public VerticalAlignment? ChildVerticalAlignment
	{
	get => (VerticalAlignment?)GetValue(ChildVerticalAlignmentProperty);
	set => SetValue(ChildVerticalAlignmentProperty, value);
	}

	/// <summary>
	/// Gets or sets the column count
	/// </summary>
	[Category("Layout")]
	[Description("Defines a set number of columns")]
	public int ColumnCount
	{
	get => (int)GetValue(ColumnCountProperty);
	set => SetValue(ColumnCountProperty, value);
	}

	/// <summary>
	/// Gets or sets the columns
	/// </summary>
	[Category("Layout")]
	[Description("Defines all columns using comma separated grid length notation")]
	public string Columns
	{
	get => (string)GetValue(ColumnsProperty);
	set => SetValue(ColumnsProperty, value);
	}

	/// <summary>
	/// Gets or sets the fixed column width
	/// </summary>
	[Category("Layout")]
	[Description("Presets the width of all columns set using the ColumnCount property")]
	public GridLength ColumnWidth
	{
	get => (GridLength)GetValue(ColumnWidthProperty);
	set => SetValue(ColumnWidthProperty, value);
	}

	/// <summary>
	/// Gets or sets a value indicating whether the children are automatically indexed.
	/// <remarks>
	/// The default is <c>true</c>.
	/// Note that if children are already indexed, setting this property to <c>false</c> will not remove their indices.
	/// </remarks>
	/// </summary>
	[Category("Layout")]
	[Description("Set to false to disable the auto layout functionality")]
	public bool IsAutoIndexing
	{
	get => (bool)GetValue(IsAutoIndexingProperty);
	set => SetValue(IsAutoIndexingProperty, value);
	}

	/// <summary>
	/// Gets or sets the orientation.
	/// <remarks>The default is Vertical.</remarks>
	/// </summary>
	/// <value>The orientation.</value>
	[Category("Layout")]
	[Description(
	"Defines the directionality of the autolayout. Use vertical for a column first layout, horizontal for a row first layout.")]
	public Orientation Orientation
	{
	get => (Orientation)GetValue(OrientationProperty);
	set => SetValue(OrientationProperty, value);
	}

	/// <summary>
	/// Gets or sets the number of rows
	/// </summary>
	[Category("Layout")]
	[Description("Defines a set number of rows")]
	public int RowCount
	{
	get => (int)GetValue(RowCountProperty);
	set => SetValue(RowCountProperty, value);
	}

	/// <summary>
	/// Gets or sets the fixed row height
	/// </summary>
	[Category("Layout")]
	[Description("Presets the height of all rows set using the RowCount property")]
	public GridLength RowHeight
	{
	get => (GridLength)GetValue(RowHeightProperty);
	set => SetValue(RowHeightProperty, value);
	}

	/// <summary>
	/// Gets or sets the rows
	/// </summary>
	[Category("Layout")]
	[Description("Defines all rows using comma separated grid length notation")]
	public string Rows
	{
	get => (string)GetValue(RowsProperty);
	set => SetValue(RowsProperty, value);
	}

	#endregion Public Properties

	#region Public Methods

	/// <summary>
	/// Handles the column count changed event
	/// </summary>
	public static void ColumnCountChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
	{
	if ((int)e.NewValue < 0)
	return;

	if (d is not AutoGrid grid) return;
	//var grid = d as AutoGrid;

	// look for an existing column definition for the height
	var width = GridLength.Auto;
	if (grid.ColumnDefinitions.Count > 0)
	width = grid.ColumnDefinitions[0].Width;

	// clear and rebuild
	grid.ColumnDefinitions.Clear();
	for (var i = 0; i < (int)e.NewValue; i++)
	grid.ColumnDefinitions.Add(
	new ColumnDefinition { Width = width });
	}

	/// <summary>
	/// Handle the columns changed event
	/// </summary>
	public static void ColumnsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
	{
	if (string.IsNullOrEmpty((string)e.NewValue))
	return;

	if (d is not AutoGrid grid) return;
	//var grid = d as AutoGrid;
	grid.ColumnDefinitions.Clear();

	var defs = Parse((string)e.NewValue);
	foreach (var def in defs)
	grid.ColumnDefinitions.Add(new ColumnDefinition { Width = def });
	}

	/// <summary>
	/// Handle the fixed column width changed event
	/// </summary>
	public static void FixedColumnWidthChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
	{
	if (d is not AutoGrid grid) return;
	//var grid = d as AutoGrid;

	// add a default column if missing
	if (grid.ColumnDefinitions.Count == 0)
	grid.ColumnDefinitions.Add(new ColumnDefinition());

	// set all existing columns to this width
	for (var i = 0; i < grid.ColumnDefinitions.Count; i++)
	grid.ColumnDefinitions[i].Width = (GridLength)e.NewValue;
	}

	/// <summary>
	/// Handle the fixed row height changed event
	/// </summary>
	public static void FixedRowHeightChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
	{
	if (d is not AutoGrid grid) return;
	//var grid = d as AutoGrid;

	// add a default row if missing
	if (grid.RowDefinitions.Count == 0)
	grid.RowDefinitions.Add(new RowDefinition());

	// set all existing rows to this height
	for (var i = 0; i < grid.RowDefinitions.Count; i++)
	grid.RowDefinitions[i].Height = (GridLength)e.NewValue;
	}

	/// <summary>
	/// Parse an array of grid lengths from comma delim text
	/// </summary>
	public static GridLength[] Parse(string text)
	{
	var tokens = text.Split(',');
	var definitions = new GridLength[tokens.Length];
	for (var i = 0; i < tokens.Length; i++)
	{
	var str = tokens[i];
	double value;

	// ratio
	if (str.Contains('*'))
	{
	if (!double.TryParse(str.Replace("*", ""), out value))
	value = 1.0;

	definitions[i] = new GridLength(value, GridUnitType.Star);
	continue;
	}

	// pixels
	if (double.TryParse(str, out value))
	{
	definitions[i] = new GridLength(value);
	continue;
	}

	// auto
	definitions[i] = GridLength.Auto;
	}

	return definitions;
	}

	/// <summary>
	/// Handles the row count changed event
	/// </summary>
	public static void RowCountChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
	{
	if ((int)e.NewValue < 0)
	return;

	if (d is not AutoGrid grid) return;
	//var grid = d as AutoGrid;

	// look for an existing row to get the height
	var height = GridLength.Auto;
	if (grid.RowDefinitions.Count > 0)
	height = grid.RowDefinitions[0].Height;

	// clear and rebuild
	grid.RowDefinitions.Clear();
	for (var i = 0; i < (int)e.NewValue; i++)
	grid.RowDefinitions.Add(
	new RowDefinition { Height = height });
	}

	/// <summary>
	/// Handle the rows changed event
	/// </summary>
	public static void RowsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
	{
	if (string.IsNullOrEmpty((string)e.NewValue))
	return;

	if (d is not AutoGrid grid) return;
	//var grid = d as AutoGrid;
	grid.RowDefinitions.Clear();

	var defs = Parse((string)e.NewValue);
	foreach (var def in defs)
	grid.RowDefinitions.Add(new RowDefinition { Height = def });
	}

	#endregion Public Methods

	#region Private Methods

	/// <summary>
	/// Called when [child horizontal alignment changed].
	/// </summary>
	private static void OnChildHorizontalAlignmentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
	{
	if (d is not AutoGrid grid) return;
	//var grid = d as AutoGrid;
	foreach (UIElement child in grid.Children)
	if (grid.ChildHorizontalAlignment.HasValue)
	child.SetValue(HorizontalAlignmentProperty, grid.ChildHorizontalAlignment);
	else
	child.SetValue(HorizontalAlignmentProperty, DependencyProperty.UnsetValue);
	}

	/// <summary>
	/// Called when [child layout changed].
	/// </summary>
	private static void OnChildMarginChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
	{
	if (d is not AutoGrid grid) return;
	//var grid = d as AutoGrid;
	foreach (UIElement child in grid.Children)
	if (grid.ChildMargin.HasValue)
	child.SetValue(MarginProperty, grid.ChildMargin);
	else
	child.SetValue(MarginProperty, DependencyProperty.UnsetValue);
	}

	/// <summary>
	/// Called when [child vertical alignment changed].
	/// </summary>
	private static void OnChildVerticalAlignmentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
	{
	if (d is not AutoGrid grid) return;
	//var grid = d as AutoGrid;
	foreach (UIElement child in grid.Children)
	if (grid.ChildVerticalAlignment.HasValue)
	child.SetValue(VerticalAlignmentProperty, grid.ChildVerticalAlignment);
	else
	child.SetValue(VerticalAlignmentProperty, DependencyProperty.UnsetValue);
	}

	///// <summary>
	///// Handled the redraw properties changed event
	///// </summary>
	//private static void OnPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
	//{ }

	/// <summary>
	/// Apply child margins and layout effects such as alignment
	/// </summary>
	private void ApplyChildLayout(UIElement child)
	{
	if (ChildMargin != null) child.SetIfDefault(MarginProperty, ChildMargin.Value);
	if (ChildHorizontalAlignment != null)
	child.SetIfDefault(HorizontalAlignmentProperty, ChildHorizontalAlignment.Value);
	if (ChildVerticalAlignment != null) child.SetIfDefault(VerticalAlignmentProperty, ChildVerticalAlignment.Value);
	}

	/// <summary>
	/// Clamp a value to its maximum.
	/// </summary>
	private int Clamp(int value, int max)
	{
	return value > max ? max : value;
	}

	/// <summary>
	/// Perform the grid layout of row and column indexes
	/// </summary>
	private void PerformLayout()
	{
	var fillRowFirst = Orientation == Orientation.Horizontal;
	var rowCount = RowDefinitions.Count;
	var colCount = ColumnDefinitions.Count;

	if (rowCount == 0 \|\| colCount == 0)
	return;

	var position = 0;
	var skip = new bool[rowCount, colCount];
	foreach (UIElement child in Children)
	{
	var childIsCollapsed = child.Visibility == Visibility.Collapsed;
	if (IsAutoIndexing && !childIsCollapsed)
	{
	if (fillRowFirst)
	{
	var row = Clamp(position / colCount, rowCount - 1);
	var col = Clamp(position % colCount, colCount - 1);
	if (skip[row, col])
	{
	position++;
	row = position / colCount;
	col = position % colCount;
	}

	SetRow(child, row);
	SetColumn(child, col);
	position += GetColumnSpan(child);

	var offset = GetRowSpan(child) - 1;
	while (offset > 0) skip[row + offset--, col] = true;
	}
	else
	{
	var row = Clamp(position % rowCount, rowCount - 1);
	var col = Clamp(position / rowCount, colCount - 1);
	if (skip[row, col])
	{
	position++;
	row = position % rowCount;
	col = position / rowCount;
	}

	SetRow(child, row);
	SetColumn(child, col);
	position += GetRowSpan(child);

	var offset = GetColumnSpan(child) - 1;
	while (offset > 0) skip[row, col + offset--] = true;
	}
	}

	ApplyChildLayout(child);
	}
	}

	#endregion Private Methods
	}