Translate.cs

using System.Threading.Tasks;
using System.Xml;
using SkiaSharp;
using Waher.Layout.Layout2D.Model.Attributes;
 
namespace Waher.Layout.Layout2D.Model.Transforms
{
    public class Translate : LinearTrasformation
    {
        private LengthAttribute translateX;
        private LengthAttribute translateY;
 
        public Translate(Layout2DDocument Document, ILayoutElement Parent)
            : base(Document, Parent)
        {
        }
 
        public override string LocalName => "Translate";
 
        public LengthAttribute TranslateXAttribute
        {
            get => this.translateX;
            set => this.translateX = value;
        }
 
        public LengthAttribute TranslateYAttribute
        {
            get => this.translateY;
            set => this.translateY = value;
        }
 
        public override Task FromXml(XmlElement Input)
        {
            this.translateX = new LengthAttribute(Input, "translateX", this.Document);
            this.translateY = new LengthAttribute(Input, "translateY", this.Document);
 
            return base.FromXml(Input);
        }
 
        public override void ExportAttributes(XmlWriter Output)
        {
            base.ExportAttributes(Output);
 
            this.translateX?.Export(Output);
            this.translateY?.Export(Output);
        }
 
        public override ILayoutElement Create(Layout2DDocument Document, ILayoutElement Parent)
        {
            return new Translate(Document, Parent);
        }
 
        public override void CopyContents(ILayoutElement Destination)
        {
            base.CopyContents(Destination);
 
            if (Destination is Translate Dest)
            {
                Dest.translateX = this.translateX?.CopyIfNotPreset(Destination.Document);
                Dest.translateY = this.translateY?.CopyIfNotPreset(Destination.Document);
            }
        }
 
        public override async Task AfterMeasureDimensions(DrawingState State)
        {
            await base.AfterMeasureDimensions(State);
 
            EvaluationResult<Length> L = await this.translateX.TryEvaluate(State.Session);
            if (L.Ok)
                State.CalcDrawingSize(L.Result, ref this.dx, true, this.Parent);
            else
                this.dx = 0;
 
            L = await this.translateY.TryEvaluate(State.Session);
            if (L.Ok)
                State.CalcDrawingSize(L.Result, ref this.dy, false, this.Parent);
            else
                this.dy = 0;
 
            SKMatrix M = SKMatrix.CreateTranslation(this.dx, this.dy);
            this.TransformBoundingBox(M);
        }
 
        private float dx;
        private float dy;
 
        public override async Task Draw(DrawingState State)
        {
            SKMatrix M = State.Canvas.TotalMatrix;
            State.Canvas.Translate(this.dx, this.dy);
 
            await base.Draw(State);
 
            State.Canvas.SetMatrix(M);
        }
 
        public override void ExportStateAttributes(XmlWriter Output)
        {
            base.ExportStateAttributes(Output);
 
            this.translateX?.ExportState(Output);
            this.translateY?.ExportState(Output);
        }
    }
}