spectre.console/src/Spectre.Console/Widgets/Columns.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Spectre.Console.Rendering;

namespace Spectre.Console;

/// <summary>
/// Renders things in columns.
/// </summary>
public sealed class Columns : Renderable, IPaddable, IExpandable
{
    private readonly List<IRenderable> _items;

    /// <inheritdoc/>
    public Padding? Padding { get; set; } = new Padding(0, 0, 1, 0);

    /// <summary>
    /// Gets or sets a value indicating whether or not the columns should
    /// expand to the available space. If <c>false</c>, the column
    /// width will be auto calculated. Defaults to <c>true</c>.
    /// </summary>
    public bool Expand { get; set; } = true;

    /// <summary>
    /// Initializes a new instance of the <see cref="Columns"/> class.
    /// </summary>
    /// <param name="items">The items to render as columns.</param>
    public Columns(params IRenderable[] items)
        : this((IEnumerable<IRenderable>)items)
    {
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="Columns"/> class.
    /// </summary>
    /// <param name="items">The items to render as columns.</param>
    public Columns(IEnumerable<IRenderable> items)
    {
        if (items is null)
        {
            throw new ArgumentNullException(nameof(items));
        }

        _items = new List<IRenderable>(items);
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="Columns"/> class.
    /// </summary>
    /// <param name="items">The items to render.</param>
    public Columns(IEnumerable<string> items)
    {
        if (items is null)
        {
            throw new ArgumentNullException(nameof(items));
        }

        _items = new List<IRenderable>(items.Select(item => new Markup(item)));
    }

    /// <inheritdoc/>
    protected override Measurement Measure(RenderContext context, int maxWidth)
    {
        var maxPadding = Math.Max(Padding.GetLeftSafe(), Padding.GetRightSafe());

        var itemWidths = _items.Select(item => item.Measure(context, maxWidth).Max).ToArray();
        var columnCount = CalculateColumnCount(maxWidth, itemWidths, _items.Count, maxPadding);
        if (columnCount == 0)
        {
            // Temporary work around for extremely small consoles
            return new Measurement(maxWidth, maxWidth);
        }

        var rows = _items.Count / Math.Max(columnCount, 1);
        var greatestWidth = 0;
        for (var row = 0; row < rows; row += Math.Max(1, columnCount))
        {
            var widths = itemWidths.Skip(row * columnCount).Take(columnCount).ToList();
            var totalWidth = widths.Sum() + (maxPadding * (widths.Count - 1));
            if (totalWidth > greatestWidth)
            {
                greatestWidth = totalWidth;
            }
        }

        return new Measurement(greatestWidth, greatestWidth);
    }

    /// <inheritdoc/>
    protected override IEnumerable<Segment> Render(RenderContext context, int maxWidth)
    {
        var maxPadding = Math.Max(Padding.GetLeftSafe(), Padding.GetRightSafe());

        var itemWidths = _items.Select(item => item.Measure(context, maxWidth).Max).ToArray();
        var columnCount = CalculateColumnCount(maxWidth, itemWidths, _items.Count, maxPadding);
        if (columnCount == 0)
        {
            // Temporary work around for extremely small consoles
            columnCount = 1;
        }

        var table = new Table();
        table.NoBorder();
        table.HideHeaders();
        table.PadRightCell = false;

        if (Expand)
        {
            table.Expand();
        }

        // Add columns
        for (var index = 0; index < columnCount; index++)
        {
            table.AddColumn(new TableColumn(string.Empty)
            {
                Padding = Padding,
                NoWrap = true,
            });
        }

        // Add rows
        for (var start = 0; start < _items.Count; start += columnCount)
        {
            table.AddRow(_items.Skip(start).Take(columnCount).ToArray());
        }

        return ((IRenderable)table).Render(context, maxWidth);
    }

    // Algorithm borrowed from https://github.com/willmcgugan/rich/blob/master/rich/columns.py
    private int CalculateColumnCount(int maxWidth, int[] itemWidths, int columnCount, int padding)
    {
        var widths = new Dictionary<int, int>();
        while (columnCount > 1)
        {
            var columnIndex = 0;
            widths.Clear();

            var exceededTotalWidth = false;
            foreach (var renderableWidth in IterateWidths(itemWidths, columnCount))
            {
                widths[columnIndex] = Math.Max(widths.ContainsKey(columnIndex) ? widths[columnIndex] : 0, renderableWidth);
                var totalWidth = widths.Values.Sum() + (padding * (widths.Count - 1));
                if (totalWidth > maxWidth)
                {
                    columnCount = widths.Count - 1;
                    exceededTotalWidth = true;
                    break;
                }
                else
                {
                    columnIndex = (columnIndex + 1) % columnCount;
                }
            }

            if (!exceededTotalWidth)
            {
                break;
            }
        }

        return columnCount;
    }

    private IEnumerable<int> IterateWidths(int[] itemWidths, int columnCount)
    {
        foreach (var width in itemWidths)
        {
            yield return width;
        }

        if (_items.Count % columnCount != 0)
        {
            for (var i = 0; i < columnCount - (_items.Count % columnCount) - 1; i++)
            {
                yield return 0;
            }
        }
    }
}