Flexible.cs

using System.Threading.Tasks;
using System.Xml;
using Waher.Layout.Layout2D.Model.Attributes;
 
namespace Waher.Layout.Layout2D.Model.Groups
{
    public enum FlexibleOrder
    {
        HorizontalVertical,
 
        VerticalHorizontal
    }
 
    public enum HorizontalDirection
    {
        LeftRight,
 
        RightLeft
    }
 
    public enum VerticalDirection
    {
        TopDown,
 
        BottomUp
    }
 
    public class Flexible : SpatialDistribution
    {
        private EnumAttribute<FlexibleOrder> order;
        private EnumAttribute<HorizontalDirection> horizontalDirection;
        private EnumAttribute<VerticalDirection> verticalDirection;
        private EnumAttribute<HorizontalAlignment> halign;
        private EnumAttribute<VerticalAlignment> valign;
 
        public Flexible(Layout2DDocument Document, ILayoutElement Parent)
            : base(Document, Parent)
        {
        }
 
        public override string LocalName => "Flexible";
 
        public EnumAttribute<FlexibleOrder> OrderAttribute
        {
            get => this.order;
            set => this.order = value;
        }
 
        public EnumAttribute<HorizontalDirection> HorizontalDirectionAttribute
        {
            get => this.horizontalDirection;
            set => this.horizontalDirection = value;
        }
 
        public EnumAttribute<VerticalDirection> VerticalDirectionAttribute
        {
            get => this.verticalDirection;
            set => this.verticalDirection = value;
        }
 
        public EnumAttribute<HorizontalAlignment> HorizontalAlignmentAttribute
        {
            get => this.halign;
            set => this.halign = value;
        }
 
        public EnumAttribute<VerticalAlignment> VerticalAlignmentAttribute
        {
            get => this.valign;
            set => this.valign = value;
        }
 
        public override Task FromXml(XmlElement Input)
        {
            this.order = new EnumAttribute<FlexibleOrder>(Input, "order", this.Document);
            this.horizontalDirection = new EnumAttribute<HorizontalDirection>(Input, "horizontalDirection", this.Document);
            this.verticalDirection = new EnumAttribute<VerticalDirection>(Input, "verticalDirection", this.Document);
            this.halign = new EnumAttribute<HorizontalAlignment>(Input, "halign", this.Document);
            this.valign = new EnumAttribute<VerticalAlignment>(Input, "valign", this.Document);
 
            return base.FromXml(Input);
        }
 
        public override void ExportAttributes(XmlWriter Output)
        {
            base.ExportAttributes(Output);
 
            this.order?.Export(Output);
            this.horizontalDirection?.Export(Output);
            this.verticalDirection?.Export(Output);
            this.halign?.Export(Output);
            this.valign?.Export(Output);
        }
 
        public override ILayoutElement Create(Layout2DDocument Document, ILayoutElement Parent)
        {
            return new Flexible(Document, Parent);
        }
 
        public override void CopyContents(ILayoutElement Destination)
        {
            base.CopyContents(Destination);
 
            if (Destination is Flexible Dest)
            {
                Dest.order = this.order?.CopyIfNotPreset(Destination.Document);
                Dest.horizontalDirection = this.horizontalDirection?.CopyIfNotPreset(Destination.Document);
                Dest.verticalDirection = this.verticalDirection?.CopyIfNotPreset(Destination.Document);
                Dest.halign = this.halign?.CopyIfNotPreset(Destination.Document);
                Dest.valign = this.valign?.CopyIfNotPreset(Destination.Document);
            }
        }
 
        public override async Task<ICellLayout> GetCellLayout(DrawingState State)
        {
            FlexibleOrder Order = await this.order.Evaluate(State.Session, FlexibleOrder.HorizontalVertical);
            HorizontalDirection HorizontalDirection = await this.horizontalDirection.Evaluate(State.Session, HorizontalDirection.LeftRight);
            VerticalDirection VerticalDirection = await this.verticalDirection.Evaluate(State.Session, VerticalDirection.TopDown);
 
            switch (Order)
            {
                case FlexibleOrder.HorizontalVertical:
                default:
                    float Size = this.ExplicitWidth ?? this.Parent?.InnerWidth ?? State.AreaWidth;
                    HorizontalAlignment HAlignment = await this.halign.Evaluate(State.Session,
                        HorizontalDirection == HorizontalDirection.LeftRight ? HorizontalAlignment.Left : HorizontalAlignment.Right);
 
                    return new FlexibleHorizontalCells(State.Session, Size, HorizontalDirection, VerticalDirection, HAlignment);
 
                case FlexibleOrder.VerticalHorizontal:
                    Size = this.ExplicitHeight ?? this.Parent?.InnerHeight ?? State.AreaHeight;
                    VerticalAlignment VAlignment = await this.valign.Evaluate(State.Session,
                        VerticalDirection == VerticalDirection.TopDown ? VerticalAlignment.Top : VerticalAlignment.Bottom);
 
                    return new FlexibleVerticalCells(State.Session, Size, HorizontalDirection, VerticalDirection, VAlignment);
            }
        }
 
        public override void ExportStateAttributes(XmlWriter Output)
        {
            base.ExportStateAttributes(Output);
 
            this.order?.ExportState(Output);
            this.horizontalDirection?.ExportState(Output);
            this.verticalDirection?.ExportState(Output);
            this.halign?.ExportState(Output);
            this.valign?.ExportState(Output);
        }
 
    }
}