LayoutContainer.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Layout.Layout2D.Model.Attributes;
using Waher.Script;
 
namespace Waher.Layout.Layout2D.Model
{
    public abstract class LayoutContainer : LayoutArea
    {
        private ILayoutElement[] children;
 
        public LayoutContainer(Layout2DDocument Document, ILayoutElement Parent)
            : base(Document, Parent)
        {
        }
 
        public ILayoutElement[] Children
        {
            get => this.children;
            set => this.children = value;
        }
 
        public bool HasChildren => !(this.children is null) && this.children.Length > 0;
 
        public override void Dispose()
        {
            base.Dispose();
 
            if (this.HasChildren)
            {
                foreach (ILayoutElement E in this.children)
                    E.Dispose();
            }
        }
 
        public override async Task FromXml(XmlElement Input)
        {
            await base.FromXml(Input);
 
            List<ILayoutElement> Children = null;
 
            foreach (XmlNode Node in Input.ChildNodes)
            {
                if (Node is XmlElement E)
                {
                    if (Children is null)
                        Children = new List<ILayoutElement>();
 
                    Children.Add(await this.Document.CreateElement(E, this));
                }
            }
 
            this.children = Children?.ToArray();
        }
 
        public override void ExportChildren(XmlWriter Output)
        {
            base.ExportChildren(Output);
 
            if (this.HasChildren)
            {
                foreach (ILayoutElement Child in this.children)
                    Child.ToXml(Output);
            }
        }
 
        public override void CopyContents(ILayoutElement Destination)
        {
            base.CopyContents(Destination);
 
            if (Destination is LayoutContainer Dest)
            {
                if (this.HasChildren)
                {
                    int i, c = this.children.Length;
 
                    ILayoutElement[] Children = new ILayoutElement[c];
 
                    for (i = 0; i < c; i++)
                        Children[i] = this.children[i].Copy(Dest);
 
                    Dest.children = Children;
                }
            }
        }
 
        public override void BeforeMeasureDimensions(DrawingState State)
        {
            this.left0 = this.right0 = this.top0 = this.bottom0 = this.width0 = this.height0 = null;
        }
 
        public override async Task DoMeasureDimensions(DrawingState State)
        {
            await base.DoMeasureDimensions(State);
 
            if (this.HasChildren && this.MeasureChildrenDimensions)
            {
                foreach (ILayoutElement E in this.children)
                {
                    E.BeforeMeasureDimensions(State);
 
                    await E.DoMeasureDimensions(State);
 
                    await E.AfterMeasureDimensions(State);
                    this.IncludeElement(E);
                }
            }
        }
 
        public override Task AfterMeasureDimensions(DrawingState State)
        {
            float f;
 
            if (this.left0.HasValue && this.right0.HasValue)
            {
                f = this.right0.Value - this.left0.Value;
 
                if (!this.width0.HasValue || f > this.width0.Value)
                    this.width0 = f;
            }
 
            if (this.top0.HasValue && this.bottom0.HasValue)
            {
                f = this.bottom0.Value - this.top0.Value;
 
                if (!this.height0.HasValue || f > this.height0.Value)
                    this.height0 = f;
            }
 
            this.Left = this.Right = this.Width = null;
            this.Top = this.Bottom = this.Height = null;
 
            if (this.width0.HasValue || this.ExplicitWidth.HasValue)
            {
                this.Width = this.ExplicitWidth ?? this.width0;
                if (this.left0.HasValue)
                    this.Left = this.left0;
                else
                    this.Right = this.right0;
            }
            else
            {
                this.Right = this.right0;
                this.Left = this.left0;
            }
 
            if (this.height0.HasValue || this.ExplicitHeight.HasValue)
            {
                this.Height = this.ExplicitHeight ?? this.height0;
                if (this.top0.HasValue)
                    this.Top = this.top0;
                else
                    this.Bottom = this.bottom0;
            }
            else
            {
                this.Bottom = this.bottom0;
                this.Top = this.top0;
            }
 
            return Task.CompletedTask;
        }
 
        private float? left0;
        private float? right0;
        private float? top0;
        private float? bottom0;
        private float? width0;
        private float? height0;
 
        protected void IncludeElement(ILayoutElement Element)
        {
            float? X = Element.Left;
            float? Y = Element.Top;
            float? V;
 
            if (X.HasValue && Y.HasValue)
                this.IncludePoint(X.Value, Y.Value);
 
            V = Element.Width;
            if (!this.width0.HasValue || (V.HasValue && V.Value > this.width0.Value))
                this.width0 = V;
 
            X = Element.Right;
            Y = Element.Bottom;
 
            if (X.HasValue && Y.HasValue)
                this.IncludePoint(X.Value, Y.Value);
 
            V = Element.Height;
            if (!this.height0.HasValue || (V.HasValue && V.Value > this.height0.Value))
                this.height0 = V;
        }
 
        protected virtual bool MeasureChildrenDimensions => true;
 
        public override void MeasurePositions(DrawingState State)
        {
            base.MeasurePositions(State);
 
            if (this.HasChildren && this.MeasureChildrenPositions)
            {
                foreach (ILayoutElement E in this.children)
                    E.MeasurePositions(State);
            }
        }
 
        protected virtual bool MeasureChildrenPositions => true;
 
        protected void IncludePoint(float X, float Y, float RX, float RY, float Angle)
        {
            float Px = (float)(X + RX * Math.Cos(Angle * DegreesToRadians));
            float Py = (float)(Y + RY * Math.Sin(Angle * DegreesToRadians));
 
            this.IncludePoint(Px, Py);
        }
 
        public void IncludePoint(float X, float Y)
        {
            if (!this.left0.HasValue || X < this.left0.Value)
                this.left0 = X;
 
            if (!this.right0.HasValue || X > this.right0.Value)
                this.right0 = X;
 
            if (!this.top0.HasValue || Y < this.top0.Value)
                this.top0 = Y;
 
            if (!this.bottom0.HasValue || Y > this.bottom0.Value)
                this.bottom0 = Y;
        }
 
        protected async Task<CalculatedPoint> IncludePoint(DrawingState State, LengthAttribute XAttribute,
            LengthAttribute YAttribute, StringAttribute RefAttribute, float X, float Y)
        {
            CalculatedPoint Result = await this.CalcPoint(State, XAttribute, YAttribute, RefAttribute, X, Y);
            if (Result.Ok)
                this.IncludePoint(Result.X, Result.Y);
            
            return Result;
        }
 
        public override async Task Draw(DrawingState State)
        {
            if (this.HasChildren)
            {
                foreach (ILayoutElement E in this.children)
                {
                    if (E.IsVisible)
                        await E.Draw(State);
                }
            }
        }
 
        public override async Task RegisterIDs(Variables Session)
        {
            await base.RegisterIDs(Session);
 
            if (this.HasChildren)
            {
                foreach (ILayoutElement E in this.children)
                    await E.RegisterIDs(Session);
            }
        }
 
        public override void ExportStateChildren(XmlWriter Output)
        {
            base.ExportStateChildren(Output);
 
            if (this.HasChildren)
            {
                foreach (ILayoutElement Child in this.children)
                    Child.ExportState(Output);
            }
        }
 
    }
}