inabox/inabox.wpf/DynamicGrid/UIComponent/IDynamicGridGridUIComponent.cs

using ICSharpCode.AvalonEdit.Indentation;
using InABox.Clients;
using InABox.Core;
using sun.tools.tree;
using Syncfusion.Data;
using Syncfusion.UI.Xaml.Grid;
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Forms.VisualStyles;

namespace InABox.DynamicGrid;

public interface IDynamicGridUIComponentColumn
{
    double GetWidth(IDynamicGridGridUIComponent component);

    DynamicGridColumnWidthUnitType GetWidthUnit(IDynamicGridGridUIComponent component);
}
public class DynamicGridColumnUIComponentColumn(DynamicColumnBase column) : IDynamicGridUIComponentColumn
{
    public DynamicColumnBase Column { get; set; } = column;

    public double GetWidth(IDynamicGridGridUIComponent component)
    {
        if (Column is DynamicImageColumn dic)
        {
            return component.RowHeight;
        }
        else if (Column is DynamicActionColumn dac)
        {
            return dac.Width;
        }
        else if (Column is DynamicGridColumn dgc)
        {
            return dgc.Width;
        }
        else
        {
            return 0;
        }
    }

    public DynamicGridColumnWidthUnitType GetWidthUnit(IDynamicGridGridUIComponent component)
    {
        if (Column is DynamicImageColumn dic)
        {
            return DynamicGridColumnWidthUnitType.Pixel;
        }
        else if (Column is DynamicActionColumn dac)
        {
            return DynamicGridColumnWidthUnitType.Pixel;
        }
        else if (Column is DynamicGridColumn dgc)
        {
            return dgc.Width == 0 ? DynamicGridColumnWidthUnitType.Star : dgc.WidthUnit;
        }
        else
        {
            return 0;
        }
    }
}

public interface IDynamicGridGridUIComponent
{
    IList<IDynamicGridUIComponentColumn> ColumnList { get; }

    int RowHeight { get; }
}

internal static class DynamicGridGridUIComponentExtension
{
    public static IEnumerable<KeyValuePair<int, double>> CalculateColumnSizes(this IDynamicGridGridUIComponent component, double width, bool manualautosize = true)
    {
        var fAvailWidth = width - (SystemParameters.VerticalScrollBarWidth);
        
        //if (Data.Rows.Count * (DataGrid.RowHeight + 1) + DataGrid.HeaderRowHeight > height + 0.5F)
        //if (height < DataGrid.AutoScroller.VScrollBar.Maximum)
        //    fAvailWidth -= (SystemParameters.VerticalScrollBarWidth + 0.75);


        var fCurWidth = 0.0;
        var autoColumnTotal = 0.0;

        var colWidths = new double[component.ColumnList.Count];
        var units = new DynamicGridColumnWidthUnitType[component.ColumnList.Count];
        for (var i = 0; i < component.ColumnList.Count; i++)
        {
            var col = component.ColumnList[i];
            var unit = col.GetWidthUnit(component);
            var colWidth = col.GetWidth(component);
            if(unit == DynamicGridColumnWidthUnitType.Star && colWidth == 0)
            {
                colWidth = 1;
            }
            colWidths[i] = colWidth;
            units[i] = unit;

            if (unit != DynamicGridColumnWidthUnitType.Star)
                fCurWidth += Math.Max(0.0F, colWidth);
            else
                autoColumnTotal += colWidth;
        }

        if (manualautosize && autoColumnTotal > 0)
        {
            var fAutoWidth = (fAvailWidth - fCurWidth) / autoColumnTotal;
            for (var i = 0; i < component.ColumnList.Count; i++)
                if (units[i] == DynamicGridColumnWidthUnitType.Star)
                    colWidths[i] = Math.Max(fAutoWidth * colWidths[i], 100);
        }

        return colWidths.WithIndex();
    }

    public static int DesiredWidth(this IDynamicGridGridUIComponent component)
    {
        var result = 0;
        for (var i = 0; i < component.ColumnList.Count; i++)
        {
            var col = component.ColumnList[i];
            var colWidth = col.GetWidth(component);
            result += colWidth > 0 ? (int)Math.Round(colWidth) : 300;
        }

        return result;
    }

    private static Dictionary<Type, Type>? _editorColumnMap;
    private static Dictionary<Type, Type> EditorColumnMap
    {
        get
        {
            _editorColumnMap ??= CoreUtils.Entities.Where(x => x.IsClass && x.HasInterface<IDynamicGridEditorColumn>()).Select(x =>
            {
                var def = x.GetSuperclassDefinition(typeof(DynamicGridEditorColumn<,,>))!;
                return new KeyValuePair<Type, Type>(def.GenericTypeArguments[0], x);
            }).ToDictionary();
            return _editorColumnMap;
        }
    }

    public static bool CreateEditorColumn<T>(this IDynamicGridGridUIComponent component, DynamicGridColumn column,
        [NotNullWhen(true)] out IDynamicGridEditorColumn? newcol)
    {
        newcol = null;

        if (EditorColumnMap.TryGetValue(column.Editor.GetType(), out var colType))
        {
            if(colType.GetInterfaceDefinition(typeof(IDynamicGridEditorColumn<>)) is Type genericInterface)
            {
                newcol = Activator.CreateInstance(colType.MakeGenericType(typeof(T)), column) as IDynamicGridEditorColumn;
            }
            else
            {
                newcol = Activator.CreateInstance(colType, column) as IDynamicGridEditorColumn;
            }
            if(newcol is IDynamicGridEditorColumn gridCol)
            {
                gridCol.UpdateUIComponent(component);
            }
            return newcol is not null;
        }
        else
        {
            return false;
        }
    }

    public static bool CreateEditorColumn(this IDynamicGridGridUIComponent component, DynamicGridColumn column,
        [NotNullWhen(true)] out IDynamicGridEditorColumn? newcol)
    {
        newcol = null;

        if (EditorColumnMap.TryGetValue(column.Editor.GetType(), out var colType))
        {
            if(colType.GetInterfaceDefinition(typeof(IDynamicGridEditorColumn<>)) is not Type genericInterface)
            {
                newcol = Activator.CreateInstance(colType, column) as IDynamicGridEditorColumn;
            }
            if(newcol is IDynamicGridEditorColumn gridCol)
            {
                gridCol.UpdateUIComponent(component);
            }
            return newcol is not null;
        }
        else
        {
            return false;
        }
    }

    private static bool FilterByPredicate(CoreRow row, string column, FilterPredicate predicate)
    {
        var value = row[column];
        var vStr = value?.ToString()?.ToLower() ?? "";
        var pValue = predicate.FilterValue;
        var pStr = pValue?.ToString()?.ToLower() ?? "";
        return predicate.FilterType switch
        {
            FilterType.Contains => vStr.Contains(pStr),
            FilterType.EndsWith => vStr.EndsWith(pStr),
            FilterType.Equals => vStr.Equals(pStr),
            FilterType.GreaterThan => vStr.CompareTo(pStr) > 0,
            FilterType.GreaterThanOrEqual => vStr.CompareTo(pStr) >= 0,
            FilterType.LessThan => vStr.CompareTo(pStr) < 0,
            FilterType.LessThanOrEqual => vStr.CompareTo(pStr) <= 0,
            FilterType.NotContains => !vStr.Contains(pStr),
            FilterType.NotEndsWith => !vStr.EndsWith(pStr),
            FilterType.NotEquals => !vStr.Equals(pStr),
            FilterType.NotStartsWith => !vStr.StartsWith(pStr),
            FilterType.StartsWith => vStr.StartsWith(pStr),
            _ => true,
        };
    }

    public static Func<CoreRow, bool>? ConvertColumnPredicates(DynamicGridColumn gridColumn, IEnumerable<FilterPredicate> predicates)
    {
        Func<CoreRow, bool>? rowPredicate = null;
        foreach (var predicate in predicates)
        {
            var p = (CoreRow row) => FilterByPredicate(row, gridColumn.ColumnName, predicate);
            if(rowPredicate is null)
            {
                rowPredicate = p;
            }
            else
            {
                var prevP = rowPredicate;
                if(predicate.PredicateType == PredicateType.And)
                {
                    rowPredicate = r => prevP(r) && p(r);
                }
                else
                {
                    rowPredicate = r => prevP(r) || p(r);
                }
            }
        }
        return rowPredicate;
    }
}