ImageUrl.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using SkiaSharp;
using Waher.Content;
using Waher.Layout.Layout2D.Model.Attributes;
 
namespace Waher.Layout.Layout2D.Model.Images
{
    public class ImageUrl : Image
    {
        private StringAttribute url;
        private StringAttribute alt;
 
        public ImageUrl(Layout2DDocument Document, ILayoutElement Parent)
            : base(Document, Parent)
        {
        }
 
        public override string LocalName => "ImageUrl";
 
        public StringAttribute UrlAttribute
        {
            get => this.url;
            set => this.url = value;
        }
 
        public StringAttribute AlternativeAttribute
        {
            get => this.alt;
            set => this.alt = value;
        }
 
        public override Task FromXml(XmlElement Input)
        {
            this.url = new StringAttribute(Input, "url", this.Document);
            this.alt = new StringAttribute(Input, "alt", this.Document);
            return base.FromXml(Input);
        }
 
        public override void ExportAttributes(XmlWriter Output)
        {
            base.ExportAttributes(Output);
 
            this.url?.Export(Output);
            this.alt?.Export(Output);
        }
 
        public override ILayoutElement Create(Layout2DDocument Document, ILayoutElement Parent)
        {
            return new ImageUrl(Document, Parent);
        }
 
        public override void CopyContents(ILayoutElement Destination)
        {
            base.CopyContents(Destination);
 
            if (Destination is ImageUrl Dest)
            {
                Dest.url = this.url?.CopyIfNotPreset(Destination.Document);
                Dest.alt = this.alt?.CopyIfNotPreset(Destination.Document);
            }
        }
 
        protected override async Task<SKImage> LoadImage(DrawingState State)
        {
            EvaluationResult<string> URL = await this.url.TryEvaluate(State.Session);
            if (URL.Ok && !string.IsNullOrEmpty(URL.Result))
                this.StartLoad(URL.Result);
 
            return null;
        }
 
        private async void StartLoad(string URL)
        {
            try
            {
                object Result = await InternetContent.GetAsync(new Uri(URL),
                    new KeyValuePair<string, string>("Accept", "image/*"));
 
                if (Result is SKImage Image)
                {
                    this.image = Image;
                    this.Document.RaiseUpdated(this);
                }
            }
            catch (Exception)
            {
                // Ignore
            }
        }
 
        public override async Task DoMeasureDimensions(DrawingState State)
        {
            EvaluationResult<string> RefId = await this.alt.TryEvaluate(State.Session);
            if (RefId.Ok && this.Document.TryGetElement(RefId.Result, out ILayoutElement Element))
                this.alternative = Element;
 
            await base.DoMeasureDimensions(State);
 
            if (!(this.alternative is null))
                await this.alternative.MeasureDimensions(State);
        }
 
        protected override ILayoutElement GetAlternative(DrawingState State)
        {
            return this.alternative;
        }
 
        private ILayoutElement alternative = null;
 
        public override async Task Draw(DrawingState State)
        {
            if (this.image is null && !(this.alternative is null))
                await this.alternative.DrawShape(State);
 
            await base.Draw(State);
        }
 
        public override void ExportStateAttributes(XmlWriter Output)
        {
            base.ExportStateAttributes(Output);
 
            this.url?.ExportState(Output);
            this.alt?.ExportState(Output);
        }
    }
}