Pen.cs

using System;
using System.Threading.Tasks;
using System.Xml;
using SkiaSharp;
using Waher.Layout.Layout2D.Model.Attributes;
 
namespace Waher.Layout.Layout2D.Model.Pens
{
    public abstract class Pen : LayoutElement
    {
        private LengthAttribute width;
        private EnumAttribute<SKStrokeCap> cap;
        private EnumAttribute<SKStrokeJoin> join;
        private LengthAttribute miter;
 
        protected SKPaint paint;
 
        public Pen(Layout2DDocument Document, ILayoutElement Parent)
            : base(Document, Parent)
        {
        }
 
        public override void Dispose()
        {
            base.Dispose();
 
            this.paint?.Dispose();
            this.paint = null;
        }
 
        public SKPaint Paint => this.paint;
 
        public LengthAttribute WidthAttribute
        {
            get => this.width;
            set => this.width = value;
        }
 
        public EnumAttribute<SKStrokeCap> CapAttribute
        {
            get => this.cap;
            set => this.cap = value;
        }
 
        public EnumAttribute<SKStrokeJoin> JoinAttribute
        {
            get => this.join;
            set => this.join = value;
        }
 
        public LengthAttribute MiterAttribute
        {
            get => this.miter;
            set => this.miter = value;
        }
 
        public override Task FromXml(XmlElement Input)
        {
            this.width = new LengthAttribute(Input, "width", this.Document);
            this.cap = new EnumAttribute<SKStrokeCap>(Input, "cap", this.Document);
            this.join = new EnumAttribute<SKStrokeJoin>(Input, "join", this.Document);
            this.miter = new LengthAttribute(Input, "miter", this.Document);
 
            return base.FromXml(Input);
        }
 
        public override void ExportAttributes(XmlWriter Output)
        {
            base.ExportAttributes(Output);
 
            this.width?.Export(Output);
            this.cap?.Export(Output);
            this.join?.Export(Output);
            this.miter?.Export(Output);
        }
 
        public override void CopyContents(ILayoutElement Destination)
        {
            base.CopyContents(Destination);
 
            if (Destination is Pen Dest)
            {
                Dest.width = this.width?.CopyIfNotPreset(Destination.Document);
                Dest.cap = this.cap?.CopyIfNotPreset(Destination.Document);
                Dest.join = this.join?.CopyIfNotPreset(Destination.Document);
                Dest.miter = this.miter?.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.penWidth ?? 0;
                State.CalcDrawingSize(Length.Result, ref a, true, (ILayoutElement)this);
                this.penWidth = a;
            }
            else
                this.penWidth = null;
 
            EvaluationResult<SKStrokeCap> Cap = await this.cap.TryEvaluate(State.Session);
            if (Cap.Ok)
                this.penCap = Cap.Result;
            else
                this.penCap = null;
 
            EvaluationResult<SKStrokeJoin> Join = await this.join.TryEvaluate(State.Session);
            if (Join.Ok)
                this.penJoin = Join.Result;
            else
                this.penJoin = null;
 
            Length = await this.miter.TryEvaluate(State.Session);
            if (Length.Ok)
            {
                a = this.penMiter ?? 0;
                State.CalcDrawingSize(Length.Result, ref a, true, (ILayoutElement)this);
                this.penMiter = a;
            }
            else
                this.penMiter = null;
        }
 
        protected float? penWidth;
 
        protected SKStrokeCap? penCap;
 
        protected SKStrokeJoin? penJoin;
 
        protected float? penMiter;
 
        public override void ExportStateAttributes(XmlWriter Output)
        {
            base.ExportStateAttributes(Output);
 
            this.width?.ExportState(Output);
            this.cap?.ExportState(Output);
            this.join?.ExportState(Output);
            this.miter?.ExportState(Output);
        }
 
    }
}