ShrlAlgoToolkit/WPFDark/StandardControls/Internal/TabPanelInternal.cs

#nullable disable

using System;
using System.Buffers;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;

namespace WPFDark.StandardControls.Internal
{
    // Based on this code
    // https://github.com/dotnet/wpf/blob/master/src/Microsoft.DotNet.Wpf/src/PresentationFramework/System/Windows/Controls/Primitives/TabPanel.cs

    public class TabPanelInternal : TabPanel
    {
        static TabPanelInternal()
        {
            KeyboardNavigation.TabNavigationProperty.OverrideMetadata(typeof(TabPanelInternal), new FrameworkPropertyMetadata(KeyboardNavigationMode.Once));
            KeyboardNavigation.DirectionalNavigationProperty.OverrideMetadata(typeof(TabPanelInternal), new FrameworkPropertyMetadata(KeyboardNavigationMode.Cycle));
        }

        /// <summary>
        /// Updates DesiredSize of the TabPanelInternal.  Called by parent UIElement.  This is the first pass of layout.
        /// </summary>
        /// <remarks>
        /// TabPanelInternal
        /// </remarks>
        /// <param name="constraint">Constraint size is an "upper limit" that TabPanelInternal should not exceed.</param>
        /// <returns>TabPanelInternal' desired size.</returns>
        protected override Size MeasureOverride(Size constraint)
        {
            var contentSize = new Size();
            var tabAlignment = TabStripPlacement;

            _numRows = 1;
            _numHeaders = 0;
            _rowHeight = 0;

            switch (tabAlignment)
            {
                // For top and bottom placement the panel flow its children to calculate the number of rows and
                // desired vertical size
                case Dock.Top:
                case Dock.Bottom:
                {
                    var numInCurrentRow = 0;
                    var currentRowWidth = 0.0;
                    var maxRowWidth = 0.0;

                    foreach (UIElement child in InternalChildren)
                    {
                        if (child.Visibility == Visibility.Collapsed)
                            continue;

                        _numHeaders++;

                        // Helper measures child, and deals with Min, Max, and base Width & Height properties.
                        // Helper returns the size a child needs to take up (DesiredSize or property specified size).
                        child.Measure(constraint);
                        var childSize = GetDesiredSizeWithoutMargin(child);

                        if (_rowHeight < childSize.Height)
                            _rowHeight = childSize.Height;

                        if (currentRowWidth + childSize.Width > constraint.Width && numInCurrentRow > 0)
                        {
                            // If child does not fit in the current row - create a new row
                            if (maxRowWidth < currentRowWidth)
                                maxRowWidth = currentRowWidth;

                            currentRowWidth = childSize.Width;
                            numInCurrentRow = 1;
                            _numRows++;
                        }
                        else
                        {
                            currentRowWidth += childSize.Width;
                            numInCurrentRow++;
                        }
                    }

                    if (maxRowWidth < currentRowWidth)
                        maxRowWidth = currentRowWidth;

                    contentSize.Height = _rowHeight * _numRows;

                    // If we don't have constraint or content width is smaller than constraint width then size to content
                    if (double.IsInfinity(contentSize.Width) || double.IsNaN(contentSize.Width) ||
                        maxRowWidth < constraint.Width)
                        contentSize.Width = maxRowWidth;
                    else
                        contentSize.Width = constraint.Width;
                    break;
                }

                case Dock.Left:
                case Dock.Right:
                {
                    foreach (UIElement child in InternalChildren)
                    {
                        if (child.Visibility == Visibility.Collapsed)
                            continue;

                        _numHeaders++;

                        // Helper measures child, and deals with Min, Max, and base Width & Height properties.
                        // Helper returns the size a child needs to take up (DesiredSize or property specified size).
                        child.Measure(constraint);

                        var childSize = GetDesiredSizeWithoutMargin(child);

                        if (contentSize.Width < childSize.Width)
                            contentSize.Width = childSize.Width;

                        contentSize.Height += childSize.Height;
                    }

                    break;
                }

                default:
                    throw new ArgumentOutOfRangeException();
            }

            // Returns our minimum size & sets DesiredSize.
            return contentSize;
        }

        /// <summary>
        /// TabPanelInternal arranges each of its children.
        /// </summary>
        /// <param name="arrangeSize">Size that TabPanelInternal will assume to position children.</param>
        protected override Size ArrangeOverride(Size arrangeSize)
        {
            var tabAlignment = TabStripPlacement;

            switch (tabAlignment)
            {
                case Dock.Top:
                case Dock.Bottom:
                    ArrangeHorizontal(arrangeSize);
                    break;

                case Dock.Left:
                case Dock.Right:
                    ArrangeVertical(arrangeSize);
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
            }

            return arrangeSize;
        }

        /// <summary>
        /// Override of <seealso cref="UIElement.GetLayoutClip"/>.
        /// </summary>
        /// <returns>Geometry to use as additional clip in case when element is larger then available space</returns>
        protected override Geometry GetLayoutClip(Size layoutSlotSize)
        {
            return null;
        }

        private static Size GetDesiredSizeWithoutMargin(UIElement element)
        {
            var margin = (Thickness) element.GetValue(MarginProperty);
            Size desiredSizeWithoutMargin = default;
            desiredSizeWithoutMargin.Height = Math.Max(0d, element.DesiredSize.Height - margin.Top - margin.Bottom);
            desiredSizeWithoutMargin.Width = Math.Max(0d, element.DesiredSize.Width - margin.Left - margin.Right);
            return desiredSizeWithoutMargin;
        }

        private void GetHeadersSize(Span<double> headerSize)
        {
            var childIndex = 0;

            foreach (UIElement child in InternalChildren)
            {
                if (child.Visibility == Visibility.Collapsed)
                    continue;

                var childSize = GetDesiredSizeWithoutMargin(child);
                headerSize[childIndex] = Math.Floor(childSize.Width);
                childIndex++;
            }
        }

        private void ArrangeHorizontal(Size arrangeSize)
        {
            var numSeparators = _numRows - 1;

            // ReSharper disable MergeConditionalExpression
            var bufferSize =
                Unsafe.SizeOf<double>() * _numHeaders +
                Unsafe.SizeOf<int>() * numSeparators;

            var bufferArray =
                bufferSize >= 512
                    ? ArrayPool<byte>.Shared.Rent(bufferSize)
                    : null;

            var buffer =
                bufferArray != null
                    ? bufferArray.AsSpan(0, bufferSize)
                    : stackalloc byte[bufferSize];
            // ReSharper restore MergeConditionalExpression

            var headerSize = MemoryMarshal.Cast<byte, double>(buffer.Slice(0, Unsafe.SizeOf<double>() * _numHeaders));
            var solution = MemoryMarshal.Cast<byte, int>(buffer.Slice(Unsafe.SizeOf<double>() * _numHeaders, Unsafe.SizeOf<int>() * numSeparators));

            try
            {
                var tabAlignment = TabStripPlacement;
                var isMultiRow = _numRows > 1;
                var activeRow = 0;
                var childOffset = new Vector();

                GetHeadersSize(headerSize);

                // If we have multirows, then calculate the best header distribution
                if (isMultiRow)
                {
                    solution = CalculateHeaderDistribution(arrangeSize.Width, headerSize, solution);
                    activeRow = GetActiveRow(solution);

                    childOffset.Y = tabAlignment switch
                    {
                        // TabPanelInternal starts to layout children depend on activeRow which should be always on bottom (top)
                        // The first row should start from Y = (_numRows - 1 - activeRow) * _rowHeight
                        Dock.Top => ((_numRows - 1 - activeRow) * _rowHeight),
                        Dock.Bottom when activeRow != 0 => ((_numRows - activeRow) * _rowHeight),
                        _ => childOffset.Y
                    };
                }
                else
                {
                    solution = Array.Empty<int>();
                }

                var childIndex = 0;
                var separatorIndex = 0;

                foreach (UIElement child in InternalChildren)
                {
                    if (child.Visibility == Visibility.Collapsed)
                        continue;

                    var margin = (Thickness) child.GetValue(MarginProperty);
                    var leftOffset = margin.Left;
                    var rightOffset = margin.Right;
                    var topOffset = margin.Top;
                    var bottomOffset = margin.Bottom;

                    var lastHeaderInRow = isMultiRow &&
                                          (separatorIndex < solution.Length && solution[separatorIndex] == childIndex ||
                                           childIndex == _numHeaders - 1);

                    //Length left, top, right, bottom;
                    var cellSize = new Size(headerSize[childIndex], _rowHeight);

                    // Align the last header in the row; If headers are not aligned directional nav would not work correctly
                    if (lastHeaderInRow)
                        cellSize.Width = arrangeSize.Width - childOffset.X;

                    child.Arrange(new Rect(childOffset.X, childOffset.Y, cellSize.Width, cellSize.Height));

                    var childSize = cellSize;
                    childSize.Height = Math.Max(0d, childSize.Height - topOffset - bottomOffset);
                    childSize.Width = Math.Max(0d, childSize.Width - leftOffset - rightOffset);

                    // Calculate the offset for the next child
                    childOffset.X += cellSize.Width;

                    if (lastHeaderInRow)
                    {
                        if ((separatorIndex == activeRow && tabAlignment == Dock.Top) ||
                            (separatorIndex == activeRow - 1 && tabAlignment == Dock.Bottom))
                            childOffset.Y = 0d;
                        else
                            childOffset.Y += _rowHeight;

                        childOffset.X = 0d;
                        separatorIndex++;
                    }

                    childIndex++;
                }
            }
            finally
            {
                if (bufferArray != null)
                    ArrayPool<byte>.Shared.Return(bufferArray);
            }
        }

        private void ArrangeVertical(Size arrangeSize)
        {
            var childOffsetY = 0d;

            foreach (UIElement child in InternalChildren)
            {
                if (child.Visibility != Visibility.Collapsed)
                {
                    var childSize = GetDesiredSizeWithoutMargin(child);
                    child.Arrange(new Rect(0, childOffsetY, arrangeSize.Width, childSize.Height));

                    // Calculate the offset for the next child
                    childOffsetY += childSize.Height;
                }
            }
        }

        // Returns the row which contain the child with IsSelected==true
        private int GetActiveRow(Span<int> solution)
        {
            var activeRow = 0;
            var childIndex = 0;

            if (solution.Length > 0)
            {
                foreach (UIElement child in InternalChildren)
                {
                    if (child.Visibility == Visibility.Collapsed)
                        continue;

                    var isActiveTab = (bool) child.GetValue(Selector.IsSelectedProperty);

                    if (isActiveTab)
                        return activeRow;

                    if (activeRow < solution.Length && solution[activeRow] == childIndex)
                        activeRow++;

                    childIndex++;
                }
            }

            // If the is no selected element and alignment is Top  - then the active row is the last row 
            if (TabStripPlacement == Dock.Top)
                activeRow = _numRows - 1;

            return activeRow;
        }

        /*   TabPanelInternal layout calculation:
         
        After measure call we have:
        rowWidthLimit - width of the TabPanelInternal
        Header[0..n-1]  - headers
        headerWidth[0..n-1] - header width
         
        Calculated values:
        numSeparators                       - number of separators between numSeparators+1 rows
        rowWidth[0..numSeparators]           - row width
        rowHeaderCount[0..numSeparators]    - Row Count = number of headers on that row
        rowAverageGap[0..numSeparators]     - Average Gap for the row i = (rowWidth - rowWidth[i])/rowHeaderCount[i]
        currentSolution[0..numSeparators-1] - separator currentSolution[i]=x means Header[x] and h[x+1] are separated with new line
        bestSolution[0..numSeparators-1]    - keep the last Best Solution
        bestSolutionRowAverageGap           - keep the last Best Solution Average Gap

        Between all separators distribution the best solution have minimum Average Gap - 
        this is the amount of pixels added to the header (to justify) in the row

        How does it work:
        First we flow the headers to calculate the number of necessary rows (numSeparators+1).
        That means we need to insert numSeparators separators between n headers (numSeparators<n always).
        For each current state rowAverageGap[1..numSeparators+1] are calculated for each row.
        Current state rowAverageGap = MAX (rowAverageGap[1..numSeparators+1]).
        Our goal is to find the solution with MIN (rowAverageGap).
        On each iteration step we move a header from a previous row to the row with maximum rowAverageGap.
        We continue the iterations only if we move to better solution, i.e. rowAverageGap is smaller.
        Maximum iteration steps are less the number of headers.

        */
        // Input: Row width and width of all headers
        // Output: int array which size is the number of separators and contains each separator position
        private Span<int> CalculateHeaderDistribution(double rowWidthLimit, Span<double> headerWidth, Span<int> bestSolution)
        {
            var numSeparators = _numRows - 1;

            // ReSharper disable MergeConditionalExpression
            var doubleArraySize = _numRows + _numRows + _numRows;
            var intArraySize = numSeparators + _numRows;

            var doubleArray =
                doubleArraySize > 128
                    ? ArrayPool<double>.Shared.Rent(_numRows + _numRows + _numRows)
                    : null;

            var intArray =
                intArraySize > 128
                    ? ArrayPool<int>.Shared.Rent(numSeparators + _numRows)
                    : null;

            var doubleBuffer =
                doubleArray != null
                    ? doubleArray
                    : stackalloc double[doubleArraySize];

            var intBuffer =
                intArray != null
                    ? intArray
                    : stackalloc int[intArraySize];
            // ReSharper restore MergeConditionalExpression

            var rowWidth = doubleBuffer.Slice(0, _numRows);
            var rowAverageGap = doubleBuffer.Slice(_numRows, _numRows);
            var bestSolutionRowAverageGap = doubleBuffer.Slice(_numRows + _numRows, _numRows);
            var currentSolution = intBuffer.Slice(0, numSeparators);
            var rowHeaderCount = intBuffer.Slice(numSeparators, _numRows);

            try
            {
                var bestSolutionMaxRowAverageGap = 0.0;
                var numHeaders = headerWidth.Length;
                var currentRowWidth = 0.0;
                var numberOfHeadersInCurrentRow = 0;
                double currentAverageGap;

                // Initialize the current state; Do the initial flow of the headers
                var currentRowIndex = 0;

                for (var index = 0; index < numHeaders; index++)
                {
                    if (currentRowWidth + headerWidth[index] > rowWidthLimit && numberOfHeadersInCurrentRow > 0)
                    {
                        // if we cannot add next header - flow to next row
                        // Store current row before we go to the next
                        rowWidth[currentRowIndex] = currentRowWidth; // Store the current row width
                        rowHeaderCount[currentRowIndex] = numberOfHeadersInCurrentRow; // For each row we store the number os headers inside
                        currentAverageGap =
                            Math.Max(0d,
                                (rowWidthLimit - currentRowWidth) /
                                numberOfHeadersInCurrentRow); // The amount  of width that should be added to justify the header
                        rowAverageGap[currentRowIndex] = currentAverageGap;
                        currentSolution[currentRowIndex] = index - 1; // Separator points to the last header in the row
                        if (bestSolutionMaxRowAverageGap < currentAverageGap
                        ) // Remember the maximum of all currentAverageGap
                            bestSolutionMaxRowAverageGap = currentAverageGap;

                        // Iterate to next row
                        currentRowIndex++;
                        currentRowWidth = headerWidth[index]; // Accumulate header widths on the same row
                        numberOfHeadersInCurrentRow = 1;
                    }
                    else
                    {
                        currentRowWidth += headerWidth[index]; // Accumulate header widths on the same row
                        // Increase the number of headers only if they are not collapsed (width=0)
                        // ReSharper disable once CompareOfFloatsByEqualityOperator
                        if (headerWidth[index] != 0)
                            numberOfHeadersInCurrentRow++;
                    }
                }

                // If everything  fit in 1 row then exit (no separators needed)
                if (currentRowIndex == 0)
                    return bestSolution.Slice(0, 0);

                // Add the last row
                rowWidth[currentRowIndex] = currentRowWidth;
                rowHeaderCount[currentRowIndex] = numberOfHeadersInCurrentRow;
                currentAverageGap = (rowWidthLimit - currentRowWidth) / numberOfHeadersInCurrentRow;
                rowAverageGap[currentRowIndex] = currentAverageGap;
                if (bestSolutionMaxRowAverageGap < currentAverageGap)
                    bestSolutionMaxRowAverageGap = currentAverageGap;

                currentSolution.CopyTo(bestSolution); // Remember the first solution as initial bestSolution
                rowAverageGap.CopyTo(bestSolutionRowAverageGap); // bestSolutionRowAverageGap is used in ArrangeOverride to calculate header sizes

                // Search for the best solution
                // The exit condition if when we cannot move header to the next row 
                while (true)
                {
                    // Find the row with maximum AverageGap
                    var worstRowIndex = 0; // Keep the row index with maximum AverageGap
                    var maxAg = 0.0;

                    for (var i = 0; i < _numRows; i++) // for all rows
                    {
                        if (maxAg < rowAverageGap[i])
                        {
                            maxAg = rowAverageGap[i];
                            worstRowIndex = i;
                        }
                    }

                    // If we are on the first row - cannot move from previous
                    if (worstRowIndex == 0)
                        break;

                    // From the row with maximum AverageGap we try to move a header from previous row
                    var moveToRow = worstRowIndex;
                    var moveFromRow = moveToRow - 1;
                    var moveHeader = currentSolution[moveFromRow];
                    var movedHeaderWidth = headerWidth[moveHeader];

                    rowWidth[moveToRow] += movedHeaderWidth;

                    // If the moved header cannot fit - exit. We have the best solution already.
                    if (rowWidth[moveToRow] > rowWidthLimit)
                        break;

                    // If header is moved successfully to the worst row
                    // we update the arrays keeping the row state
                    currentSolution[moveFromRow]--;
                    rowHeaderCount[moveToRow]++;
                    rowWidth[moveFromRow] -= movedHeaderWidth;
                    rowHeaderCount[moveFromRow]--;
                    rowAverageGap[moveFromRow] = (rowWidthLimit - rowWidth[moveFromRow]) / rowHeaderCount[moveFromRow];
                    rowAverageGap[moveToRow] = (rowWidthLimit - rowWidth[moveToRow]) / rowHeaderCount[moveToRow];

                    // EvaluateSolution:
                    // If the current solution is better than bestSolution - keep it in bestSolution
                    maxAg = 0;

                    for (var i = 0; i < _numRows; i++) // for all rows
                    {
                        if (maxAg < rowAverageGap[i])
                        {
                            maxAg = rowAverageGap[i];
                        }
                    }

                    if (maxAg < bestSolutionMaxRowAverageGap)
                    {
                        bestSolutionMaxRowAverageGap = maxAg;
                        currentSolution.CopyTo(bestSolution);
                        rowAverageGap.CopyTo(bestSolutionRowAverageGap);
                    }
                }

                // Each header size should be increased so headers in the row stretch to fit the row
                currentRowIndex = 0;

                for (var index = 0; index < numHeaders; index++)
                {
                    headerWidth[index] += bestSolutionRowAverageGap[currentRowIndex];
                    if (currentRowIndex < numSeparators && bestSolution[currentRowIndex] == index)
                        currentRowIndex++;
                }
            }
            finally
            {
                if (doubleArray != null)
                    ArrayPool<double>.Shared.Return(doubleArray);
                
                if (intArray != null)
                    ArrayPool<int>.Shared.Return(intArray);
            }

            return bestSolution;
        }

        private Dock TabStripPlacement => (TemplatedParent is TabControl tc)
            ? tc.TabStripPlacement
            : Dock.Top;

        private int _numRows = 1; // Number of row calculated in measure and used in arrange
        private int _numHeaders; // Number of headers excluding the collapsed items
        private double _rowHeight; // Maximum of all headers height
    }
}