LayoutArea.cs

using System.Threading.Tasks;
using System.Xml;
using Waher.Layout.Layout2D.Model.Attributes;
 
namespace Waher.Layout.Layout2D.Model
{
    public enum Overflow
    {
        Clip,
 
        Ignore
    }
 
    public abstract class LayoutArea : LayoutElement
    {
        private LengthAttribute width;
        private LengthAttribute height;
        private LengthAttribute maxWidth;
        private LengthAttribute maxHeight;
        private LengthAttribute minWidth;
        private LengthAttribute minHeight;
        private BooleanAttribute keepAspectRatio;
        private EnumAttribute<Overflow> overflow;
        private ExpressionAttribute onClick;
 
        public LayoutArea(Layout2DDocument Document, ILayoutElement Parent)
            : base(Document, Parent)
        {
        }
 
        public LengthAttribute WidthAttribute
        {
            get => this.width;
            set => this.width = value;
        }
 
        public LengthAttribute HeightAttribute
        {
            get => this.height;
            set => this.height = value;
        }
 
        public LengthAttribute MaxWidthAttribute
        {
            get => this.maxWidth;
            set => this.maxWidth = value;
        }
 
        public LengthAttribute MaxHeightAttribute
        {
            get => this.maxHeight;
            set => this.maxHeight = value;
        }
 
        public LengthAttribute MinWidthAttribute
        {
            get => this.minWidth;
            set => this.minWidth = value;
        }
 
        public LengthAttribute MinHeightAttribute
        {
            get => this.minHeight;
            set => this.minHeight = value;
        }
 
        public BooleanAttribute KeepAspectRatioAttribute
        {
            get => this.keepAspectRatio;
            set => this.keepAspectRatio = value;
        }
 
        public EnumAttribute<Overflow> OverflowAttribute
        {
            get => this.overflow;
            set => this.overflow = value;
        }
 
        public ExpressionAttribute OnClickAttribute
        {
            get => this.onClick;
            set => this.onClick = value;
        }
 
        public override Task FromXml(XmlElement Input)
        {
            this.width = new LengthAttribute(Input, "width", this.Document);
            this.height = new LengthAttribute(Input, "height", this.Document);
            this.maxWidth = new LengthAttribute(Input, "maxWidth", this.Document);
            this.maxHeight = new LengthAttribute(Input, "maxHeight", this.Document);
            this.minWidth = new LengthAttribute(Input, "minWidth", this.Document);
            this.minHeight = new LengthAttribute(Input, "minHeight", this.Document);
            this.keepAspectRatio = new BooleanAttribute(Input, "keepAspectRatio", this.Document);
            this.overflow = new EnumAttribute<Overflow>(Input, "overflow", this.Document);
            this.onClick = new ExpressionAttribute(Input, "onClick", this.Document);
        
            return base.FromXml(Input);
        }
 
        public override void ExportAttributes(XmlWriter Output)
        {
            base.ExportAttributes(Output);
 
            this.width?.Export(Output);
            this.height?.Export(Output);
            this.maxWidth?.Export(Output);
            this.maxHeight?.Export(Output);
            this.minWidth?.Export(Output);
            this.minHeight?.Export(Output);
            this.keepAspectRatio?.Export(Output);
            this.overflow?.Export(Output);
            this.onClick?.Export(Output);
        }
 
        public override void CopyContents(ILayoutElement Destination)
        {
            base.CopyContents(Destination);
 
            if (Destination is LayoutArea Dest)
            {
                Dest.width = this.width?.CopyIfNotPreset(Destination.Document);
                Dest.height = this.height?.CopyIfNotPreset(Destination.Document);
                Dest.maxWidth = this.maxWidth?.CopyIfNotPreset(Destination.Document);
                Dest.maxHeight = this.maxHeight?.CopyIfNotPreset(Destination.Document);
                Dest.minWidth = this.minWidth?.CopyIfNotPreset(Destination.Document);
                Dest.minHeight = this.minHeight?.CopyIfNotPreset(Destination.Document);
                Dest.keepAspectRatio = this.keepAspectRatio?.CopyIfNotPreset(Destination.Document);
                Dest.overflow = this.overflow?.CopyIfNotPreset(Destination.Document);
                Dest.onClick = this.onClick?.CopyIfNotPreset(Destination.Document);
            }
        }
 
        public override async Task DoMeasureDimensions(DrawingState State)
        {
            await base.DoMeasureDimensions(State);
            float a;
 
            EvaluationResult<Length> Length = await this.width.TryEvaluate(State.Session);
            if (Length.Ok)
            {
                a = this.Width ?? 0;
                State.CalcDrawingSize(Length.Result, ref a, true, this);
                this.Width = this.ExplicitWidth = a;
            }
 
            Length = await this.height.TryEvaluate(State.Session);
            if (Length.Ok)
            {
                a = this.Height ?? 0;
                State.CalcDrawingSize(Length.Result, ref a, true, this);
                this.Height = this.ExplicitHeight = a;
            }
 
            Length = await this.minWidth.TryEvaluate(State.Session);
            if (Length.Ok)
            {
                a = this.MinWidth ?? 0;
                State.CalcDrawingSize(Length.Result, ref a, true, this);
                this.MinWidth = a;
            }
 
            Length = await this.maxWidth.TryEvaluate(State.Session);
            if (Length.Ok)
            {
                a = this.MaxWidth ?? 0;
                State.CalcDrawingSize(Length.Result, ref a, true, this);
                this.MaxWidth = a;
            }
 
            Length = await this.minHeight.TryEvaluate(State.Session);
            if (Length.Ok)
            {
                a = this.MinHeight ?? 0;
                State.CalcDrawingSize(Length.Result, ref a, true, this);
                this.MinHeight = a;
            }
 
            Length = await this.maxHeight.TryEvaluate(State.Session);
            if (Length.Ok)
            {
                a = this.MaxHeight ?? 0;
                State.CalcDrawingSize(Length.Result, ref a, true, this);
                this.MaxHeight = a;
            }
        }
 
        public override void ExportStateAttributes(XmlWriter Output)
        {
            base.ExportStateAttributes(Output);
 
            this.width?.ExportState(Output);
            this.height?.ExportState(Output);
            this.maxWidth?.ExportState(Output);
            this.maxHeight?.ExportState(Output);
            this.minWidth?.ExportState(Output);
            this.minHeight?.ExportState(Output);
            this.keepAspectRatio?.ExportState(Output);
            this.overflow?.ExportState(Output);
            this.onClick?.ExportState(Output);
        }
 
    }
}