PolyLine.cs

using System.Threading.Tasks;
using System.Xml;
using SkiaSharp;
using Waher.Layout.Layout2D.Model.Attributes;
using Waher.Layout.Layout2D.Model.References;
 
namespace Waher.Layout.Layout2D.Model.Figures
{
    public class PolyLine : Vertices, IDirectedElement
    {
        private StringAttribute head;
        private StringAttribute tail;
 
        public PolyLine(Layout2DDocument Document, ILayoutElement Parent)
            : base(Document, Parent)
        {
        }
 
        public override string LocalName => "PolyLine";
 
        public StringAttribute HeadAttribute
        {
            get => this.head;
            set => this.head = value;
        }
 
        public StringAttribute TailAttribute
        {
            get => this.tail;
            set => this.tail = value;
        }
 
        public override Task FromXml(XmlElement Input)
        {
            this.head = new StringAttribute(Input, "head", this.Document);
            this.tail = new StringAttribute(Input, "tail", this.Document);
 
            return base.FromXml(Input);
        }
 
        public override void ExportAttributes(XmlWriter Output)
        {
            base.ExportAttributes(Output);
 
            this.head?.Export(Output);
            this.tail?.Export(Output);
        }
 
        public override ILayoutElement Create(Layout2DDocument Document, ILayoutElement Parent)
        {
            return new PolyLine(Document, Parent);
        }
 
        public override void CopyContents(ILayoutElement Destination)
        {
            base.CopyContents(Destination);
 
            if (Destination is PolyLine Dest)
            {
                Dest.head = this.head?.CopyIfNotPreset(Destination.Document);
                Dest.tail = this.tail?.CopyIfNotPreset(Destination.Document);
            }
        }
 
        public override async Task DoMeasureDimensions(DrawingState State)
        {
            await base.DoMeasureDimensions(State);
 
            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;
            }
        }
 
        private Shape headElement;
        private Shape tailElement;
 
        public override async Task Draw(DrawingState State)
        {
            if (this.defined)
            {
                SKPaint Pen = await this.GetPen(State);
 
                using (SKPath Path = new SKPath())
                {
                    bool First = true;
 
                    foreach (Vertex V in this.points)
                    {
                        if (First)
                        {
                            Path.MoveTo(V.XCoordinate, V.YCoordinate);
                            First = false;
                        }
                        else
                            Path.LineTo(V.XCoordinate, V.YCoordinate);
                    }
 
                    State.Canvas.DrawPath(Path, Pen);
                }
 
                if (!(this.tailElement is null) || !(this.headElement is null))
                {
                    SKPaint Fill = await this.TryGetFill(State);
                    if (!(Fill is null))
                        Fill = null;
 
                    this.tailElement?.DrawTail(State, this, Pen, Fill);
                    this.headElement?.DrawHead(State, this, Pen, Fill);
                }
            }
 
            await base.Draw(State);
        }
 
        public bool TryGetStart(out float X, out float Y, out float Direction)
        {
            if (!this.defined || this.points is null || this.points.Length < 2)
            {
                X = Y = Direction = 0;
                return false;
            }
 
            Vertex P1 = this.points[0];
            Vertex P2 = this.points[1];
 
            X = P1.XCoordinate;
            Y = P1.YCoordinate;
            Direction = CalcDirection(P1, P2);
 
            return true;
        }
 
        public bool TryGetEnd(out float X, out float Y, out float Direction)
        {
            int c;
 
            if (!this.defined || this.points is null || (c = this.points.Length) < 2)
            {
                X = Y = Direction = 0;
                return false;
            }
 
            Vertex P1 = this.points[c - 2];
            Vertex P2 = this.points[c - 1];
 
            X = P2.XCoordinate;
            Y = P2.YCoordinate;
            Direction = CalcDirection(P1, P2);
 
            return true;
        }
 
        public override void ExportStateAttributes(XmlWriter Output)
        {
            base.ExportStateAttributes(Output);
 
            this.head?.ExportState(Output);
            this.tail?.ExportState(Output);
        }
 
    }
}