Path.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using SkiaSharp;
using Waher.Layout.Layout2D.Exceptions;
using Waher.Layout.Layout2D.Model.Attributes;
using Waher.Layout.Layout2D.Model.Backgrounds;
using Waher.Layout.Layout2D.Model.Figures.SegmentNodes;
using Waher.Layout.Layout2D.Model.References;
 
namespace Waher.Layout.Layout2D.Model.Figures
{
    public class Path : Figure, ISegment, IDirectedElement
    {
        private ISegment[] segments;
        private StringAttribute head;
        private StringAttribute tail;
        private StringAttribute shapeFill;
 
        public Path(Layout2DDocument Document, ILayoutElement Parent)
            : base(Document, Parent)
        {
        }
 
        public override string LocalName => "Path";
 
        public StringAttribute HeadAttribute
        {
            get => this.head;
            set => this.head = value;
        }
 
        public StringAttribute TailAttribute
        {
            get => this.tail;
            set => this.tail = value;
        }
 
        public StringAttribute ShapeFillAttribute
        {
            get => this.shapeFill;
            set => this.shapeFill = value;
        }
 
        public override async Task FromXml(XmlElement Input)
        {
            await base.FromXml(Input);
        
            this.head = new StringAttribute(Input, "head", this.Document);
            this.tail = new StringAttribute(Input, "tail", this.Document);
            this.shapeFill = new StringAttribute(Input, "shapeFill", this.Document);
 
            this.segments = this.GetSegments();
        }
 
        private ISegment[] GetSegments()
        {
            List<ISegment> Segments = null;
 
            if (this.HasChildren)
            {
                foreach (ILayoutElement Child in this.Children)
                {
                    if (Child is ISegment Segment)
                    {
                        if (Segments is null)
                            Segments = new List<ISegment>();
 
                        Segments.Add(Segment);
                    }
                    else
                        throw new LayoutSyntaxException("Not a segment type: " + Child.Namespace + "#" + Child.LocalName);
                }
            }
 
            return Segments?.ToArray();
        }
 
        public override void ExportAttributes(XmlWriter Output)
        {
            base.ExportAttributes(Output);
 
            this.head?.Export(Output);
            this.tail?.Export(Output);
            this.shapeFill?.Export(Output);
        }
 
        public override ILayoutElement Create(Layout2DDocument Document, ILayoutElement Parent)
        {
            return new Path(Document, Parent);
        }
 
        public override void CopyContents(ILayoutElement Destination)
        {
            base.CopyContents(Destination);
 
            if (Destination is Path Dest)
            {
                Dest.head = this.head?.CopyIfNotPreset(Destination.Document);
                Dest.tail = this.tail?.CopyIfNotPreset(Destination.Document);
                Dest.shapeFill = this.shapeFill?.CopyIfNotPreset(Destination.Document);
 
                Dest.segments = Dest.GetSegments();
            }
        }
 
        public override async Task DoMeasureDimensions(DrawingState State)
        {
            await base.DoMeasureDimensions(State);
 
            PathState PathState = new PathState(this, null, false, false);
 
            EvaluationResult<string> RefId = await this.head.TryEvaluate(State.Session);
            if (RefId.Ok &&
                this.Document.TryGetElement(RefId.Result, out ILayoutElement Element) &&
                Element is Shape Shape)
            {
                this.headElement = Shape;
            }
 
            RefId = await this.tail.TryEvaluate(State.Session);
            if (RefId.Ok &&
                this.Document.TryGetElement(RefId.Result, out Element) &&
                Element is Shape Shape2)
            {
                this.tailElement = Shape2;
            }
 
            RefId = await this.shapeFill.TryEvaluate(State.Session);
            if (RefId.Ok &&
                this.Document.TryGetElement(RefId.Result, out Element) &&
                Element is Background Background)
            {
                this.shapeFiller = Background;
            }
 
            if (!(this.segments is null))
            {
                foreach (ISegment Segment in this.segments)
                    await Segment.Measure(State, PathState);
            }
        }
 
        private Shape headElement;
        private Shape tailElement;
        private Background shapeFiller;
 
        public override async Task Draw(DrawingState State)
        {
            SKPaint Fill = await this.TryGetFill(State);
            SKPaint Pen = await this.TryGetPen(State);
 
            bool CalcStart = !(this.tailElement is null);
            bool CalcEnd = !(this.headElement is null);
 
            if (!(this.segments is null))
            {
                using (SKPath Path = new SKPath())
                {
                    PathState PathState = new PathState(this, Path, CalcStart, CalcEnd);
 
                    await this.Draw(State, PathState, Path);
 
                    PathState.FlushSpline();
 
                    if (!(Fill is null))
                        State.Canvas.DrawPath(Path, Fill);
 
                    if (!(Pen is null))
                        State.Canvas.DrawPath(Path, Pen);
                }
            }
 
            if (CalcStart || CalcEnd)
            {
                if (!(this.shapeFiller is null))
                    Fill = this.shapeFiller.Paint;
 
                this.tailElement?.DrawTail(State, this, Pen, Fill);
                this.headElement?.DrawHead(State, this, Pen, Fill);
            }
 
            await base.Draw(State);
        }
 
        public async Task Measure(DrawingState State, PathState PathState)
        {
            if (!(this.segments is null))
            {
                foreach (ISegment Segment in this.segments)
                    await Segment .Measure(State, PathState);
            }
 
            this.hasStart = false;
            this.hasEnd = false;
        }
 
        public async Task Draw(DrawingState State, PathState PathState, SKPath Path)
        {
            if (!(this.segments is null))
            {
                bool CalcStart = PathState.CalcStart;
 
                foreach (ISegment Segment in this.segments)
                {
                    if (Segment.IsVisible)
                    {
                        await Segment .Draw(State, PathState, Path);
 
                        if (CalcStart &&
                            Segment is IDirectedElement DirectedElement &&
                            DirectedElement.TryGetStart(out this.startX, out this.startY, out this.startDirection))
                        {
                            CalcStart = false;
                            this.hasStart = true;
                        }
                    }
                }
 
                if (PathState.CalcEnd)
                {
                    int i = this.segments.Length;
 
                    while (i-- > 0)
                    {
                        if (this.segments[i] is IDirectedElement DirectedElement &&
                            DirectedElement.TryGetEnd(out this.endX, out this.endY, out this.endDirection))
                        {
                            this.hasEnd = true;
                            break;
                        }
                    }
                }
            }
        }
 
        private float startX;
        private float startY;
        private float startDirection;
        private bool hasStart;
        private float endX;
        private float endY;
        private float endDirection;
        private bool hasEnd;
 
        public bool TryGetStart(out float X, out float Y, out float Direction)
        {
            if (this.hasStart)
            {
                X = this.startX;
                Y = this.startY;
                Direction = this.startDirection;
 
                return true;
            }
            else
            {
                X = Y = Direction = 0;
                return false;
            }
        }
 
        public bool TryGetEnd(out float X, out float Y, out float Direction)
        {
            if (this.hasEnd)
            {
                X = this.endX;
                Y = this.endY;
                Direction = this.endDirection;
 
                return true;
            }
            else
            {
                X = Y = Direction = 0;
                return false;
            }
        }
 
        public override void ExportStateAttributes(XmlWriter Output)
        {
            base.ExportStateAttributes(Output);
 
            this.head?.ExportState(Output);
            this.tail?.ExportState(Output);
            this.shapeFill?.ExportState(Output);
        }
 
    }
}